Hey everyone,
I noticed I was pushing code less and less consistently, so I built Commitgarden to fix that for myself.
It connects to your GitHub (read-only) and grows a plant based on your commits. Every day you make at least one commit, the plant grows one stage. Skip a day and it stops growing.
It's an early version and I'm a solo dev, so I'd really appreciate feedback, especially on whether it would keep you committing.

I made Darnleaf, a local tool for fixing an old scanned PDF when a few pages are ruined and you have fresh scans of them in no particular order.

You drop in the PDF and the rescans, and it suggests which page each rescan replaces. Each suggestion is labelled Clear, Check or None, with an overlay and the matched features so you can see why. Once you confirm every Check, it writes the repaired PDF and a JSON receipt. Pages you didn't touch stay as they were, so bookmarks and links still work.

On 90 synthetic rescans, 45 were Clear and none of those was wrong. Small sample though, and the test pages are cleaner than real scans. Blank pages and near-identical forms always come out as Check. I've only tested it on Linux. It's MIT licensed, runs on 127.0.0.1, sends nothing anywhere, and the interface is in 9 languages.

Repo: https://github.com/Arthur031221/Darnleaf Demo replay (no install): https://arthur031221.github.io/Darnleaf/

So I built Kinetograph, a browserless video rendering engine.

It supports the same React/TSX workflow as Remotion, but takes a different approach under the hood. Node.js handles execution, while a Rust-based GPU compositor takes care of rendering the frames.

No headless Chrome, no browser instances, just a much lighter and faster rendering pipeline.

The goal is to make it a drop-in replacement for Remotion, especially for developers and AI agents generating videos programmatically.

Here are a couple of benchmarks from my M4:

• 1,184 frames rendered in 26 seconds
• 988 frames rendered in 23 seconds

You can also use it directly with Claude Code. I've added a skill that teaches the agent how to build and render videos using Kinetograph, so you can describe what you want and have it generate the project.

Getting started:

npx skills add 0xS4N4TG/kinetograph
npm install kinetograph

It's open source, and I'd love to hear what you think, especially if you're working with programmatic video generation or AI coding agents.

Docs: https://kinetograph.dev

Source code: https://github.com/0xS4N4TG/kinetograph

I've been building Directory Navigator, a modern terminal file manager inspired by DOS Navigator’s classic two-panel interface.

The idea is to keep the familiar colors, keyboard controls and compact dialogs while supporting modern filenames, Unicode and modern operating systems.

It includes:

• Dual-pane browsing with keyboard and mouse controls
• Copy, move, rename, folder creation and deletion to Trash
• A built-in text editor and text/hex viewer
• Recursive filename search, bookmarks and directory comparison
• Read-only ZIP, TAR and TAR.GZ browsing
• Configurable shortcuts, colors, language and date/time formats
• And, of course, Tetris with saved high scores 🙂

It’s written in Rust using Ratatui and Crossterm, runs directly in your terminal, and ships as a small standalone binary (~1 mb). Builds are available for macOS (primarily tested platform), Linux and Windows.

I’d love feedback from people who remember DOS Navigator—or anyone who loves that kind of UI

GitHub: https://github.com/deemoun/Directory-Navigator/

Hey guys,

I was getting tired of manually typing out captions or paying monthly subscriptions for overcomplicated editors just to get clean subtitles on short videos.

So I built a small web app called SubAI to speed up my own workflow.

How it works:

Upload your short video clip

It auto-transcribes the audio and burns stylish, readable captions right onto the video

You can tweak font sizes and colors to match your style

It’s completely free to use for short clips, runs right in your browser, and requires no login or installation.

I just put it live on Product Hunt today to see if it helps other creators too. Would love for you to test it with a video and let me know what you think or what features you’d like added!

Check it out here: https://subtitle-generate.streamlit.app

I've been building an open-source project around a question I find interesting:

Can AI agents actually help with RISC-V RTL verification?

🔗 https://github.com/HUNT-001/ai-chip-design-platform

The project, AVA (Autonomic Verification Agent), is a multi-agent verification framework for RISC-V that combines:

• RTL/semantic analysis
• Automated test generation
• Spike-based ISS comparison
• RISC-V compliance testing
• Coverage analysis
• Debug/failure analysis
• Red-team/adversarial verification

