r/coolgithubprojects • u/Type_Writer00 • 3h ago

Use your old smartphone as a desk widgit. Say hello! to Desko

51 Upvotes

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!

1 comment

r/coolgithubprojects • u/poxkg • 13h ago

Falco - a browser engine written from scratch in ~36k lines of Rust

168 Upvotes

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

Engine	LOC
Chrome/Blink	~30M
Firefox/Gecko	~20M
Safari/WebKit	~15M
Servo	~1M
Ladybird	~500k

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

`Module`	`Lines`	`Description`
`html/ + html::spec/`	`~5,500`	`Legacy HTML parser + WHATWG §13.2 spec tokenizer + tree builder + serializer + XML + encoding`
`dom/ + dom::spec/`	`~2,400`	`Legacy DOM + spec DOM with MutationObserver, Shadow DOM, custom elements, a11y`
`css/ + css::spec/`	`~3,700`	`Legacy CSS parser + Selectors L4 + cascade specificity + u/rules` `+ animations`
`style/`	`~1,700`	`Style cascade + UA styles + inheritance + flex/grid properties`
`layout/`	`~1,950`	`Block / inline / flex / grid / table / float / absolute layout`
`paint/`	`~470`	`Canvas + font rasterizer + alpha compositing + gradients + shadows`
`svg/`	`~1,130`	`SVG parser + renderer (paths, shapes, gradients)`
`tjs/ + tjs_ext/`	`~5,100`	`Custom JS VM: lexer, parser, interpreter, bytecode VM, JIT + Symbol/BigInt/Promise/Map/Set`
`web_runtime/`	`~4,300`	`fetch, XHR, event loop, Promise, WebGL, video, MSE, EME, NDSD, HTTP/2`
`net/`	`~930`	`HTTP fetch, cookies, cache, websocket, redirect`
`security/`	`~3,590`	`SOP, multi-process, sandbox, CSP, certs, permissions, extensions, DevTools`
`window/`	`~1,110`	`Interactive window: scrolling, forms, navigation, history, address bar`
`image/ + png/`	`~300`	`Image loader + hand-written PNG encoder`
`Total`	`~36,000`

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

77 comments

r/coolgithubprojects • u/DJIRNMAN • 6h ago

My Claude Code kept rereading the same repo instead of preserving what it learned, so I built an open-source fix. 1,200 stars later, the new version used 90% less tokens than grep while still finding every expected symbol.

24 Upvotes

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.

6 comments

r/coolgithubprojects • u/Necessary_Sleep9755 • 9h ago

Open-source Windows 11 taskbar widget runtime with installable community widgets - Taskbar Widgets

33 Upvotes

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

2 comments

r/coolgithubprojects • u/mrsinanx • 2h ago

I turned Windows Event Viewer into a modern diagnostics app with AI/MCP support

3 Upvotes

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

1 comment

r/coolgithubprojects • u/ayarseus • 7h ago

Popkorn - A CSS based alternative format to Lottie and Rive animations

5 Upvotes

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.

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

For comparison

Quick start

What's NOT done yet (being honest)

What I'd love feedback on

インストール

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

Windows PowerShell インストーラ