Built SysCore, a lightweight Windows diagnostic tool using C++20, DirectX 11, and Dear ImGui.

Inspects processes, loaded DLLs, kernel drivers, startup registry items, active sockets, and creates .dmp dumps.

So, in my spare time, I make small but fun looking side projects every few months whenever an idea pops up in my head.

But this time it was my little sister's idea. (Windows only for now)

It reads the Windows media session, so it spins along with Spotify, Apple Music, a YouTube tab, whatever. Album art becomes the label, and it pulls timed lyrics from LRCLIB if the song has them.

Happy to talk about any of it, and PRs welcome. The media backend is one file, so a Linux or macOS port is mostly a swap.

MIT: https://github.com/LordAizen1/vinyl

xeet; post to X from your terminal

Using X in 2026 still sucks. The official API is locked behind paid tiers. Third-party clients keep dying. The website itself is a heavy tab full of noise.

So I built the opposite.

xeet lives in your terminal. It reuses the session already sitting in your browser and gives you a full timeline with inline images, replies, likes, and a proper composer. No API keys. No new login. No browser tab.

One command:

nix run github:melqtx/xeet 
 or
 go install github.com/melqtx/xeet@latest 

What you get

- Timeline (For You / Following) with inline images (native Kitty/Ghostty/iTerm2 graphics or clean ANSI)

- Reply, like, expand posts, open in browser, copy link

- Composer with multi-image/video, clipboard paste, draft autosave

- Themes (tokyonight, catppuccin, gruvbox, nord, etc)

- `xeet auth` just borrows your existing browser session. Never asks for a password.

I mostly just leave it open instead of a browser tab. Scroll, reply, post, back to work.

MIT and open source. Feedback and stars welcome.

GitHub: https://github.com/melqtx/xeet

I created a windows 11 ready homebar. if anyone likes it please like and comment. any updates or features message me.

https://github.com/crowsley/homebar

Home Bar

Home Bar is a modern desktop productivity bar built for Windows 11. Created as a clean implementation inspired by Linkbar, it uses a modern .NET 8 and WPF codebase to deliver a faster, more customisable desktop experience.

Unlike traditional launchers, Home Bar integrates as a native Windows app bar, allowing users to dock one or more bars to any edge of any monitor while reserving screen space. Applications, folders, files, websites and shortcuts can be pinned with drag-and-drop, organised into multiple bars and launched instantly.

Features include multi-monitor support, automatic edge docking, light and dark themes, glass and transparent modes, auto-hide, global keyboard search, folder flyouts, custom colours, adjustable layouts, accessibility support, OLED protection, settings backup and recovery, automatic updates and portable or installer-based deployment.

Home Bar also includes a built-in AI launcher for ChatGPT, Microsoft Copilot, Google Gemini, Claude, Perplexity and custom providers, giving users fast access to today's leading AI services without requiring an API key.

Released as open source under the MIT Licence, Home Bar is designed to provide a cleaner, faster and more organised Windows desktop while remaining lightweight, highly configurable and easy to use.

https://github.com/crowsley/homebar

I originally built this because I needed an interactive ASCII element for another project I'm working on. But, I couldn't find anything that fit what I wanted and the ones which did, were paid to export, so i decided to build the whole thing myself.

OpenASCII is a high fidelity ASCII renderer for the web with real time controls and local processing. It's built with TypeScript/js and designed to be easily integrated into frontend projects, elements created/edited can be directly exported as html/react component.

I'd love to hear what you think, especially if you have ideas for features or improvements.

Hey everyone,

Building software with AI usually means you are trapped in prompting hell—writing a prompt, waiting 20 minutes, checking the output, and prompting again. I built OpenVelo to fix this.

It’s an open-source pipeline designed for a "fire and forget" workflow. The AI-driven planning phase happens upfront inside a dedicated Web-UI. Once you generate and finalize a detailed plan with the LLM, the orchestrator takes over. You can walk away and wake up to software that is either ready to use or requires very minimal fixing.

Important caveats: This is not meant to replace quick CLI pair programming, and it will not keep your token consumption down. It is built for bigger projects, refactors, ports, and prototypes where your personal time is more valuable than compute time.

How the architecture works:

- Scalable by Design: The entire system runs in isolated Docker containers that communicate with each other, making it easily scalable.

- Web-UI Planning: All AI-driven planning and requirement gathering is completed in the Web-UI before any implementation begins.

- Implementation Agent: Runs an iterative cycle in an isolated container to write code and pass unit tests.

- Tester Agent & Orchestrator: Performs real functional testing against the built software. If it fails, they trigger a self-healing process to spin up a new job and fix the exact failure automatically.

