A thank you for open source builders. You put in the work, we want to send something back.

Drop your open source repo below. My team picks one they find interesting. No star requirement, no follow, no catch. Winner gets a Fleet device shipped for free.

What's Fleet? I was running Claude Code on my laptop, Codex on my desktop, more agents on servers. No way to manage them all. So I built a device that sits on your desk and connects to every agent across every machine. You talk to it, agents send you status updates, you don't need 10 terminal tabs.

Been using the prototype for a month. Cant live without it.

Drop your repo. Thanks for what you build.

Edit: I didn't think that I can gather this many great people. I might not be able to reply to you all but be assure that my team will check all of the repos here. Will try to make this a weekly event, so for this week, the deadline is Sunday. Big thanks to all of you.

I've been watching Nova Designs on YouTube for a while and loved how clean his code presentations look. Turns out he uses CodeSlides which is great, but it's subscription-based.

So I built OpenSlides — a free, open-source, fully offline desktop app for making animated code presentations. Think CodeSlides, but it runs natively on your machine, your data never leaves your disk, and you own everything.

https://github.com/codewiththiha/OpenSlides.git

Routeveil is an open-source React + TypeScript transition system for React Router.

It provides:

- 20 built-in page and overlay transitions

- transition-specific TypeScript options

- declarative RouteveilLink navigation

- programmatic navigation

- previews without route changes

- cursor-aware radial effects

- reduced-motion support

- support for custom transitions

The transition engine handles the route exit, navigation, incoming render, entry animation, and cleanup without requiring animation code inside page components.

Repo:

https://github.com/milkevich/routeveil

Interactive demo:

https://routeveil.dev

Test out the transitions:
https://routeveil.dev/lab

built this over a weekend and figured some of you might want it on your profile readme. it renders your contribution graph as a snake that actually plays the game: it pathfinds to your commits, avoids its own body, and grows as it eats. one python file and you add it with a single github action.

https://github.com/dahan8473/snake-and-commits

happy to take feedback or feature requests.

I wanted a simple way to share passwords, API keys, and snippets without trusting a server with the plaintext, so I built binthere.

It's a zero-knowledge, end-to-end encrypted pastebin where everything is encrypted locally in your browser using AES-256-GCM before it's uploaded. The server only ever stores ciphertext, while the decryption key stays in the URL fragment and never leaves your device.

It's built as a single Cloudflare Worker, supports one-time ("burn after read") notes with 24-hour expiry, includes an official CLI, and is fully open source.

I'd love to hear any feedback on the security model, architecture, or overall UX.

GitHub: https://github.com/nxfu/binthere

Demo: https://binthere.gaury.dev

Docs rot the moment code changes, and nobody updates them on purpose - RepoDocs regenerates them, citing file:line for every claim.

It's a CLI, not a plugin: it shells out to whatever coding agent session you already have open (Claude Code by default, or OMP/Codex), scans the repo deterministically first, then has the agent write each page from what the scan found. Rebuilds hash sources and only regenerate what changed. It also diagrams how the modules fit, and can publish straight to a GitHub Wiki. Publishing is guarded (dry-run first, refuses main/master/trunk, scans for secrets).

Zero runtime dependencies - Python 3.10+, stdlib only. v0.2.0. Runs locally; your code never leaves your machine.

uvx --from repodocs repodocs-all .

> github.com/aryrabelo/repodocs — if you try it, tell me what broke.

At Bitwize, we've been building Logue, a native macOS app for AI meeting notes and writing, and we just open-sourced it (MIT). We're sharing it here because the whole point is that it runs 100% on-device — we wanted something that could transcribe and summarize meetings without shipping audio or notes to anyone's cloud.

By default, nothing leaves your Mac. The only network calls are the initial on-device model download, app update checks, and opt-in features you explicitly turn on (web search or plugging in an external AI provider if you want one). No accounts, no telemetry, no backend.

What it does:

• Real-time transcription of mic and system audio (Apple's on-deviceSpeechTranscriber)
• Speaker diarization — who said what — via FluidAudio (streaming Sortformer)
• "Smart Minutes": local LLM summaries, action items, highlights
• Writing assistant: 60+ modes (rewrite, grammar, clarity, tone), a document editor with AI chat, vocabulary suggestions
• On-device PII detection and a fact-check/verify panel
• Templates, Spaces, and "Ask Logue" chat over your own notes

Stack: Swift + SwiftUI/AppKit, MLX (mlx-swift-lm) for LLM inference, Apple's Speech framework, FluidAudio for diarization, Sparkle for updates. Data is AES-256-GCM encrypted at rest.

Honest caveats: it targets macOS 26 (Tahoe) and Apple Silicon only (MLX + the new Speech APIs), so it won't run on Intel or older macOS. It's early — expect rough edges — and we'd genuinely love feedback, issues, and PRs.

Repo: https://github.com/bitwize-ai/Logue

Happy to answer anything about the on-device pipeline, MLX inference, or diarization in the comments — we're the team that built it. 

Hey everyone,

I use Mermaid for diagramming, but I was tired of tools that require a login, track usage, or save data to a third-party cloud. I just wanted a simple tool where my diagrams stay completely private (and I couldn't find one).

So I built Mermify. It’s fully client-side, runs entirely in your browser, and doesn’t track a thing. I just updated it to v0.3 it now supports Flow Charts & Sequence Diagram.

What it actually does:

• Real-time Sync: Type raw Mermaid syntax in Monaco or visually drag nodes/edges on the canvas. It syncs instantly both ways.
• Drag-to-Create & Inline Editing: Drag from a node's socket into empty space to spawn connected nodes, and edit labels directly on the canvas.
• 100% Private Links: Uses pako to compress the entire diagram state into the URL hash. No database, no backend.
• Run it Anywhere: Zero backend means you can easily self-host it, or just install it as a standalone desktop PWA.

The Rough Edges & Tech Stack:

I'm mostly used to Python and Docker environments, so TypeScript isn't my native tongue. I used an LLM to handle the TS syntax heavy-lifting while I focused entirely on the UX logic, product flow, and writing robust E2E/unit tests.

Note: It's strictly for desktop right now (screens width ≥ 1024px) due to the side-by-side layout.

I’m really proud of how it turned out, but since I'm stepping out of my comfort zone with TS/React, feel free to roast the app or the implementation (constructively!). Let me know what features you're missing or what I can improve.

🚀 Live App:https://tra-sco.github.io/mermify/

📦 GitHub Repo:https://github.com/tra-sco/mermify

A place to take a break, chat with people around the globe, listen to some music, play a game, water your bonsai. All in your terminal.

ssh late.sh

That's it :) No passwords, no OAuth, no accounts. Your SSH key is your identity.

Last time I posted here, our "big multiplayer game" was blackjack. Well... we kinda went wild since then :D

The roguelikes

• Dungeon Crawl Stone Soup: the most played roguelike of the modern era, real console crawl running over SSH, your save persists. Soon connected to https://dcss-stats.com .
• NetHack: the one hanging in a museum (literally, MoMA has it). The real upstream game running over SSH: your save persists, the dead stay down there, and your bones haunt other late.sh players.
• and a third classic is landing soon... arguably the most beautiful ASCII ever put on a terminal ;)

The BBS door games

• Legend of the Green Dragon: the classic LORD, rebuilt native in Rust for the terminal. Hunt the forest, beat your master, slay the dragon. We've got big plans for this one :)
• Usurper: the actual LORD-era door from the 90s, resurrected on a PTY, one shared persistent world.
• Lateania: our own persistent multiplayer text-world. Pick a class, fight turn-based combat, drop bosses. Your character lives between sessions.
• dopewars: buy low, sell high, dodge the cops. One sitting, shared high-score board.
• Rebels in the Sky: ricott1's brilliant space-pirate basketball roguelike, playable door-game style.

The Lobby

Ctrl+Q anywhere and you get every multiplayer game in one list:

• correspondence games, chess, battleship, connect four, reversi, checkers, backgammon. Post a challenge, walk away, play one move whenever you're around. 24h per move or you forfeit, winner gets chips. Every match gets its own private chat + voice room for proper trash talk :D
• five always-on house tables you just sit down at, poker, blackjack, tron, super snake, asterion
• spectate any live match
• and the roster keeps growing, card games are next, gin rummy is looking good ;)

Turns out correspondence chess over SSH is a hit. Who knew.

The Arcade grew too

• new games, Le Word (one global daily word for everyone, so the chat gets competitive), Traffic (multi-track racing), and a Rubik's Cube (real cube, same daily scramble for everyone)
• daily puzzles across the board (sudoku, nonograms, minesweeper, solitaire, le word, rubik), daily quests and streaks that pay chips, monthly champions get permanent profile badges
• and a shit ton of QoL, like one backtick key that cycles you through your unfinished dailies, boards where it's your move, and back to chat

MUSIC

