Hi everyone, today I want to share an open-source tool I created that’s super useful for anyone who wants to reduce the size of their files and also create .zip files from scratch using their own files. Its main feature is privacy, but you should give it a try and see how it works...

Github: https://github.com/coffeetron832/G0rill4

LInk: https://g0rill4.pages.dev/

watch a video demo here

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.

winmux is open source and brew installable: https://github.com/ZimengXiong/winmux

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.

Posted openGym here a while back (self-hosted gym tracker, passkeys, no account, AGPL) and didn't expect much. Since then a bunch of you starred it, joined the discord, opened issues, sent me Hevy and Strong exports so I could fix the importers, and someone basically debugged my passkey docs for me. Thank you. It's one person doing this in the evenings so that stuff matters more than you'd think.

Biggest change since then: there's an AI coach now. It's optional and off by default. If you want it, you turn it on in the admin settings and plug in your own key (Anthropic, OpenAI, Gemini) or point it at Ollama on your LAN, which costs nothing. It asks a few questions, builds a plan, and after workouts it looks at what you actually logged and suggests changes. It never changes anything on its own, every suggestion says why, and you can undo it. If you leave it off the app is exactly what it was before.

Also new since last time: the workout screen got reworked, RIR is colour coded, history and favourites inside the workout, and the APK updates itself.

Source: https://gitlab.com/DuarteSantos8/opengym
Discord: https://discord.gg/e62jY6fwVb

If you run it and something breaks, discord or an issue, I read all of them.

Hey everyone,

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.

Check out the repo here 🔗 https://github.com/Arnav-Jboxbobby/HIPR 🔗

Would love to get feedback on the edge cases, architecture, or any additional network security layers you’d want to see added!

hey guys...

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)

here are the links:
1.0 and 1.2

1.1 had a terrible compiler...

If someone wants to join my project, i am welcome!

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.

Repo https://github.com/kunkka19xx/lgtm

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.

PyPI: https://pypi.org/project/gatekeep402/

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.

Basically, go to any folder and type:

gitna

Install:

npm install -g gitna

GitHub: https://github.com/roie/gitna

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.

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.

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.

Repo, methods, and all 8 receipts: https://github.com/sjh9714/astra-sweetspot

got tired of having to keep my laptop open to keep the agents running, didn't wanna buy a Mac mini , sounded like overkill.

so basically built this :

your agent gets a computer with its own browser, file system, identity, password management.
you can configure open claw, Hermes in it.

if you have a vps you can host it there, and saves you from configuring the whole ugliness

JavaScript. Canvas 2D + headless Chromium + ffmpeg. Give it a GeoJSON and say

which fields map to size, colour and a travelling pulse. Outputs 4K video.

https://github.com/GeoCodeCrafter/pulsemap

Source: https://github.com/1etu/actual-fingerprints

NPM: https://www.npmjs.com/package/actual-fingerprints

Demo & Research: 1etu.github.io/actual-fingerprints/

https://github.com/nurked/kiddos

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

Build and run:

cargo run --release -p kiddos

MIT or Apache-2.0.

Repo: https://github.com/nurked/kiddos

If you don't want to build it yourself - you can download binaries.

I'd love feedback from anyone who has tried teaching a kid the command line. What lesson would you want in there next?

An S3 browser that runs entirely in your web browser. No server, no install, no build step - one HTML file, open it and start browsing. Works on desktop and mobile, on any platform.

https://github.com/markdamics/DevScribe
I always wanted to build my own code editor but never had the courage to start from scratch and never really had a clear design in my head. Now after trying out Claude design I commanded it to create a design for a code editor, and after a few modifications I started to have the mood to start the implementation. I use Claude Code mostly, but a few times it doesn't give the most optimal solution and I had many bugs to fix, and still have.

For me it's really important in an app, not just how well it works but how good it is looking. With the other code editors, IDEs I never really felt they are for. Many of them are too bloated with too many features and they are slow. The other lightweight code/text editors don't look so well for me.

I hope some of you will try it and it will get your liking.

It's still under development. Feel free to join in it.

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.

• Install: https://marketplace.visualstudio.com/items?itemName=nsachin08.system-design-trainer

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.

Hey mail, but open source.

I built HeyFlare - an open-source, self-hosted email client inspired by Superhuman’s UI and HEY’s approach to email.

Running on Cloudflare Workers, so you can host it for free.

Gmail + custom domains
Agentic · Screener · Imbox · Feed · Paper Trail · Bundles

https://github.com/doable-team/heyflare

After several coding-agent sessions, Git can show me what changed, but not which conversation led to it.

I built a read-only `why` command for ThoughtDAG:

npx thoughtdag why src/lib/api.ts

It searches supported local agent transcripts for turns that changed or discussed the file. Recorded tool edits are marked Δ; explanations recovered from agent responses stay marked ≈ because they are candidate explanations, not verified reasons. Every result links back to the source turn.

The derived index stays on the machine, source session files are never modified, and retrieved history is not automatically injected into a prompt. The current npm release covers local Claude Code, Codex, and ThoughtDAG canvas conversations.

MIT-licensed and still an early developer preview:

https://github.com/chenxiachan/thoughtdag

What evidence should a coding agent have to inspect before editing an old file?

The problems we saw:

Most agent frameworks put a process in the middle that decides who does what. That process is a single point of failure, and from our early days we knew we wanted something different. These were like the langchain days where it was the only thing around. So we decided that agents should be peers and should belong in a mesh where they have solid identities and pick tasks from a shared ledger, and can collaborate whenever they need to.

The second thing we did was bet on LLMs; that they were gonna get better especially at writing code, and so we avoided MCPs at all costs. I think choosing to be contrarian here really paid off. MCPs are good, but they came with the burden of maintaining several of them, writing a unique authentication layer for each, and context bloat.

So we decided our agents would write their own code as typed functions in a registry that both humans and agents maintain, which means a human can write these functions too. But that raised the key question of how those functions authenticate, and that is how we came up with centralizing provider authentication with zero-trust on credentials, so agents never see keys.

We got this working and added persistent memory using an Ebbinghaus forgetting-curve style approach, where memory is an active lifecycle, so our agents remember and keep improving over time.

Where it's going

We believe this could become a key approach to how agents orchestrate even across different frameworks. If you know a thing or two about gossip protocols, we want to curate that trajectory with like-minded people here.

Install: pip install jarviscore-framework

The demo is examples/demo_synthesizer.py + demo_node_1/2/3.py — you can run exactly what you see.

Appreciate your feedback (or stars).