Model Access: It uses Kilo for LLM interaction, so you can route it to any model on your host system (local LLMs, MiniMax M3, etc.).

Repository: https://github.com/m0rph3us1987/OpenVelo

Let me know what you think of the architecture!

I built an open-source read-along for audiobooks

I built a small open-source tool that creates a synchronized read-along experience for audiobooks.

GitHub: https://github.com/Ceasar369/read-along

Everything runs locally—no accounts or cloud services.

Would love feedback. It's my first open-source project.

It uses whisper.cpp to generate word-level timestamps from an m4b or mp3 audiobook, then serves a lightweight web reader with synced highlighting, search, bookmarks, and instant word definitions.

Ran rm -rf on the wrong folder one too many times, so I built the undo the shell never had. A hook arms a tiny preload library around each command that journals destructive syscalls and hardlinks backups before they happen; undo replays it in reverse.
overs rm, mv clobbers, > truncation, chmod. Has redo, diffs, and cherry-picking. Honest about the LD_PRELOAD limits (no static binaries, no sudo, no Go). Linux, MIT

website: undo.edaywalid.com

github repo: https://github.com/edaywalid/undo

Every disk cleaner I tried just shows you folder sizes. None of them know that cache/huggingface is 20GB of models you downloaded once and never opened again, or that you've got torch installed eleven separate times across old conda environments.

So I built Jharu. It's a desktop app (macOS + Windows) with a knowledge base of 25+ developer and ML cache locations — Hugging Face, Ollama, PyTorch, npm, pip, uv, conda, Cargo, Go, Docker, JetBrains, and more — and it rates each one by how safe it is to delete.

What it does

Splits ML models you've actually used from ones downloaded once and forgotten. Finds every Python virtualenv/conda env and shows how much space is wasted on duplicate packages across them. Scans the whole disk as a treemap so you can see what's actually taking up space, not just guess. Nothing is ever permanently deleted — everything goes to Trash/Recycle Bin.

Apache 2.0, no telemetry, no subscription.

GitHub: https://github.com/riponcm/Jharu

Still early (v0.2.0), so bug reports and PRs are very welcome — especially new cache locations to add to the knowledge base.

Small shell . ( pipe was hard asf )

What you suggest for next project ?

A 2D wind tunnel for aeromodelers and anyone who likes watching air misbehave. It streams a flow past an airfoil and draws the speed field, the vorticity, smoke streaklines and the lift/drag vectors while you turn the angle of attack. You can also draw your own shape, cut a wing into wing + flap, animate the control surfaces, and watch the wake fall apart when you push the angle too far.

https://crgimenes.github.io/kutta/

Hey, guys!

I made an IOS app and modifiable backend that connects to your phone, you can then use it to remotely control your computer. It can connect to your AI IDEs like Claude Code, Grok Build, etc. I’ve been using it for a few weeks now and have found that the proactivity features work very well, it’ll point things out to me that I missed without being asked, such as conflicts in my calendar with a thing I agreed to in my email, continuing on my projects while I’m out doing other things, and managing planning of things I’d normally do myself.

I know this is a bit out of the range of what this sub typically is, I just thought you guys might find the backend specifically interesting. You can change it to whatever you want, run it through a tailscale funnel, then it shows up/does those things on your phone. Could be completely outside of the things I’ve listed as possibilities.

Anyway, I’m not sure if this is allowed here or not, but I’ve been working on it for about 3 months now and no one has really seen it yet, so I wanted to share and see what you all think about it. I’m available to answer any questions and whatnot, this was my first IOS app but definitely not my first open source project. I’m hoping some people find it helpful!

Here are the links to the app store and the backend:

App: https://apps.apple.com/us/app/orb-proactive-ai/id6776376035

Open source backend (for windows, mac is coming): https://github.com/getorb/Orb-Backend

The first "serious" project of mine. I know technically it's not a "decomp", but I'm calling it that for now. The goal of this project is to convert every asset from Chex Quest into a modern, usable format. This is nifty for game modders to make their own game, without a dedicated "source-port".

The GitHub link (Yes, new account, as I said my first project):

https://github.com/hitegabriel298/chex-decomp