• the booth, a community YouTube jukebox. Queue tracks, vote, skip, browse the history of everything that ever played. Someone's always DJ-ing.
• the radio, live synthwave from Nightride FM, with their blessing and live artist/title attribution. Five stations: Chillsynth, Nightride, Datawave, Spacesynth, Ambient.
• the library, 600+ curated CC0/CC-BY tracks (lofi, ambient, classical), all controlled from inside the TUI

Chat leveled up too, polls, image previews, an embedded IRC server (use late.sh from any IRC client, irc.late.sh port 6697 TLS)... and VOICE chat. In your terminal. No browser :D

Everything from before is still here, the live artboard (https://late.sh/gallery), news feed with ASCII thumbnails, profiles + showcase (https://late.sh/profiles), the classics (2048, tetris, snake) with leaderboards and badges.

Oh, and did I mention the whole thing now has a fully ASCII clubhouse? A walkable tavern where you see everyone who's online, sit at the bar, wave, dance, and buy a drink from the AI bartender with your chips. It's the front door of late.sh now :)

Still a team effort, still a great vibe. Hop in, take a break ;)

License: FSL-1.1-MIT

Code: https://github.com/mpiorowski/late-sh

Landing: https://late.sh

Demo: https://late.sh/play

Hey everyone,

I built DevTime, a CLI tool that scans your repo and creates a local “memory” of how your project actually works.

It helps you:

• Understand the big picture (concepts + relationships)
• Get answers about your codebase
• See what’s risky in a change before you commit
• Keep decisions & context in one place
• Works offline. No cloud, no telemetry, open source.

I made it because I got tired of re-explaining the same parts of my projects to new teammates and AI tools.
Would love feedback from you all 🙏

Repo: https://github.com/Shakargy/devtime

I built The Email Game: you design a Python AI agent that competes against other people's agents over simulated emails. Each agent can cryptographically sign messages only for the agents it's authorized to, and has to cooperate with the same rivals trying to manipulate it into signing something it shouldn't. A base class handles the protocol, RSA signing, and email plumbing, so you just write the decision logic. It's live and you can compete virtually from anywhere; the next competition is Aug 1: theemailgame.com. Built it during my AI research fellowship at WithAI (YC P26), feedback is welcome!

HakPoint is a modular enterprise management platform that helps companies centralize and manage their daily operations from one responsive interface.

Built with PHP 8.2+, MySQL, PDO, HTML, CSS, and JavaScript, it is suitable for SMEs, distributors, retailers, service companies, and organizations looking for an adaptable business-management solution.

Main features

• 📊 Dashboard with KPIs, charts, summaries, and recent activity
• 🤝 CRM management for prospects, customers, and suppliers
• 📦 Product and service catalog with pricing, margins, notes, and files
• 🏬 Warehouse and inventory management
• 🔄 Stock transfers, adjustments, movements, lots, serial numbers, and physical inventories
• 📝 Complete sales workflow: quotations, orders, invoices, credit notes, and payments
• 🛒 Supplier purchases, purchase orders, supplier invoices, and payments
• 🚚 Shipment and reception management
• 🏦 Bank accounts, payment methods, reconciliation, and cash-flow tracking
• 📚 Basic accounting with accounts, journals, periods, entries, balance, and general ledger
• 📄 PDF generation for business documents
• ✉️ Email preparation and document sharing
• ✍️ Electronic signature workflow
• ✅ Approval and validation workflows
• 📈 Business reports, analytics, status monitoring, and Excel/CSV exports
• 📂 Document management and secure uploads
• 👥 User accounts, hierarchy, roles, and granular permissions
• 🔐 Two-factor authentication, CSRF protection, login controls, and audit logs
• 💾 Database backup and restoration
• 🔌 REST API protected by API keys, Bearer authentication, and configurable CORS
• 🤖 HakPoint AI assistant with French, English, and Arabic support
• 🧩 Optional modules for projects, agenda, POS, manufacturing/BOM, currencies, and custom fields
• 📱 Responsive interface for computers, tablets, and mobile devices

How HakPoint helps companies

Technology stack

• Backend: PHP 8.2+
• Database: MySQL with PDO
• Frontend: HTML5, CSS3, JavaScript
• Dependency management: Composer
• Integration: REST/JSON API
• Hosting: Standard PHP/MySQL hosting, Apache/cPanel, or Caddy-based environments
• Architecture: Modular, configurable, and designed for future extension

Free public version

HakPoint is available publicly and is intended to remain free and open source.

