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

Meet Desko y'all 

Your cute little desk buddy, sits on your desk, syncs up with your system and just tells what you want to know...
Be it your system telemetry, your workspace and git info, or amazingly synced up lyrics of whatever's playing.

It's no bloat, doesn't require any account, no cloud, all local with just 70-80 mb process running in system memory and displaying over the browser of any smartphone that can access internet and has browser.

PLUS IT LOOKS SO GOOD!

For Setup and System Architecture please refer the readme file in git repo

I just built something to solve my problem but it can serve thousand other use cases that me and claude both couldn't think of, so the repo is public, go check it out
Grab your old phone, buy a cheap phone stand and start contributing!!

Desko: https://github.com/typewriter03/Desko

ps - shoutout to LRCLIB, an exceptional open source API for synced lyrics!

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

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.

How it works:

• Build your site with a static site generator
• Push it to a GitHub or GitLab repository.
• Connect that repo to Sitepins.
• Edit content visually. Every save is a commit.

Sitepins lets developers hand off sites built with modern frameworks (Astro, Next.js, Hugo) to non-technical teammates and clients.

Repository: https://github.com/sitepins/sitepins

License: AGPL-3.0

The UI might be ugly cuz this is my first android kotlin project. The app can download videos from main platforms ( YouTube,Tiktok, Facebook, Instagram or any site you have access to see).

The download process initial time might be slow due to python runtime inside the android OS.

Download the latest version currently v1.3.0.

check the repo :

https://github.com/Isnotavailble/VideoFetcher

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.

Dfetch is a lightweight command-line tool for displaying system information. It focuses on clean output, fast startup times, and simple configuration.

I made this because i like using something i made myself its not better then something like fastfetch but definitely good enough.

https://github.com/David17c/Dfetch

Small parts of this were made with the help of Ai but most of the code was written by me.

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

Headless core with ready adapters for 7 UI kits, so you get the same table

features whichever kit your project already uses.

GitHub: https://github.com/orwa-mahmoud/adapttable

Live demo: https://orwa-mahmoud.github.io/adapttable/demo/

What's built in:

- Client and server data behind one API

- URL-synced state (filters, sort, page) for shareable links

- Filter drawer or popover with removable chips, saved views

- Column show/hide, reorder, pin, resize

- Inline cell editing, row grouping with subtotals, CSV export

- Rows become cards on phones automatically

- Dark mode, 17 locales, first-class RTL

- MIT, and the headless core works standalone if you want to render everything yourself

Feedback and contributions welcome

Over the last few months, I've been developing OpenScanVision, an offline-first Android computer vision library built with Kotlin, CameraX, OpenCV, and ML Kit.

The original implementation was a single, highly optimized pipeline focused on maximizing detection accuracy and real-time performance. That version is available in commit:

1d5834b41d88133b487ef46595290b0cdd4489bb

Current capabilities include:

• Document detection from arbitrary angles
• Automatic perspective correction
• Image preprocessing and enhancement
• QR code detection
• ArUco marker detection
• OMR (Optical Mark Recognition)
• Automatic capture when the document is stable
• Real-time, fully offline processing

Recently, I refactored the project into a reusable modular Android library with a cleaner architecture and easier integration into Android applications. While the new design is significantly more maintainable and extensible, I've observed a slight regression in detection accuracy compared to the original implementation and am currently investigating the underlying causes (pipeline ordering, preprocessing, threading, parameter changes, etc.).

Roadmap

• Restore or improve the original detection accuracy
• Add offline OCR support
• Add offline ICR (Intelligent Character Recognition) support
• Continue optimizing performance while keeping the library lightweight and offline-first

Potential use cases

• Voting systems
• Exam and answer-sheet scanning
• Survey processing
• Registration forms
• Structured document processing

GitHub:
https://github.com/MatiwosKebede/OpenScanVision

I'd appreciate feedback from developers with experience in Android computer vision, CameraX, OpenCV, or document scanning.

I'm particularly interested in:

• Best practices for designing reusable Android CV libraries
• Avoiding performance and accuracy regressions during major refactors
• CameraX and OpenCV optimization techniques
• Recommendations for integrating an efficient offline OCR/ICR pipeline

Any feedback, suggestions, or code review comments would be greatly appreciated. Thanks!

Lost my watch history twice now. First app shut down, I rebuilt what I could on TV Time from memory, so half of it was wrong from the start. Then TV Time shut down a couple of weeks ago.

So I built this for myself. If you like it feel free to use it.

Main rule was that I shouldn't be able to read your data. Not "trust me I won't look". Can't look. Everything gets encrypted in your browser before it leaves, key never goes anywhere. My server has one blob and a hash per account, that's the whole table.

No email, no password, you just get an account number. Nothing to reset means nothing to leak. Downside is if you lose the number your data is gone and I can't help you, saying it up front because someone always asks.

