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

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

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

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.

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

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!

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

I've just open-sourced PDFClear, a privacy-first collection of PDF tools that processes documents directly in the browser.

I built it because most online PDF services require users to upload potentially sensitive documents to a remote server. With PDFClear, the documents themselves stay on the user's device.

It currently supports:

• Merging, splitting, rotating, reordering, and compressing PDFs
• Adding text, images, signatures, watermarks, and page numbers
• Filling forms and editing PDF metadata
• Converting between PDFs, images, text, HTML, and Markdown
• Browser-based OCR for scanned documents
• Local AI summarization and semantic PDF search

The AI and OCR tools download their required assets when first used. Once those assets are loaded and cached, users can disconnect from the internet and continue working locally.

The project is built with React, TypeScript, Vite, PDF.js, pdf-lib, qpdf-wasm, Tesseract.js, and Transformers.js. It is licensed under Apache-2.0 and can also be self-hosted.

Source: https://github.com/aliansari22/pdfclear
Live version: https://www.pdfclear.com

I'd especially appreciate feedback on the privacy model, browser architecture, documentation, and areas where contributors could help.

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. 

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!

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!

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.

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.

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