I am not requesting payment for the public version. If you find the project useful, the best way to support its development is simply to give the repository a ⭐ on GitHub.

Every star improves the project’s visibility and encourages me to continue adding features, improving security, and making HakPoint more professional.

👉 GitHub repository: github.com/hakkachhamza/HakPoint

Private and customized version

Companies that need a more specialized solution can request a private and professionally customized version, including:

• Custom branding and interface
• Company-specific modules and workflows
• Integration with existing websites, APIs, or databases
• Private GitHub repository
• Deployment and configuration
• Security hardening
• Data migration
• Maintenance, training, and technical support

Pricing can be adapted fairly according to the company’s requirements, project scope, and expected support.

Contact Hamza Hakkache:

• [LinkedIn]()
• Email: [[email protected]]()

Most developers building AI apps don't realize they need an intelligent gateway layer — they hardcode API keys, juggle provider SDKs, write their own failover. I built Aurora so you don't have to.

Aurora is a full LLM gateway you integrate into your backend. Your apps use a single OpenAI-compatible SDK; Aurora handles routing, load balancing, failover, caching, guardrails, and cost tracking transparently.

The OSS edition (Apache 2.0) ships with production features: auto-discovery, provider pools, semantic caching, guardrails, audit logging, usage analytics, token saver, managed API keys — all included. Enterprise adds SSO/RBAC.

Built in Go for raw speed.

What it does:
- Set an API key as environment variable → provider auto-discovers
- Provider pools: round-robin/weighted with health-aware failover
- Model aliases: rename any model to a custom identifier
- Fallback + resilience: 5xx/429 failover, circuit breaker, exponential backoff
- 3-layer caching: semantic (Qdrant, pgvector, Pinecone), exact (Redis), prompt (native)
- Guardrails: PII redaction, prompt injection blocking, regex, length limits, LLM-based altering
- Managed API keys: scoped, rate-limited, per-model authorization
- Token saver: policy-driven output compression to cut costs
- Audit logging: full request/response capture, live SSE stream
- Usage analytics: per-model cost tracking, daily aggregation, budgets
- Admin dashboard: React SPA in the binary
- Workflows: config-driven per-request routing, caching, guardrail, budget policies
- Prometheus + Grafana: request rate, latency, errors, phase timing

Install:

npm install -g iaurora
mkdir my-gateway && cd my-gateway
aurora init
# Edit .env with your API keys
aurora

Or Docker:

docker run -d -p 8080:8080 \
-e AURORA_MASTER_KEY="your-key" \
-e OPENAI_API_KEY="sk-..." \
-e GROQ_API_KEY="gsk_..." \
aurorahq/aurora

Built in native Go. Single binary.

Docs: https://aurorallm.online/docs
GitHub: https://github.com/aurorallm/aurora
Discord: https://discord.gg/AfaFBSU2km

Happy to answer questions!

I kept running into the same problem: I'd solve an issue or make a technical decision, and a few weeks later I had to search through old AI conversations, Git history, and manual notes to recover the context behind it.

So I built Kote.

It indexes development context from AI conversations and Git, then adds a CodeLens above your code in VS Code. When you open a file, you can immediately see the discussions and decisions that led to that implementation instead of digging through old chats or commit history.

The context is also searchable through a web UI, CLI, and MCP server. It's self-hostable and works with your own LLM provider.

See More: https://github.com/pedroaugusto04/Kote

I'm curious if anyone else has this problem, or if you've found a better way to preserve the reasoning behind technical decisions.

Hi everyone,

I built Cortex, an open-source runtime analysis and debugging toolkit for Windows games and native applications.

The goal is to combine several workflows that usually require separate tools into one interface: memory scanning, debugging, patching, screenshots, input automation, disassembly, and persistent project data.

Cortex uses two components:

• an external host for memory scanning and analysis;
• an injectable agent for live debugging, renderer hooks, screenshots, native calls, and background input.

Everything is exposed through authenticated local REST APIs, with OpenAPI discovery and a native MCP endpoint for scripts, developer tools, and AI agents.

Some of the current features include:

• x86 and x64 support;
• typed memory reads and writes;
• exact, comparative, AOB, and string scans;
• breakpoints, traces, disassembly, CFGs, and xrefs;
• tracked patches, freezes, trampolines, snapshots, and rewind;
• background screenshots and keyboard/mouse input;
• Direct3D 8–12 and OpenGL support;
• persistent addresses, pointer paths, structures, and notes.

The project is intended for authorized debugging, offline research, accessibility tooling, and single-player modding. It is not intended for bypassing anti-cheat systems or interfering with online services.

