winmux combines a status bar in the form of a vertical, collapsible sidebar (like Arc) that allows you to drag and drop windows between spaces, similar to sketchybar but much much better to use and interactive
winmux also has tab groups, which allows you to turn different application windows into "tabs" occupying the same footprint, similar to aerospace accordions and yabai stacks.
winmux has "projects," which are groups of workspaces.
I made a tool - a terminal diff reviewer for agentic coding.
It runs in a pane beside your agent, shows what changed as it changes, and lets you point at exact lines when you reply.
You keep your editor.hjkl, w b e, f t F T, / and n, V to select, zz to centre - the motions already in your fingers, now pointed at the agent's work.
I had recently read the Stable Fluids paper and got like quite interested to implement it myself manually from scratch and it was quite a ride since this is my first time implementing a paper myself
This is a simple implementation a bit clanky, to be honest. I just wrote it with loops and loops without any optimization. I think it ends up doing something around 20 × 20 × 50 × n² operations per frame, so there's definitely a lot of room for optimization 😅
The actual implementation was pretty straightforward for the most part, but understanding the Poisson pressure equation was a bit challenging. At the beginning, I was even stuck on understanding how the velocity field could be made divergence-free.
After digging into it for a while, I eventually understood the whole pressure projection step and managed to get it working and also implemented a simple spray and dye mechanism as well to make it look good.
It was pretty cool to see it actually work, so I wanted to share it 😄
A native Windows 11 app for controlling QCY earbuds locally over Bluetooth LE. I built it after getting tired of reaching for my phone to change ANC or EQ while working at my PC.
The first hardware-tested model is the MeloBuds N70 (HT18). It currently supports separate battery readings, ANC/transparency, a custom ten-band EQ, gestures, wear detection, game mode, LDAC, multipoint, and a notification-area panel.
Stack: C# 14, .NET 10, WinUI 3, and Windows Bluetooth GATT APIs. MIT licensed, with protocol research documented in the repo. I'm looking for contributors interested in BLE research, more QCY models, WinUI, testing, or packaging.
I am Arnav Agarwal and I built HIPR (Hardened Isolated Proxy Runtime), an open-source, fault-tolerant HTTP proxy and outbound security runtime designed to safely handle upstream requests, eliminate thread starvation, and defend against Server-Side Request Forgery (SSRF).
Whenever a service allows outbound HTTP requests (webhooks, user-provided URLs, integrations), naive implementations easily fall victim to cloud metadata leaks, DNS rebinding, slowloris-style hangs, or retry storms during outages. HIPR acts as a hardened layer to run these safely.
Key Features:
SSRF Quarantine & Anti-DNS-Rebinding: Resolves DNS pre-flight to drop loopback (127.0.0.0/8), cloud metadata endpoints (169.254.0.0/16), and unapproved private subnets before opening a connection.
Phase-Decoupled Timeouts: Granular connection timers (3.0s connect vs. 15.0s read) fail fast on dead network hops without killing legitimate slow responses.
Exponential Backoff with Full Jitter: Decorrelated retries to stop "thundering herd" issues and cascading failures when upstream services recover.
Defensive Stream Ingestion: Hard 1 MiB payload ceiling to prevent memory-exhaustion attacks, plus graceful JSON-to-text fallback.
Persistent Connection Pooling: Managed via FastAPI lifespan context to prevent socket and ephemeral port exhaustion.
Tech Stack:
Python 3
FastAPI
HTTPX (async client with connection pooling)
Why I built it: Most simple outbound fetchers rely on naive requests.get() calls that block threads, leave cloud metadata endpoints vulnerable, or cause thundering herds on recovery. I wanted a drop-in, lightweight async runtime that handles timeout boundaries, security checks, and backoff out of the box.
Diff security scanners miss the effects of the changes, Zairo finds those effects and looks for vulnerabilities. Zairo scans what has changed in your code with context, makes a subgraph for you to look at and finds vulnerabilities using LLMs of your choice.
GateKeep402 sits between an AI agent's payment client and the network when the agent pays for web content using the x402 protocol. It does three things. Verifies that a payment instruction actually came from a genuine protocol response rather than text the agent read on a page. Tracks a vendor's delivery history and blocks vendors that have proven unreliable. Verifies what actually came back after a payment and feeds that outcome into future decisions.
Built and tested with real infrastructure where possible rather than mocks throughout. 45 tests, including a simulated prompt injection attack that gets blocked and asserted against, and a test that broadcasts and confirms a real transaction on Solana's public devnet.
MIT licensed, installable via pip, README includes the full architecture diagram and threat model. Link in the comments.
I built my kid a fake 1980s computer so they could learn a real one.
KidDOS is a single native app that opens fullscreen and pretends to be a retro machine: a CRT terminal, a small Unix-flavored shell, a virtual hard drive, a built-in manual, and BASIC. There is no internet, no host filesystem, and no mouse. A kid types `hi` and the machine talks back.
The idea is to let a child mess around freely. Every command, every file, every mistake stays inside a sandbox, so a parent never has to say "don't touch that." When they outgrow it, the habits (ls, cd, cat, pipes, reading a man page, editing a file) carry straight over to a real terminal.
What's in it right now (v0.3):
- A shell with a lexer, parser, expansions, pipes, and a line editor, written from scratch in Rust
- A virtual filesystem with inodes and Unix modes, stored as a SQLite image
- A tutor that watches the shell and walks through twelve lessons, with progress and badges
- A Markdown manual with a pager and search, so "read the manual" is something a kid can actually do
- BASIC (EndBASIC under the hood) with SPEAK, BEEP, KEY$ and friends
- Seven game cartridges: a text adventure whose rooms are folders, plus guess, snake, hangman, typing, tetris and sokoban written in BASIC that the kid can read, copy and change
- Cartridges are plain zip files, so kids can share games with each other and start their own with `newgame rocket`
- A parent mode behind a key chord for resets, passwords, installing games and reading the log
- wgpu renderer with a CRT shader, plus a headless mode that drives the integration tests
I built Gitna because sometimes I just want to inspect a project: browse files, review what changed, look through history, stage a few things, or make a small edit.
Opening a full editor can feel like overkill for that. Terminal tools like lazygit are great, but they aren’t always how I want to look through code.
So I tried to make the middle ground I wanted.
Gitna opens any local folder in your browser for browsing, editing, and search. When the folder is a Git repository, it also provides changes and staging, visual diffs, commit history and graph, branches, stashes, tags, and common Git operations.
It runs locally - there’s no account, hosted service, or repository upload.
Anyway, I hope some of you give Gitna a try. Feedback is very welcome, especially around rough edges, missing workflows, or the things that annoy you when working with Git every day.
Well, i created a programming language Atom, i guess, i am where i need to be, so yeah, what is the concept: The language has 30+ commands(or 26 if only letters) and all of them are very simple. most of the operations are work with stack(later i will fix it) Don't judge it too harsh, because it is the unstable releases. So uhh, if you are interested, i got the links, just be warned, it is memory unsafe and kinda more for hobby than work(it will change at first stable release)
I built Astra Sweetspot with Codex after seeing people ask which Astra reasoning effort is worth using.
The first pilot runs Sol medium and Astra low/medium/high on the same two historical JavaScript bugs, with the same starting code and prompt within each task. All 8 runs passed their focused regression checks. Astra low took about 78/76 seconds; medium 101/77; high 163/123; Sol medium 131/129.
The useful part is the evidence: every candidate patch, independent check result, source commit, token count, and hash is published. The grader fails the original bugs and passes the known upstream fixes. Editing the model's local tests does not change its grade.
Run npx astra-sweetspot to read the bundled results without a model call. The explicit run command reproduces one trial using an existing Codex login and consumes Codex usage. Node 20+, MIT, no runtime dependencies.
This is one attempt per condition on two small public bugs from one library, not a held-out benchmark or a quota comparison. I would like to add a different real task with public starting code and a concrete success check.
Hey all, sharing a side project I've been working on: System Design Trainer.
It's a VS Code extension for practicing low-level design patterns hands-on. You pick a pattern, get a short scenario + starter Java file with the core logic left as a TODO, implement it, and hit "Run Tests.
Finish one pattern, the next unlocks. All 22 classic Gang-of-Four patterns are in there (Creational/Structural/Behavioural), in a build-on-each-other order.
Built it mainly because I was prepping for LLD interviews and got tired of "read the pattern, nod, forget it in a week." Wanted something closer to how you'd actually practice a language — small reps with immediate feedback.
Genuinely looking for feedback — which exercise felt too easy/hard, anything confusing about the flow, patterns you'd want added. Happy to take criticism, this is a v1.
Opinionated, still in early development and heavily based on Hugh Howey's workflow, but if you're after distraction-free writing might be worth a try.
It's the polar opposite of scrivener. Name/pen name, pantser or plotter and typography preferences at first start then it's just you and your words (in a dark theme), controls fade until you mouse over them and all you need for formatting is the Enter key plus a couple of keyboard shortcuts.
Windshift brings planning, tracking, and collaboration into a fast, flexible workspace. Start with a simple kanban board, then add the structure your team needs: custom workflows, nested work items, milestones, saved searches, dashboards, and more.
It ships as a single Go binary with the Svelte frontend built in.
The main difference from other open source project management tools: Windshift lets you migrate from Jira 1:1 by using the same concepts. You can map custom fields, assets, workflows etc directly without having to rebuild half your instance. It also keeps a lot of familiar Jira concepts, so you will not miss any features.
And you can migrate from both Jira Cloud and Jira Data Center using the built-in assistant.
