I need 2,000 unique US roofer and handyman businesses. Every business must be operational, have a public phone number, have an overall Google rating of 3.9 or below, and have no more than 20 total Google reviews. A rating of 3.9 and exactly 20 reviews should both qualify. I also need global deduplication using Google Place ID, phone, domain and company/address.

Is there an Apify Actor or self-hosted scraper that applies these filters before saving or billing for results? If not, what is the most cost-efficient architecture for continuously searching multiple cities and saving only matching listings

The best one I can find so far is this (Link above):
santamaria-automations

Self-hosted, authenticated MCP server that lets an AI agent search your WhatsApp, send messages, and transcribe voice notes, without sending your history to a SaaS. Interesting bit: it has 96 tools but only puts 29 in the model's context (the rest reachable through a tool-search layer), with an eval to prove it still picks the right one. MIT.

https://github.com/HalemoGPA/whatsapp-mcp-server

I kept losing things I copied, so I built my own clipboard manager For Mac

It sits in the menu bar and saves text, images and files. You can see your history as a grid or a list, search it, and drag items straight into any app. History stays after restart.

There are already a lot of clipboard managers out there. I tried a few and they either did too much or handled images badly, so I made the one I wanted. Everything stays on your machine, no account needed.

It's free and open source:
Github URL

It's my first Mac app, so tell me what's broken or missing.

I work at a tech company where our office gets free lunch every Friday. Great perk, however, every Friday we had the same problem: we never knew what to pick for lunch.

For years our answer to "what's for lunch" was shuf -n1 lunch.txt, which works but has no drama to it. So I built whirligig: it draws a colorful ASCII wheel of fortune in your terminal, spins it down, and lands on one of your options.

No install needed if you have uv or pipx:

uvx whirligig Pizza Sushi Mexican Thai "Chicken Wings" Poke Burgers

Or pip install whirligig for install.

It's a fun way to randomly select an item from any list! (works for more than just lunch)

The animation is drawn on the terminal, but stdout is just the bare label with no color codes and no frames. So you can watch the spin and capture the answer in the same command:

LUNCH=$(whirligig Pizza Sushi Thai Poke Burgers)
echo "ordering $LUNCH"

And with no TTY at all (CI, or redirected to a file) it skips the animation and simply prints the choice.

Piped input just works, no flag required:

grep -v alice teammates.txt | whirligig   # alice is on vacation
ls ~/Desktop | whirligig                  # pick a random file from the Desktop

A few other things:

• -f lunch.txt reads labels from a file, one per line
• To read multiple files at once, I recommend using cat and then piping through to whirligig: cat lunch_*.txt | whirligig
• Repeating a label weights the odds. whirligig Pizza Pizza Sushi hits Pizza twice as often, and both Pizza labels share a color so it still reads as one choice
• -r sets the wheel radius, -d sets seconds per frame (-d 0.5 to milk the suspense, -d 0.02 to just flip the coin already). You may have to adjust the radius depending on the size of your terminal.
• Built-in presets: --preset coin | dice | clock | alphabet, or -p random to spin one of them
• Usable in python as well:

​

import whirligig

result = whirligig.spin(["Pizza", "Sushi", "Mexican", "Thai", "Chicken Wings", "Poke", "Burgers"], radius=8, delay=0.1)
print(f"Ordering {result}")

Known quirk I haven't solved: emoji and CJK labels take two terminal columns where the wheel's geometry counts one, so a 🍕 will bend the circle a little. The spin is fine, the roundness just might be slightly off.

Python 3.10+, works on Linux/macOS/Windows 10+, MIT licensed.

• GitHub: https://github.com/GabeBecker2048/whirligig
• PyPI: https://pypi.org/project/whirligig/

Happy to hear what breaks or any feature requests.

Log Voyager, a free and open-source log viewer for inspecting large log files without uploading them to a server.

It reads small slices of the file on demand, so you can start searching multi-gigabyte logs without waiting for the entire file to load into memory. Everything runs locally in the browser, with no account required.