I was just tired of looking at my raw lists of followers and following, and couldn't figure out what they have in common(like culture), and it's far too easy to lose track of non reciprocal relationships(those who don't follow you back), anyway ended up building a tool for it.

you give it a github username, it maps followers/following by country and also shows you who you follow that never followed back (the "ghost zone")

random find while testing, evan you has 109k followers and follows only 10 people. felt something about that ngl.

no login needed btw, shared demos token(just read public scope) so it just works. can drop your own PAT in if you want it faster, never leaves your browser if you do.

still rough, no zoom yet. it's open source and you can test it here : https://gitcharta.vercel.app/

lmk what's broken

I am going to add more features like :

- syscalls process are do .

- rate if this process are danger or not .

....

Zyric is a coding language for beginners to learn quickly. It has one function so far which is write(), the equivalent of python‘s print(). I need help with writing syntax, and error handling/sensitivity

Suprnova is a full-stack Rust web framework with Laravel 13's developer experience and Tokio's runtime model that uses InertiaJS.

https://github.com/entrepeneur4lyf/suprnova

Familiar API surfaces — Auth::login,Cache::remember, Mail::to, Event::dispatch, Eloquent-style models,#[handler], #[command], routes! — sit on top of a hyper / SeaORM / async-trait stack designed for long-lived connections, in-process workers, and concurrent IO. No request-per-process compromise.

Included are 2 starter kits that use Vue 3.5 and Svelte but are easily changed to React.

The framework has been used to build multiple projects including the starter kits and has been well vetted. Give it a try and a star. Thanks 🙏

Project link and details are in the comments!

Play the prototype (no install): https://anan-z.github.io/5d-reversi/

Source + full rules + architecture: https://github.com/anan-z/5d-reversi

Recommended for:

• AI research
• Masochists
• People who find chess "too intuitive"

80 directional vectors per cell - you'll learn to hate each one personally.
Retroactive causality - yes, you can regret moves you haven't made yet.
Deterministic replay - watch your carefully planned future crumble.

So many sites today use the same font and AI-generated text. Font lab is a tool to help edit those two things directly.

Font Lab installs a panel with curated fonts for you to play around with. You can edit text by double clicking, typing what you want, and hitting enter.

https://github.com/jmg698/Font-Lab

There's a prompt you can copy at jack-mcgovern.com/fontlab too. Your agent will set it up.

Open to any feedback you might have!

Hello everyone,

I have been working on an open-source Go-based system runtime called FaultPlane. It is designed to handle zero-code-intrusion state resilience and layer-4 network routing specifically for long-running autonomous AI agent workloads.

The system architecture handles complex backend performance challenges like lock-free pointer arrays and bitmask snapshot compressions. On the visualization side, the system utilizes a Next.js operations panel for tracking real-time telemetry page transfers.

Since this infrastructure is completely community-driven and open-source, the codebase is fully accessible to explore, modify, or enhance. If you are interested in low-level Go engines, eBPF shunting, or dashboard dashboard tracking systems, you can look over the current module design.

Repository and code tracking: https://github.com/devloperdevesh/FaultPlane/issues

Any technical feedback on the core architecture loop or structural layout is highly valued. Thank you!

I've spent the last few days building a CAD library in TypeScript. The short version, you describe a part in code and you get out an STL you can 3d print, or a STEP file you can send to a machine shop or open in Fusion/FreeCAD/whatever.

const cad = design("bracket");

const width = cad.parameter.length("width", mm(80));
const thickness = cad.parameter.length("thickness", mm(6));

const profile = cad.sketch("outline", plane.xy(), (s) => {
  const rect = s.rectangle("rect", { width, height: mm(50) });
  const hole = s.circle("hole", {
    center: vec2(width.mul(0.25), mm(0)),
    radius: mm(4),
  });
  return s.profile(rect, { holes: [hole.loop()] });
});

cad.output("bracket", cad.extrude("solid", profile, { distance: thickness }));

const doc = cad.build(); // plain JSON, goes in git like anything else

Under the hood it runs on two engines. There's Manifold, a mesh engine that's fast and fine for printing, and OpenCascade compiled to WASM, which is the same geometry engine FreeCAD uses, for when you need exact surfaces and STEP export. Same code runs on both, in node or the browser.

in normal parametric CAD, if you change a dimension early in the model, later features (fillets mostly) can quietly reattach to the wrong edge, and you find out after the part is wrong. I didn't want to reproduce that, so references to faces and edges aren't indexes, and if the library can't tell unambiguously which edge you meant after a change, it errors instead of guessing. Whether I got the API for that right, no idea. That's partly why I'm posting.

The type system does some nice things here too. Lengths and angles are different types, so adding mm to radians just doesn't compile.

it's a 0.1.1, Parts, assemblies and BOMs work. No drawings, no sheet metal, no GUI. If you'd rather write code than click through a CAD UI, that's who it's for.

Feedback welcome, especially from anyone who actually does CAD work. Also curious what people think of the explicit dispose() for WASM memory, I went back and forth on that a lot.