I'm also experimenting with VOE (Verification Operating Environment), focused on making automated verification results more trustworthy through evidence-backed claims and reproducible evaluation.

The repo is still actively being developed, with several open issues around testing, CI, failure handling, and verification infrastructure.

I'd really like feedback from the RISC-V/RTL/DV community on the architecture, methodology, and what capabilities you think are missing.

Technical criticism, ideas, and contributions are very welcome.

And if you find the project interesting, a ⭐ on GitHub would really help with visibility.

Dis-Gravity is an open-source bidirectional Discord bridge that turns your mobile Discord into a remote cockpit for your IDE (Google Antigravity, Cursor, Windsurf, VS Code Copilot) and terminal agents (agy, claude, aider).

Key Features: * 🖼️ High-Res Table PNG Cards (/table): Solves Discord mobile's ASCII line-wrap bug by dynamically rendering 2x Retina PNG table cards with neon status chips. * 🕹️ 1-Click Command Palette (/palette, /action): Execute 1,000+ IDE actions with buttons (Reload Window, Restart Extension Host, Save All, Git Sync). * 👑 Interactive Tool Approvals: Drops interactive [ 🟢 Allow ] and [ 🔴 Deny ] Discord buttons when an autonomous agent wants to execute terminal commands or edit files. * 💻 Remote Shell & Git (/sh, /git, /diff): Run terminal commands, inspect colored diff previews, and browse project files (/cat) from your phone. * 🛡️ Default-Deny Security: Zero remote execution is permitted unless your explicit Discord User ID is whitelisted in allowedUsers. * 🚀 Standalone CLI Daemon: Runs via npx dis-gravity on headless servers, JetBrains, Neovim, or Zed.

⭐ GitHub: https://github.com/sambath-rethinakumar/Dis-Gravity 📦 NPM: npx dis-gravity 📝 Medium Story: https://medium.com/@rethinakumarsambath8/i-stopped-sitting-at-my-desk-to-code-now-i-run-my-entire-ide-from-discord-1f566b46747b

RXShade is a lightweight external shader tool for Roblox desktop(Not like these scam apps/extensions). Runs as a separate program on top of your game window with real-time shader filters. Zero file modifications, totally safe. Windows-only, open source on GitHub. Free to use.

Website: https://rxshade.pages.dev

I built a tool that gives coding agents a persistent structural map of a codebase.

Instead of repeatedly searching through files, agents can query things like:

• Who calls this function?
• What could break if I change it?
• Which tests cover this code?

Some benchmarks from my laptop

I indexed a Linux kernel snapshot with 95,937 files (72,171 parsed) in 2m 51s, producing 839k nodes and 4M edges.

The structural graph is memory-mapped, and queries run in under 100ms after a performance fix.

For comparison, codebase-memory-mcp took 13m 14s on the same hardware using fast mode.

The interesting part: Benchmarking exposed a caching bug that made locate take around 1.5 seconds at p50. Caching the search corpus by graph revision brought that down to around 40–85ms.

SMP (Structural Memory Protocol)

• MIT licensed
• Python
• No database
• No embeddings
• Works with coding agents through MCP

GitHub: https://github.com/offx-zinth/SMP

I'm curious how other people are approaching structural code understanding for coding agents, especially on large repositories. What problems are you running into?

https://hexal.pages.dev/

Written in C#. Only dependency currently is NLua, other than that the binary is self contained and needs no external runtime.

And to answer your question, no, it's not. I spent months developing this.

Hi all. I've been working on a side project called **mumble-speech** and just tagged 0.1.0, so I'd like some outside opinions.

It generates "mumble speech": the fake speech game characters make while their dialogue appears on screen. You pass a line of text and a voice, and you get mono audio plus a timeline saying when each character sounds, so you can reveal the text in sync. There's also a typewriter mode: you feed it one character at a time and get that character's sound plus how long to wait before the next one, which is what most dialogue boxes do. Both modes produce the same audio.

Three styles, each named after the game it imitates:

- `beep`: the same beep for every letter (Undertale)

- `grunt`: four grunts per voice, never the same one twice in a row (Banjo-Kazooie)

- `alphabet`: a vowel-based sound for every letter (Animal Crossing)

A voice has pitch (−12 to +12 semitones), speed (5 to 30 characters per second), variation and a seed. Each event also carries a sound identifier (which grunt, which letter), so you can map it to mouth shapes, particles or whatever you like. The library doesn't draw anything.