I’d really appreciate feedback on the architecture, API design, documentation, and potential use cases.

GitHub: https://github.com/PdB333/cortex

I've been building an open-source framework called Akan.js and wanted to share it here, partly because I'd like feedback from people who care about how these things are licensed and structured, not just whether they're shiny.

The problem it targets:
for a single feature, you usually end up maintaining something like 8 separate layers.

Schema, query, service, API, fetch client, types, state, UI props. Codegen tools and AI assistants can produce all of those quickly. What none of them do well is keep the 8 in sync when you change one thing three weeks later. The web version and the mobile version drift apart, and you find out in production.

Akan.js takes a convention-over-configuration approach to that. You declare a feature once:

export class ProductInput extends via((field) => ({
  name: field(String),
})) {}

and the framework derives the schema, type, API contract, fetch client, state, and UI prop from that one declaration, for web, iOS, Android, and the server. Change the declaration and the derived layers move with it. The conventions are doing the work, which is also why it stays legible to coding agents. There's less surface area for them to get wrong.

Some honest details:

• It's Bun-first. That's a deliberate constraint, not a hedge. If you're on Node this is not a drop-in.
• Native iOS/Android is a Capacitor shell, not a from-scratch native renderer. I'm not going to pretend otherwise. What I did add at the framework level is page transitions (stack, fade, bottom-up, scale) so navigation doesn't feel like a website trapped in a webview.
• It's early for outside contributors. I've run it on internal projects and a handful of client deployments over about five years.

What I'd genuinely like from here:
Tell me where the architecture is wrong. Whether the single-declaration model holds up outside the cases I built it for. And if anyone has kept web and mobile in sync by hand and has opinions about where this breaks, I want to hear them before more people depend on it.

Repo: https://github.com/akan-team/akanjs (MIT-License)
Docs: https://www.akanjs.com

There's a Discord if you'd rather discuss the design decisions in real time, linked from the repo. Happy to answer anything here too.

Hi. I recently finished the first release of a visual novel engine based in Renpy that works reading CSV files, this means that you can create visual novels with minima programming knowledge. Basically is a simplification of Renpy.

Each CSV file is a scene that contains a dialogue per row (background, music, sound, characters, effects and the dialogue itself in many languages). Each scene can finish by a decision, consequence or a linear transition to another scene.

It is open source and uses Python, here is a video tutorial (in spanish): https://youtu.be/hQgPutc-hpo?si=_EK9Tn4dkkCEWtRD

If you have questions, I'm all ears.

I’ve been experimenting with real-time hand tracking.

The camera detects your hand gestures, letting you control a 3D particle object:

✋ Open your hand → the 3D particle object expands.
✊ Close your hand → it contracts.

The goal was to explore a simple, responsive way to interact with 3D objects using natural hand gestures.

Github Link

Where do you think this could be useful beyond a tech demo? I’d love to hear your ideas and feedback.

I have built an offline FOSS app to perform PDF and DOCX operations after getting fed up by sluggish, freemium websites like ilovepdf and smallpdf.

Thanks to the community's amazing support, the project just crossed 100 stars! I've spent the last few weeks using your feedback to optimize the UI design, improve functionality, and heavily reduce the app size.

Source - https://github.com/vasuki-re/IStanPdf

My goal is to help as many users as possible permanently ditch these freemium sites. If you like the project or the idea, please consider giving a star to the repo - it really helps the app reach more people!

A while ago, I saw a post about a deaf mom expressing how much real-time captions meant to them, seeing what her kids say while playing (3rd photo).

Yes its not the most unique project but the existing projects are either not local, dont have a clicktrough overlay, no transparent text option, not performant enough, dont have enough customization options or just not good looking enough imo.

I want more people to be interested in the goal, and have people that are actually using it. So feel free to drop by and tell me what you think https://github.com/ErdemKaraahmet/Real-Time-Subtitler

I wrote a free, open-source book that teaches how to build a modern Wayland desktop shell using Quickshell and QML.

The book covers:

• QML from the fundamentals
• Panels, docks, launchers, widgets, notification centers, and lock screens
• Integration with Hyprland, PipeWire, MPRIS, UPower, BlueZ, and systemd
• Component architecture, theming, and project organization
• Building a complete desktop shell from scratch

Each chapter includes runnable examples, and the complete source code is available under the MIT License.

If you're interested in building your own desktop environment or learning Quickshell, I hope you find it useful.

https://github.com/programmersd21/the_quickshell_book