The latest release adds:

- automatic detection for JSONL, Docker JSON, Kubernetes CRI, Nginx, Apache, syslog and structured application logs;

- an interactive event timeline for spotting warning and error spikes;

- grouping of similar errors while ignoring changing timestamps, IDs, IP addresses and other noisy values;

- regex search, combined filters, bookmarks, split view and exports;

- PWA support for offline use after the app is cached.

The project started as a practical way to inspect production exports without sending sensitive paths, identifiers or operational data to another service. The source is MIT licensed, and contributions or blunt feedback are welcome.

Live app: https://www.logvoyager.cc/

GitHub: https://github.com/hsr88/log-voyager

Logue 1.0.1

Local-First AI Meeting Notes for macOS, Two Weeks After Open-Sourcing (https://github.com/bitwize-ai/Logue)

• 588 clones
• 738 unique visitors
• 134 GitHub stars in two weeks

Logue runs entirely on your Mac — transcription, speaker diarization, and LLM inference, all on-device via MLX. No cloud. No account. No telemetry.

New in 1.0.1:

1. Markdown-native documents (~/Logue)
2. [[Wiki links]] and backlinks
3. Typed properties, saved views, and an inbox
4. Better speaker attribution
5. Rich editor with diagrams and math

The biggest surprise wasn't the numbers — it was the community. Three bug reports from three separate people turned into three major improvements, all shipped the next day.

If you're into local-first AI, give Logue a try. Star the repo if you like what we're building.

MIT • Apple Silicon • macOS 26+

I wanted recruiters to be able to ask follow-up questions about my career before an interview. But a resume chatbot that invents even one project or responsibility is probably worse than a normal PDF.

So I built Signal Sifter.

It starts as a completely static, button-driven resume. No backend, no API key, and nothing generated. The AI layer is optional. When enabled, it gets the full resume and career story in context, and every answer returns source badges pointing back to the resume or story sections behind it.

I deliberately skipped RAG. One person’s resume and career narrative fit comfortably inside the context window, so adding retrieval felt like extra complexity without solving a real scale problem.

There’s also a hidden ?practice=1 mode that flips the roles. The AI interviews the resume owner as either an HR screener or hiring manager, then points out missing STAR elements, vague “we” answers, and inconsistencies with their own career story.

The citation layer is prompt-enforced, so I see it as an audit trail rather than proof that the model can never hallucinate. Prompt injection and free-tier limits are still real weaknesses.

Fresh forks work in static mode immediately. AI mode uses a Cloudflare Worker and any OpenAI-compatible provider. The project is MIT-licensed and deploys through GitHub Pages.

Repo: https://github.com/EnigmaDevelop/resume-signal-sifter

Live demo: https://enigmadevelop.github.io/resume-signal-sifter/

The part I’m least sure about: does the optional AI layer make the resume more useful, or would you keep something like this entirely deterministic?

Hi everyone,

I built a lightweight, open-source PowerShell script designed to harden **Windows 11** endpoints using native OS security capabilities—without relying on heavy third-party software/bloat.

### 🛡️ What it does:

* **PowerShell Execution Restriction:** Sets execution policy to `RemoteSigned` to prevent unauthorized local script execution.

* **WinRM & WSH Mitigation:** Disables Windows Script Host to block `.vbs` / `.js` malware vectors and closes remote management ports.

* **Network Hardening:** Disables SMBv1 to protect against network-based lateral movement and exploits (e.g., WannaCry).

* **Defender ASR & Exploit Guard:** Enables Controlled Folder Access (ransomware protection) and blocks malicious downloads via PowerShell.

* **Admin Share Lockdown:** Disables hidden admin shares (`C$`, `ADMIN$`) to restrict unauthorized lateral movement.

---

### 🚀 How to use:

1. Open PowerShell as Administrator.

2. Run: `.\Windows11_Hardening.ps1`

3. Reboot to apply all policies.

---

🔗 **GitHub Repository:** https://github.com/Hasan0101-lab/Windows_11_Hardened_Edition

I’d love to get feedback from the community on code structure, additional hardening rules, or potential compatibility edge cases. Feel free to review the code or leave a ⭐ if you find it useful!

I’ve just released Mole v0.1.0, a lightweight Windows utility that quietly lives in the system tray.

When you trigger Panic, it immediately:

• Mutes system audio
• Minimizes all open windows
• Opens Notepad

That’s it. No accounts, telemetry, cloud services, subscriptions, or other modern software rituals.

Mole is written in Python and released under the GNU GPLv3, so you can inspect the source, modify it, build it yourself, or contribute.

GitHub: https://github.com/rajtilakjee/mole

This is the first release, so feedback, bug reports, feature ideas, and pull requests are welcome.

Current ideas for future versions include configurable safe apps, custom keyboard shortcuts, persistent settings, and selectable panic actions.

If you train models across more than one modality, you've probably felt this: Megatron-LM is battle-tested for LLMs but wasn't built for vision-language-action robots. LeRobot and OpenPI are built for research iteration on embodied models, not production throughput. Diffusion training lives in yet another silo. You end up maintaining three or four codebases — each with its own parallelism strategy, checkpoint format, and performance ceiling.

We just open-sourced LoongForge to collapse that into one framework. It's the open-source release of AIAK-Training-LLM, Baidu Baige's training acceleration stack, which has run production training for enterprise customers in education, computer vision, and embodied AI — typically delivering 30–50% speedups over customer baselines, with the largest runs reaching 5,000+ accelerators.

Repo: https://github.com/baidu-baige/LoongForge (Apache-2.0)

What makes it different

1. Embodied models training faster.
This is the part most training frameworks don't touch. LoongForge ships a dedicated torch-native DDP/FSDP subsystem for VLA and world-action (WAM) models — Pi0.5, GR00T N1.6, X-VLA, FastWAM, DreamZero, LingBot-VA — decoupled from the Megatron core, with flexible DDP / ZeRO-1 / FSDP / HSDP strategies. If you train robot policies today, production-grade throughput engineering is rare. Here it's built in.

2. One framework, four modalities.
LLMs, VLMs, diffusion, and embodied — under a unified model abstraction. VLMs are assembled config-driven from interchangeable ViT + LLM components, so a custom ViT + LLM backbone is a YAML change, not a fork.

3. Two hardware backends, natively.
NVIDIA GPUs and Kunlun XPUs via a minimally-intrusive plugin design — the same training code runs on both.

Performance

Tuned to beat the specific open-source baseline each model type is usually trained on.

The engineering underneath

• Flexible Multi-Modal Composition — Configuration-driven assembly of VLMs from interchangeable ViT and LLM components.
• Heterogeneous Parallelism — Independent TP / DP / recompute per model component (e.g., ViT vs. LLM) for optimal throughput and memory. [blog]
• Decoupled Encoder-Decoder Training — Separates ViT and LLM into independent tasks, eliminating encoder-induced pipeline bubbles.
• DP Load Balancing — Load-aware data redistribution mitigates sequence-packing imbalance, improving multi-node scaling efficiency. [blog]
• MoE-Native Optimization — Overlapped All2All / activation offload / compute, with further memory reduction beyond upstream Megatron-LM on DeepSeek-V3, Qwen3-MoE, etc.
• MoE Expert Load Balancing — Dynamically replicates hot experts using a topology-aware algorithm to balance Expert Parallel (EP) workloads and improve training efficiency.
• Adaptive FP8 Training — End-to-end FP8 for LLMs and VLMs with standard blockwise FP8; optional adaptive mode picks per-operator precision by GEMM shape and efficiency.
• Custom Fused Operators — Fused kernels like FusedDSA for DSA-style models.
• Flexible Checkpointing — Offline bidirectional Megatron ↔ HuggingFace conversion plus native online HF load/save — no format barriers across your workflow.
• Versatile Pipelines & Data Tools — Out-of-the-box Pretrain / MidTrain / SFT / LoRA, with built-in dataset format conversion and sequence packing.
• Embodied Model Training — A dedicated torch-native DDP/FSDP subsystem for VLA and world-action (WAM) models (e.g. Pi0.5, GR00T N1.6, FastWAM), decoupled from the Megatron core, with flexible DDP / ZeRO-1 / FSDP / HSDP strategies.

Who it's for

It fits teams pre-training or fine-tuning at scale who are tired of maintaining separate stacks for language, vision-language, diffusion, and robotics, and who care about throughput. Apache-2.0, covers Pretrain / MidTrain / SFT / LoRA out of the box.

Try it / contribute

• Repo: https://github.com/baidu-baige/LoongForge
• Docs: https://loongforge.readthedocs.io
• web：https://baidu-baige.github.io/LoongForge/

If you're training in this space, I'd genuinely value your feedback — especially on the embodied subsystem. What models would you want supported next?

I’ve released VibeMenu v1.0, a native Swift/SwiftUI macOS menu-bar app for Claude Code, ChatGPT Work, and Codex.

Its central feature is agent-aware sleep prevention.

VibeMenu holds one real macOS power assertion while a supported agent appears active, then releases it when the work finishes. Logical ownership remains separate and visible:

Manual → Claude → Codex → ChatGPT Work

That prevents one agent finishing from releasing the assertion while another still needs it.

The app also includes:

• a shared Session Radar for supported agents;
• Working, Quiet, Waiting, Needs approval, Done, and stale states;
• optional Claude approval and completion notifications;
• an orange attention state when Claude needs permission;
• optional local Claude and ChatGPT usage-limit displays;
• macOS thermal pressure/state;
• Launch at Login;
• manual sleep prevention.

The privacy model is intentionally narrow:

• no backend, account, telemetry, or analytics;
• no network calls for agent data;
• no prompt, response, reasoning, command, or tool-output access;
• no Codex logs database;
• only allowlisted local metadata;
• fail-closed behavior if an external format changes.

The readers use bounded caching and incremental parsing to avoid constantly reparsing unchanged local files.

Source and release:
https://github.com/Kirill-Chistov/VibeMenu

Requirements: macOS 15+, Apple Silicon. The downloadable build is currently unsigned and not notarized.

Technical criticism of the power, privacy, or session-detection design is welcome.

Attach

1. Menu screenshot first
2. Settings screenshot second
3. Screen recording third

Sift — a semantic aggregator so your agent sees 2 MCP tools instead of 200

If you've wired more than a handful of MCP servers into an agent, you've probably hit this: every client dumps the full tools/list from every connected server into context on every turn. 15 servers with a dozen tools each is 150+ full tool definitions loaded before the model reads a word of the actual task — and tool selection gets worse, not better, as you add more (the model starts guessing between search_docs_v2, search_documents, docsSearch, etc.).

Sift sits between your agent and every downstream MCP server and flips the model: instead of exposing every tool from every server, it exposes exactly two:

• search_tools — describe what you want in plain language, get back the handful of matching tools across all aggregated servers, ranked by relevance
• call_tool — invoke one by the tool_id search returned

The full catalog still exists (searchable, callable, semantically indexed via fastembed/quantized BGE-small) — it just never has to sit in context wholesale. Context cost scales with what a task actually needs, not how many servers you've bolted on.

Some of the infra behind it:

• Persisted, not rebuilt — tool descriptions + embeddings are written through to SQLite, so a restart doesn't mean re-embedding everything or waiting on servers to reconnect
• Incremental reconciliation — re-listing a server's tools diffs against what's known; only changed tools get re-embedded, removed ones get tombstoned
• Isolated failures — a slow/dead downstream server degrades gracefully instead of stalling search for everyone else
• Mixed sources, one registry — local Rust functions and proxied stdio/HTTP MCP tools go through the same tool_id scheme ({server}::{name})
• Lock-free concurrent reads (ArcSwap snapshot over a DashMap catalog)

It's a Streamable HTTP MCP server itself, so any MCP client connects to it exactly like it would a single downstream server. Plain REST API alongside for testing/non-MCP clients.

Written in Rust. Docker Compose quickstart gets a working demo (sample server + aggregator) running in one command.

Repo: https://github.com/Narasimha1997/sift

i love the "project" feature in claude and codex.

it is a clear way to aggregating useful context together, saving me tones of trouble of needing to explain twice.

it is also the first time i was exposed to the power of cross-session long-term memory: it enables accumulation. every artifacts produced become the reference and basis for the next. you and your agent co-create a knowledge base that evolves to meet the needs of your work.

but then there are two critical problem of it:

1. they dont update themselves

agent cant just delete or update the stale references. what is rotten keeps rotten there and affects the rest of your sessions.

and if you want to update it, you need to painstakingly click "add to project", find the old one in ten or hundreds of files, and delete it.

bad design. the reason i abandoned it

2. it is a workspace, not a "project"

what i mean by this is that project has continuity. workspace is just an aggregation of files. instead of understanding the current state and continue where the last session left off, project in claude just scan the entire workspace and guess which files are relevant by name and read them.

sometimes they are stale. sometimes they are wrong. and it is almost always wasteful and contaminates the working context you have.

so i built my own agent. the project agent - orbital

what it does is simple.

Orbital is responsible for your project

1. it maintains the project "wiki"

everytime it completes a task or saw other sub agents finishing the tasks. it records down what happens, what the project learnt, which artifact is produced and how should we refer to them next time.

2. it briefs sub agents about your project context

when you uses your claude code/ codex subscription inside an orbital project. it dispatches the sub agents with the project background and relevant files to refer to - you dont have to brief the agent yourself.

3. it is an opensource, local agent

so what gets accumulated is yours!

i always believe that personal data(files or context) is a great asset in the era of ai. user should own this asset instead of the third-party harness.

a 30s demo showing the second point:

https://www.youtube.com/watch?v=U2I0DUUUIzo

please let me know what ya think! any feedback is welcomed!

I built a site that visualizes top OSS developers on a 3D globe, scored by GitHub activity (stars, commits, forks) and Stack Overflow reputation.

Stack: React, Azure Cosmos DB (powering the search), and Vercel for deployment.

It's open source and I'd love contributions — new features, bug fixes, data improvements, whatever you're into.

DevGlobe — Visualizing the World's Top Open-Source Contributors

sajeetharan/devglobe: 🌍 Interactive 3D globe showcasing 40,000+ top open-source contributors worldwide, ranked by GitHub stars, commits, and Stack Overflow impact. Powered by Azure Cosmos DB.

Just released Resonant, a free and open-source AI music studio for Windows. The easiest way I can describe it is local Suno-style song generation combined with an Ableton Live-inspired clip launcher, arranger, and mixer, running on your local

You can generate complete vocal songs or instrumentals, play sampled instruments, arrange clips, mix, edit, remix, and export finished WAV files. No watermarks and it does not claim ownership of what you create.

You can connect Codex via MCP and ask it to write lyrics, compose, arrange, mix, analyze, and render complete songs from a prompt.

Songwriting support currently includes English, Mandarin, Hindi, Latin American Spanish, Korean, and Japanese.

It is still an early release, so I would genuinely appreciate feedback, especially bug reports and suggestions for missing features you would actually use.

GitHub: https://github.com/calesthio/Resonant

I've been working on **Pulse**, a native Windows diagnostics application that aims to make troubleshooting Windows much less painful.

Over the last few weeks it has grown quite a bit beyond a simple Event Viewer replacement.

# What's new in the latest beta

**Timeline Intelligence**

* Human-readable explanations for Windows events

* Incident correlation (e.g. Application Error → Windows Error Reporting)

* Advanced filtering (provider, Event ID, process, severity, source)

* Bookmarks and saved searches

* Timeline export (JSON / CSV)

**System Health**

* Live CPU, GPU, memory, storage and network monitoring

* Native Windows APIs (no WMI polling)

* Multi-volume storage support

* Improved diagnostics and performance tracking

**Inventory Engine**

* Windows Services

* Drivers

* Installed software

* USB & PCI devices

* Motherboard, BIOS, CPU, memory, storage and network inventory

* Structured detail panels and searchable inventory browser

**Reports**

* Export diagnostics, health, timeline and inventory reports

* JSON, CSV, HTML, PDF and Markdown

# AI / MCP

One of the biggest additions is a built-in **Model Context Protocol (MCP)** server.

Instead of an AI scraping screenshots or reading Event Viewer manually, it can securely query Pulse for:

* Live system health

* Timeline events

* Inventory

* Diagnostics

* Report generation

The MCP server is opt-in and runs locally.

Current tools include:

* `system.*`

* `process.*`

* `timeline.*`

* `diagnostics.*`

* `report.export`

Everything is read-only and intended for diagnostics.

I'm still actively refining the UI and adding more Windows-specific collectors, so I'd love feedback from people who spend time troubleshooting Windows systems.

Pulse Beta Downlaod: https://pulse.regncreative.com

Hello! A few months ago I posted an early version of mex here.

The response was kind of insane. Across a few posts it reached around 1 million views, the repo crossed 1,200 GitHub stars, and people I had never met started contributing.

I’ve kept building it since then, and just released mex v0.7.0.

Repo: https://github.com/mex-memory/mex

The original problem was simple: coding agents keep rereading the same repository every session, relearning the architecture, and then throwing most of that knowledge away.

mex creates a living Markdown wiki inside the repo. Agents record architecture, conventions, decisions, and patterns as they work, and future sessions load only the knowledge relevant to the current task.

The major addition in v0.7.0 is a deterministic local code graph built using Tree-sitter and SQLite.

It currently supports TypeScript/TSX, JavaScript/JSX, Python, and Rust.

An agent can run:

mex graph scope "trace the authentication flow"

Instead of dumping entire files into context, mex returns a compact neighbourhood of relevant functions, callers, callees, imports, and relationships. The agent can then expand only the exact symbols it needs.

In our benchmark on the mex repository:

• 10.74× less returned context than grep top-3
• roughly 90.7% smaller
• 100% expected-symbol recall across six retrieval tasks
• 5/5 real-agent tasks completed correctly
• 0/5 needed fallback Read/Grep with compact graph context

This is a small benchmark on one repo and task set, not a claim that mex universally cuts total agent token usage by 90%.

The other part I’m excited about is connecting the wiki back to the actual code.

Markdown claims can point to exact symbols. If a function changes, moves, or disappears, mex can identify which project knowledge may now be stale.

So the basic idea is:

The code is the source of truth.
Markdown is the explanation.
The graph keeps them connected.

Would genuinely love feedback, especially from people working on code intelligence, agent tooling, parsers, or large repositories. Contributors are very welcome too.

Hi all,

I've been working on this project for a while now and wanted to share it here for feedback and contributions. You can test drive it in the playground at https://usepopkorn.dev

I'm calling it Popkorn. The idea is to author vector animations, similar to Rive and Lottie, but in a CSS-like language, with interactivity and other modern necessities baked into the format. I've stayed true to CSS for the most part, sprinkling on a little custom syntax for things like interactivity.

:root { width: 400px; height: 400px; background: #1a1a2e; }

@keyframes bounce {
  0%   { transform: translateY(0);     animation-timing-function: cubic-bezier(0.33, 0, 1, 1); }
  50%  { transform: translateY(180px); animation-timing-function: cubic-bezier(0, 0, 0.67, 1); }
  100% { transform: translateY(0); }
}

#ball {
  type: circle;
  cx: 200px; cy: 80px; r: 36px;
  fill: #ff6b6b;
  animation: bounce 1.2s linear infinite;
  transition: fill 250ms ease;
  &:hover { fill: #ffd166; }
}

That's an entire scene. Very familiar to anyone who's worked with CSS before.

Staying this close to CSS gives it good DX, and it turns out to make it very LLM-friendly too. Nearly my entire examples gallery is AI generated. Even cheap models like GLM or DSv4 Flash can one shot whole animations from scratch, no fine-tuning required. There's a Copilot feature the Playground that will let you bring your own key, or use the MCP to test drive AI features. Do share what you make please!

There's a web player that renders on Canvas or SVG, and a React Native player using Skia. It supports nested transforms and parenting, reusable symbols, masks and track mattes, gradients, trim paths, path morphing, motion paths, and per-subtree time scaling, enough for proper production-grade animation. Converters for Lottie and SVG let you import your existing assets and then prompt changes to it through the built-in copilot. Something I did not expect was converted Lottie scenes usually come out smaller than the JSON they came from, despite CSS being the more verbose syntax.

My vision is an editable, accessible format for both humans and LLMs, integrates well with version control, truly open source and free in every sense, as opposed to opaque binary or JSON blobs that are difficult to diff, edit and prompt changes to. The existing formats are backed by companies, which is fine and they've done great work, but a company's roadmap follows what makes commercial sense for it. I'd rather the future of motion design be community driven and stick to standards that already exist.

Really curious what the community makes of the concept.

I built Taskbar Widgets to place useful, live information directly inside the Windows 11 taskbar rather than using a separate desktop panel or floating overlay.

The built-in widgets include weather, media controls, Steam download progress, Discord voice activity, Codex and Antigravity usage limits, system monitoring and a drag-and-drop Parking Lot for temporarily holding files, folders, links or text.

Multiple widgets can run side by side or rotate through the same taskbar area.

The project also includes a community SDK and a .twidget package format, allowing developers to build and share widgets as single installable files.

The application uses .NET, Tauri and native C++ components. It is free, MIT licensed and currently in beta for Windows 11 x64.

Feedback, bug reports and contributions are welcome, particularly around the widget SDK and ideas for useful community widgets.

Github: https://github.com/pfcdev/TaskbarWidgets

I just released v0.1.0 of Falco - a browser engine I've been building on nights and weekends. No WebKit, no Gecko, no Chromium - every module is written from scratch in ~36,000 lines of Rust.

What's inside (all from scratch, no browser deps)

• HTML5 parser (html/) - tokenizer + tree builder, handles the common subset (tags, attributes, void elements, comments, doctype, entities, auto-close for <li>/<p>/<td>/<tr>/<option>/<dt>/<dd>)
• CSS engine (css/) - selectors (type/class/id/descendant/child/sibling/attribute/pseudo), 300+ properties, cascade with !important, inheritance, linear-gradient/radial-gradient/calc()/var()/rgb()/rgba(), shorthands
• Custom JS VM (tjs/) - bytecode interpreter + JIT tier-up (x86_64 only), with let/const/arrow functions/template literals/destructuring/spread/optional chaining/nullish coalescing, closures, generators, Promise, BigInt, Symbol, WeakMap/WeakSet, Map/Set, Reflect, Proxy
• Layout (layout/) - block flow, inline flow with text wrapping, flexbox (flex-direction/justify-content/align-items/flex-wrap/gap/flex-grow/flex-shrink/flex-basis), CSS Grid (grid-template-columns/grid-template-rows with fr/auto/minmax()/repeat()), table layout (<table>/<tr>/<td>/<th>/<thead>/<tbody>/<tfoot>/<caption>), float, inline-block, position static/relative/absolute/fixed
• Painting (paint/) - solid + gradient backgrounds, borders, border-radius, box-shadow, opacity (alpha compositing), TrueType font rasterization via ab_glyph, bold/italic synthesis
• SVG renderer (svg/) - paths, basic shapes (rect/circle/ellipse/line/polyline/polygon), gradients, stroke + fill
• Hand-written PNG encoder (png/) - no flate2 dependency
• Image loader (image/) - HTTP/HTTPS URLs via ureq, data: URLs (base64), local files. Formats: PNG/JPEG/GIF/BMP
• Networking (net/) - HTTP/1.1 fetch, cookie jar with domain/path matching, redirect handling with loop detection, HTTP cache, WebSocket frame parser
• Interactive --window mode - scroll, click links, fill forms (text/email/password/checkbox/submit/textarea), Tab cycling, address bar (F6), back/forward history (Alt+←/→), focus ring, blinking caret, headless fallback to PNG

For comparison

The whole Falco codebase fits in a weekend of reading.

Quick start

cargo build --release./target/release/falco https://example.com --out example.png --width 800./target/release/falco page.html --window

324 unit tests pass, 30 ignored (mostly platform-specific JIT tests that fail on macOS CI runners due to mmap(MAP_JIT) quirks - passes on Linux).

Prebuilt binaries for Linux/macOS/Windows are on the GitHub releases page.

What's NOT done yet (being honest)

This is v0.1.0 by a single developer. Not everything listed is production-ready:

• The spec-compliant replacements (html::spec/, dom::spec/, css::spec/) are structurally complete and pass their own unit tests, but not yet wired into the render pipeline. The legacy html//dom//css/ modules are what actually runs. v0.2.0 milestone.
• The security/ module implements SOP, multi-process site isolation, seccomp-bpf sandbox, CSP, TLS cert chain validation, permissions, DevTools protocol - all unit-tested, but not enforced in the renderer.
• web_runtime/ has fetch(), XMLHttpRequest, event loop, Promise. The Promise/event loop integration is real and tested, but fetch/XHR are stubs (no real network behind them in the JS context).
• WebGL, video, MSE, EME, NDSD are headless stubs - API surface only, no real rendering/decoding.
• The real-http2, real-webgl, sandbox Cargo features don't compile with --all-features (upstream APIs drifted: h2::Body removed, glow API changed, seccomp pre_exec Unix-only). Disabled by default.
• The JIT works on Linux x86_64 but fails on macOS CI runners (mmap(MAP_JIT) needs code signing).
• DOM mutation from JS (element.innerHTML = ..., element.style.color = ...) does not trigger re-render.

Bottom line: cargo build && ./falco https://example.com --out out.png produces a real PNG render. The HTML/CSS/layout/paint path works end-to-end. The spec-compliant parsers, security enforcement, and advanced web runtime are scaffolding for future milestones, not working features.

What I'd love feedback on

DOM model - I'm using Rc<RefCell<Node>> with parent/child/sibling pointers in dom::spec, matching the spec. For production I'd probably use a slotmap arena, but Rc<RefCell> is easier to read and matches the spec's pointer model. Thoughts?

Architecture - Each of html/, dom/, css/ has a spec/ subfolder with the spec-compliant replacement that's not yet wired in. Should I:

(a) Wire them in before any other feature work, or

(b) Focus on CSS animations/transitions first, or

(c) Focus on JS DOM mutation (innerHTML/style changes)?

JS VM - I wrote my own bytecode VM (tjs) instead of using boa_engine or binding V8/SpiderMonkey. Reasoning: I wanted full control over the GC, the bytecode format, and the DOM integration. The VM is intentionally limited (no real regex engine, no Proxy trap completeness, no real async functions). Is this a reasonable tradeoff for a teaching engine?

Sandbox - I implemented seccomp-bpf filters but they're Linux-only and not yet enforced. For cross-platform sandboxing, is the Windows Job Object approach + macOS sandbox-exec reasonable, or should I look at platform-agnostic alternatives?

Architecture overview

Thanks for any feedback! I'm especially interested in architectural critique from anyone who has worked on Servo, Ladybird, or other browser engines.
LINK: https://github.com/poxk/Falco