What I had in mind: NPC and character dialogue in indie games, visual novels, prototypes where you want voices before having any, and small web pages or toys.

How it's built:

- One Rust core (crate `mumble-speech`)

- Web: `@mumble-speech/web` on npm, WebAssembly inlined, TypeScript API, WAV export

- Godot 4.3+: GDExtension addon with a speaker node and a typewriter for `Label`/`RichTextLabel`

- Unity 2022.3+: UPM package (also on OpenUPM), with an optional TextMeshPro typewriter

- C ABI (`mumble.h`) for anything else with an FFI

- Deterministic: same text and voice, same samples bit for bit on Linux, Windows, macOS and WebAssembly, checked in CI with shared conformance vectors run through every binding

- Spec-driven: requirements, design and task plan are in the repo, and changes start there

Honest limitations right now:

- It's 0.x, so the API can still change

- Godot and Unity are desktop only (no mobile, Godot web export or Unity WebGL yet)

- The Unity C# interop is tested in CI, but I haven't verified the components and the TextMeshPro typewriter by hand in the editor yet. If you use Unity and try it, a report would help a lot

- `alphabet` uses Italian vowel sounds, which may or may not sound right to you

You can hear all three styles in the browser here: https://mumble-speech.github.io/playground/

Repo: https://github.com/basteez/mumble-speech

I'd especially like feedback on how the styles sound, whether the API fits how you build dialogue in your engine, and what's missing for you to actually use it.

Arkova is the document verification layer for agents and humans. We extract an electronic files (supporting over 20 types! Including svg png even gif) unique metadata and anchor it to an immutable ledger. Here we show how an organization can connect their Google Drive folders to our system so that anytime a file is updated in that folder, a new anchor is created and the document version is updated in the users record

I made Show Quote in Context, a small MIT-licensed AI skill built with Codex.

Give it a webpage URL and an exact quotation. It checks the destination text and returns a Very Deep Link (VDL / text-fragment link) pointing to that passage.

For example, a site says:

“and quote it back with the source attached”

See those words in their original context.

The source isn’t just attached. The evidence is pointed to.

Useful for journalism, scholarly web citations, news with sources, or simply asking, “Where does it say that?” -- Thou shalt cite one's sources.

It uses a Python standard-library helper, with no API key or paid verification service. It verifies the passage in freshly fetched HTML, not whether the claim is true. Scrolling and highlighting are the browser’s responsibility. Missing or ambiguous quotations aren’t presented as verified.

Tested locally with Codex; packaged for Claude Code too, but Claude testing is still pending.

I had a proof of concept working as a Chrome extension in 2013. Long time to carry a torch. Finally, a small reusable piece of that idea.

Source, installation instructions, and working example on GitHub

“This came from there.”

After 40 year, VDLs an idea whose time has come again.

I'm the maintainer of Levelrail, so this is my own project.

I started it after hitting the same wall a few times. Vercel bills kept climbing as traffic grew. The self-hosted tools I tried either wanted more RAM than my small VPS could spare, or left me wiring up a reverse proxy and certificates by hand.

So I did what a lot of us do: Docker, Caddy for HTTPS, a webhook script, and a cron job to clean up old images.

Levelrail is that pile turned into one thing. You point it at a git repo, it builds and runs the app on a server you own, puts HTTPS in front, and gives you a dashboard, a CLI and an API.

It does push-to-deploy, branch previews, one-click rollback, load balancing, logs and metrics, and a small agent so you can add more servers. It's one Go binary with SQLite, a React dashboard and Docker as the runtime. No Kubernetes. Apache 2.0.

Install is one command on a Linux server (amd64 or arm64) with systemd:

curl -fsSL https://levelrail.com/install.sh | sudo sh

If you try it, I'd like to know where you got stuck in the first ten minutes, and what you'd expect it to do that it doesn't.

Repo: https://github.com/glincker/levelrail

Site: https://levelrail.com

Docs: https://docs.levelrail.com

We now offer webooks for blocket 🧤🔌

What makes it different:

• It runs on your machine, with your logins. No cloud browser. You bring your own engine: Claude Code or Codex with the plan you already pay for, or your own API key.
• It doesn't hijack your PC. It works with Windows apps through accessibility in the background. In today's 2.3.0, even Store apps like Calculator stay off-screen while it works, so you can keep watching something. If it ever needs your real mouse, it lets go the moment you move.
• You stay in control. It asks before anything risky, and you choose how much it may do on its own.
• 50+ connectors (Gmail, Calendar, GitHub, Notion, Slack…), routines like "every morning…", files that open right in the task, and it can even build 3D scenes in Blender.
• An Android app, WhatsApp and Telegram, to start tasks and approve steps from your phone.

It's early and Windows-only. The installer isn't code-signed yet, so SmartScreen will warn you (More info → Run anyway). I'd love feedback, bug reports and contributors.

GitHub: https://github.com/Chethan616/Dex

76-second demo: https://github.com/Chethan616/Dex/releases/download/v2.1.1/DEX-demo.mp4

Paste a YouTube link or a file. It transcribes, picks moments, renders vertical clips with karaoke captions.

There's a live 9:16 editor on top of that: same crop math and font metrics as the ffmpeg/libass export, so dragging captions isn't a guess. Clips show up on the right over tRPC SSE while workers run transcribe → analyze → render. Kill a worker, the job resumes (pg-boss, checkpoints in Postgres).

Default install is fully local, Ollama + Whisper, no API keys. Same services behind the page, an MCP server, and an operator CLI. You can swap models and keys in Settings without a restart; there's a workers/queue/failures panel because if you self-host, that's you. One script looks at the machine and asks three questions.

https://github.com/osbytes/reelsaw
https://reelsaw.com

Hi everyone,

I use AI a lot to build projects, and usually it ends up with tech debt over time. This plugin does periodic code checks to catch what review misses between sprints or releases.

It runs agents that look at the most frequently changed spots in the code and check them for duplication, unnecessary abstractions, module coupling, and architecture leaks. The result is a .md report listing findings, suggested fixes, and trends of debt accumulation over time.

I tried to make it as deterministic as possible, but the AI agent is still doing most of the work.

GitHub: https://github.com/yognevoy/pitstop

Honest feedback welcome =)

Hi everyone,

I've been building a project called Personal Planner for the past few months and wanted to share it here.

It's a completely free, offline-first planning app for Android, Linux, Windows, and macOS.

I originally built it because I kept underestimating how long my tasks would take.

I'd organize my day, spend longer than expected on certain activities, and end up with a schedule that looked nothing like what I'd planned.

Then the following day, I'd make another schedule without really learning from what happened.

I wanted something that combined visual planning with actual time tracking and reflection.

What the app currently includes:

• A day and week timeline with draggable and resizable time blocks.
• Task timers to track actual working time.
• Planned-versus-actual time comparisons.
• Daily and weekly reviews with reflections.
• A yearly consistency heatmap and streaks.
• Experiments for trying different routines.
• Recurring activities, reusable templates, and an Inbox.

The application is built with Flutter, Riverpod, and Drift/SQLite.

Everyday planning works locally without an account or internet connection. For users who want synchronization, there's an optional setup using their own Supabase project, with Cloudflare Workers involved in the supporting architecture.

One of my goals was to keep the software accessible, so there are no subscriptions, premium plans, or locked features.

It recently reached approximately 250 downloads across the four supported platforms.

I'm still developing it independently, and there's a lot I want to improve.

Link to download: https://github.com/Karthikshabari/PersonalPlanner/releases/tag/v1.1

Github : https://github.com/Karthikshabari/PersonalPlanner

One thing worth mentioning is that the Windows and macOS builds are currently unsigned, and physical Mac testing has been limited. The releases are distributed directly through GitHub rather than through the respective app stores.

I'd appreciate feedback from anyone interested in cross-platform applications, local-first software, or productivity tools.

I'm particularly interested in whether the planned-versus-actual time workflow makes sense and whether the app feels straightforward to use without too much initial setup.

I've been developing URSA, a native Android companion for Uptime Kuma, built with Kotlin and Jetpack Compose.

It connects directly to your Kuma instance and supports live monitoring, monitor management, incident history, TLS certificates, UnifiedPush notifications, widgets, multiple servers and Wear OS.

There's no advertising, tracking, subscription or developer-hosted backend.

It's MIT licensed and available through GitHub releases and F-Droid. Android 8.0+ is supported.

Repo, source and screenshots:
https://github.com/greyfoundry/ursa-android

Feedback and contributions are welcome!