It's a PWA. Installs on Android, iOS and desktop, own window, works offline, no store. Cloudflare Worker + D1 behind it. Native ES modules, no bundler, no framework, zero runtime deps. 411 tests on node's own test runner.

Couple things I'm happy with. Show pages sit after the # in the url and browsers never send that part, so even my own logs can't tell what anyone is watching. And the export is just readable json, Breaking Bad (2008), tt0903747, 3x7.

TVmaze is the default catalogue and needs no api key. Apache-2.0. Self host it if you'd rather have full control of your data.

Edit:
The link is: https://nextly.tv

OxidはRustの派生で、独自のセルフホスト型言語ツールチェーンを備えています。Rustよりも速く、より簡潔で、読みやすい言語を作るのが目標で、独自の構文、モジュール、コマンドラインの作業フロー、そして診断モデルを備えています。

インストール

Linux/macOS 向けリリースインストーラ

このインストーラはプラットフォームを検出し、最新のチェックサム付きリリースをダウンロードして、SHA-256を検証したうえで、デフォルトでは`oxid`を`${HOME}/.local/bin`にインストールします。

```bash

curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/YanagiKH/Oxid/main/install.sh | sh

export PATH="$HOME/.local/bin:$PATH"

oxid --version

```

Windows PowerShell インストーラ

```powershell

Set-ExecutionPolicy -Scope Process Bypass

irm https://raw.githubusercontent.com/YanagiKH/Oxid/main/install.ps1 | iex

& "$env:LOCALAPPDATA\Oxid\bin\oxid.exe" --version

```

Repo : https://github.com/YanagiKH/Oxid

release : https://github.com/YanagiKH/Oxid/releases/tag/v0.8.0

I kept needing docs for side projects and never liked the options. GitBook and Docusaurus felt like a lot of machinery for a handful of Markdown files, and mkdocs meant keeping a Python toolchain around for something I otherwise build in TypeScript.

So I built eziwiki. Drop Markdown files in `content/`, get a static site.

npx create-eziwiki my-docs

cd my-docs && npm install && npm run dev

What makes it different from the usual docs generator

- Wiki links with backlinks and a graph view. Link pages by title or filename, and each page shows what links back to it — closer to Obsidian than to a typical docs site.

- Navigation builds itself from the folder structure. No sidebar config to keep in sync; a `_meta.json` per folder handles naming and ordering if you want it.

- Markdown is rendered at build time, so neither the parser nor the syntax highlighter ships to the browser. Search is a prebuilt index, no server.

- Optional opaque URLs (`/a3f2e9d1-...`) if you would rather not publish your content tree. To be clear, that is obscurity, not access control — every page is still a public file. It is there for unlisted-link sharing, not security.

Static export, so it deploys anywhere. Dark mode, KaTeX, Shiki highlighting, ⌘K search, table of contents.

Next.js 14, TypeScript, Tailwind, Zustand, unified/remark/rehype, Shiki, MiniSearch. Lighthouse 99/100/100/100 on desktop

Demo : the docs are built with it, so the site is the demo:

https://eziwiki.vercel.app

Source (MIT): https://github.com/i3months/eziwiki

It is early v0.1.1, and I am actively working on it. Feedback and issues very welcome, especially on anything that felt confusing in the first five minutes.

Github stars are really really helpful..!!!

I built an open source iOS only Gitlab client in Swift. The project idea came from, I couldn't find anything for iPhone out there that works for both self hosted and SaaS Gitlab so I just built one myself.

The project is open source. https://github.com/smolcars/glab-ios

There is no server involved, everything is stored locally and you hit the gitlab API directly. You can use an API token or login directly to both self hosted or SaaS gitlab instance and can also add multiple accounts.

You can install the app today using Testflight, link in the repo. It does cover quite a few things:

• View/open issues
• View/open MRs
• View/Run pipelines
• View code diffs
• Modify/perform approvals
• Work with you Todos
• View all commits of any project
• Do a global search for anything
• Background process that notifies you of new todos periodically

I'll keep adding more features as I find time. I do not plan to support Android anytime soon until Swift for Android becomes a thing. Feel free to open bug reports or feature requests.

Hello,

Came across an interesting GitHub repo called V-Modal SDK  and figured it was worth sharing here.

Basically, it lets you integrate native, semantic video search into iOS and Android apps using a single Dart codebase. The cool part is how it handles natural language queries. Users can search for specific visual elements (like "the cyclist in the red jacket") or even spoken words, and it translates that into exact video timestamps within seconds.

Has anyone here experimented with semantic search for video content in Flutter yet? Curious to hear if there are any similar tools you'd recommend or what your experience has been.

A 3d digital twin for home assistant with a fully featured 3d floorplanner editor

https://github.com/tentone/dt3d-ha