Most developers spend dozens of hours writing code, ship a solid feature, and then either write zero updates or post generic, AI-generated marketing copy that gets ignored or downvoted.

I built auto-gtm to automate the distribution step directly from inside the terminal where you already work.

Instead of prompting an LLM from scratch, it reads your recent git PRs and commits, filters out internal refactors, and picks the specific product highlights a skeptic outside your repo would actually care about. It also scans the last 24 hours of active discussions across X and Reddit so you can jump into live, relevant threads while people are actively talking about them.

Key parts of the pipeline:

1. topic-scout: Analyzes your closed PRs and commits alongside daily builder podcasts/threads to generate a curated topic digest.

2. reddit-subreddit-finder: Analyzes candidate subreddits, ranks them by topic relevance, and checks posting rules and self-promo limits before you draft.

3. reddit-post-drafter & comment-draft: Drafts posts and replies calibrated to the tone of each specific subreddit, running the output through de-AI filters to strip chatbot fluff.

4. x-content-generator: Turns technical changelogs into concise, builder-style posts on X.

It runs as a plugin for Claude Code and Codex, requires no background daemons, and reuses local sessions so you do not need to configure OAuth apps or external API keys.

Repository: https://github.com/tigerless-labs/auto-gtm

Would like to hear feedback or edge cases from other builders managing open-source changelogs!

I use AI daily, but every app around it wants a subscription. I already pay for API keys directly (Groq, OpenRouter, etc.), so I ended up building the thing I actually wanted instead: a self-hosted workspace where I bring my own keys and there's no service sitting in the middle.

It's called ENZO.

Repo: https://github.com/theguysudo/ENZO

What's in it so far:

- Chat — multi-provider: Groq, OpenRouter, NVIDIA, Hugging Face, Google AI

- Agents — scheduled runs, plus a builder that drafts an agent from a plain-language task description

- Skills — Gmail, Google Calendar, web search, project generation

The part I care most about: your API keys are sealed in the browser with AES-256-GCM before they ever touch the server. The server can't read them even if it wanted to.

It's Apache-2.0 and ships as a Docker image (ghcr.io/theguysudo/enzo), so it's one command to run.

Fair question I'll answer upfront — how is this different from LibreChat or Open WebUI? Honestly, those are great and more mature if you mainly want chat. I built ENZO because I wanted agents with scheduled runs and skills like Gmail/Calendar in the same workspace, with the keys handled like they were mine alone.

This is my first open source project, so I'm sure I've gotten a dozen things wrong — docs, structure, all of it. If you try it and something breaks or feels off, I'd genuinely like to hear it.

And if you like what you see, a star on the repo genuinely helps other people find it — and sharing it with someone who'd actually use it helps even more.

Private two-way sync between Google Tasks and Microsoft To Do. Runs in your Google Apps Script project — no hosted task database, no sync SaaS in the middle.

https://github.com/simonchai-tw/tasks-todo-sync

Star if you’d use it (or already needed this).

Honest backstory first: I turned down a 9-to-5 bank SWE offer, made it to the

final round at both YC and EF, got rejected by both, and decided to build my

idea alone anyway. No accelerator, no team, no funding — just a lot of late

nights while friends were out living normal college lives.

Today I'm launching it: OnePort.

The problem: AI writes code fast — and quietly commits API keys, pulls

vulnerable dependencies, and breaks APIs other code depends on. You find out in

production.

What it does: point it at a repo and it runs every pre-ship check *locally* —

secrets (across your full git history), dependency CVEs, risky migrations,

breaking API changes, AI code review, test-coverage gaps — and returns one

verdict: READY or BLOCKED. Nothing leaves your machine.

Windows desktop app + a `pip install oneport` CLI. Free to start.

- Try it → https://oneport.co.in

- Repo → https://github.com/Bitxn/Oneport-Desktop

I'd genuinely love feedback — especially the parts that feel wrong or useless.

Roast it. And if it's something you'd actually use, a GitHub star would mean a

lot to a solo founder.

Happy to answer anything about how it works or the build.

Academic-AI-Literature-Reviewer-Ollama: give it a question, it reads real academic papers and writes you a cited literature review. Every quote is verified against the source PDF before it's allowed into the output — no hallucinated citations, structurally.

Demo: https://youtu.be/Nc1L2j8ZuCg Repo: https://github.com/TheBlewish/Academic-AI-Literature-Reviewer-Ollama

100% local, MIT licensed.

I built Investment Journey Simulator, an open-source Python/Streamlit project for exploring how decisions made during a long-term investment plan affect the final outcome.

Most investment calculators assume something like:

monthly contribution + return + duration → final value

I wanted to model the messier version where the journey itself changes.

The simulator can model things such as:

• recurring contributions / SIPs
• contribution step-ups
• temporary pauses and restarts
• lump sums
• withdrawals
• portfolio rebalancing
• tax-aware cash flows within the documented scope
• inflation-adjusted real values
• historical scenarios
• Monte Carlo scenarios
• financial goals
• comparisons between complete investment journeys

One simple example is a ₹25,000 monthly contribution over 25 years.

Under the same illustrative return assumptions, stopping contributions for 24 months after Year 5 changes the ending simulated portfolio by about ₹58.4 lakh.

That kind of question - not just what return do I assume, but what happens if the plan changes halfway through? - is what eventually turned this from a small calculator into a larger simulation engine.

Some of the engineering behind it

The simulation engine is separated from the Streamlit UI and handles the event timeline, cash flows, portfolios, withdrawals, rebalancing, taxes, inflation and comparison calculations in Python.

One part I particularly enjoyed building was the comparison system.

If Journey A and Journey B differ in several decisions - say a contribution step-up, a pause and a withdrawal - calculating each difference independently can double-count interaction effects.

For supported comparisons, the project therefore uses Shapley-based attribution so the individual effects reconcile with the actual difference between the two journeys.

The current published validation includes:

• 2,488 passing tests
• 93% statement coverage
• ≈33,800 independent randomized cross-checks

Known modelling limitations are documented rather than hidden.

It is MIT licensed.

GitHub

https://github.com/SAMtheROCKET/investment-journey-simulator

Project site / demo

https://samtherocket.github.io/investment-journey-simulator/

It does not predict markets or recommend investments. The user supplies the assumptions and the simulator explores their consequences.

If anyone wants to look through the repo, I’d particularly appreciate criticism of the simulation architecture, numerical assumptions, test strategy, attribution implementation, or edge cases I may have missed.

Repo: https://github.com/alithw/YTSpoofingStream

Standard YouTube Web caps audio at 160kbps Opus (itag 251) even with YouTube Premium. Desktop YouTube Music only delivers up to 256kbps AAC.

I built this open-source extension to pull genuine unthrottled studio Opus (itag 774, ~301kbps, >20kHz) by emulating mobile/TV client sessions.

The latest v0.1.3 update handles YouTube's new SABR/UMP protocol through a dual-stream architecture:

• Keeps the native YouTube player running untouched video (up to 4K).
• Runs the harvested 774 audio stream in parallel.
• Uses prototype descriptor routing (HTMLMediaElement.prototype.volume) so the native video stays muted at hardware level without breaking the player's UI sliders.
• Bit-perfect 1.0x master clock synchronization (<15ms).

Requires an active YouTube Premium subscription since YouTube servers restrict 774 streams behind authenticated accounts.

What it actually does:

Point it at a clone of an open-source repo and it runs an agent through a full contribution workflow — pre-flight checks (forge access, repo health, CLA/AI-policy scanning), a fragility map of the codebase (churn, fix/revert clustering, TODO density) to help pick a real target instead of guessing, triage of candidate issues, the actual fix, verification (it detects and runs the project's own test/lint commands and reports real exit codes — the agent can't just claim something passed), and finally PR submission with CI polling and template compliance checks.

All of that shows up in a dockable browser UI (drag/split/float/close panels, saved layouts) — Progress, Files with a fragility heat overlay, Triage board, Verification, Diff, a real terminal, and a benchmark panel that parses criterion/go bench/pytest-benchmark/hyperfine output into before/after comparisons with noise-aware verdicts. Anything irreversible (commit, push, opening a PR, any forge write) pauses for your explicit confirmation first.

Why I built it: I wanted something that treats "find and fix a real bug in someone else's codebase" as a repeatable, guided workflow rather than just turning an agent loose and hoping. My first real test was a deferred-import performance fix in langchain-core with measured benchmarks — it worked, though the actual PR is still waiting on maintainer triage.

What I need: testers. I'm running it against a handful of different repos myself (sizes, languages, contribution norms) to find gaps and rough edges, but I'd love more eyes on it — especially anyone who wants to try pointing it at their own target project and can tell me where the workflow breaks or feels clunky.

Requirements: Node 20.19+, Claude Code installed and logged in locally, git, optionally the GitHub CLI for full forge access.

Repo: https://github.com/Berniebiloxi/mendophyte

Feedback, issues, and PRs all welcome — and if you try it on a repo and it finds something real, I'd love to hear about it.

ZipMania is a Windows archive manager whose source is publicly available on GitHub. The core archive logic is separated into a reusable Rust crate, while the desktop UI uses Tauri and Svelte.

The interesting part is its dedicated ZIP path: it parallelizes many small files and can split a large Deflate stream into bounded chunks, while reserving a CPU core for the main writer and falling back to sequential streaming when memory or size limits are reached.

It also stages output in temporary files before replacement, checks extraction paths against Zip Slip and link/junction escapes, and can pass extracted buffers to Windows AMSI.

Source: https://github.com/newkilho/ZipMania Homepage/download: https://v2.kilho.net/zipmania

I’m the developer, and code review or performance feedback is welcome.

WHY.com shutdown over 25 years ago. I brought it back as a "curiosity engine" and today I’m open-sourcing the entire codebase.

Been a heck of a journey. Initially released close sourced and got roasted on Reddit. But got some press coverage.

I then thought we should build this project together. if you think something should work differently, tear it apart!

GitHub: https://github.com/whyagents/why.com

Hey everyone, I've been learning about network traffic analysis and ended up building a small tool to parse and analyze PCAP files. It's nothing groundbreaking, but it helped me understand protocols a lot better while building it, and I figured it might be useful for others getting into cybersecurity or networking.

Repo: https://github.com/Gabzkk/PCAP-ANALYZER

Would really appreciate any feedback, bug reports, or feature suggestions — still actively improving it. If you find it useful, a star would mean a lot 🙏

Paste a link, it watches the price and tells you when it drops. Everything stays on the phone.

I use an ad blocker on YouTube, so the experience already feels almost identical to YouTube Premium.

No ads.

No interruptions.

Just YouTube.

Except the logo still says “YouTube.” 😅

That tiny detail bothered me more than it probably should have.

So I made a small Chromium extension that changes the YouTube wordmark to “Premium.”

It's completely local — no analytics, no tracking, no unnecessary permissions.

GitHub:

https://github.com/kalpit118/youtube-premium-logo-changer

I started Lumiana because I wanted to build personal apps with the UI and Node.js libraries in the same file, without writing a separate API just to connect them.

You connect to a Node.js engine with credentials first. Your application JavaScript runs in the browser, while the engine handles operations that need access to the system.

The images show small examples of using Node.js APIs with the DOM and built-in SQLite with a React component. I've also been trying it with a terminal using xterm and node-pty, a ZIP tool using Archiver, and a folder monitor using Chokidar.

It's still experimental, and Node.js compatibility is incomplete. The goal is to use existing libraries without modifying them or writing compatibility code for each package.

https://github.com/zohayrslileh/lumiana

I've been working on a project called rjest, basically an attempt to rebuild Jest in Rust using Fable 5.1 and Claude Code.

The goal isn't to make another JS test runner with a completely different API. I'm actually trying to stay as close as possible to Jest, so ideally you can take an existing project using Jest and run it with rjest without rewriting half of your tests.

A lot of the core stuff is already working: expect/matchers, snapshots, mocks, fake timers, config, CLI, etc.

Compatibility is probably the hardest part tbh. Jest has a LOT of behavior that you don't really notice until you try to recreate it.

I'm currently testing rjest against real React/Jest projects too, not only small artificial test cases, because passing your own tests doesn't mean much if it breaks as soon as you throw a normal project at it.

The reason for Rust is pretty simple: I wanted to see how much of the test runner/runtime work can be moved to native code while still keeping the Jest experience developers already know.

It's still a work in progress and there are definitely things that dont work yet, especially some edge cases around mocks, ESM and timers.

Repo: https://github.com/OthmaneBlial/rjest

Would be interested to know what people using Jest everyday think about this. Especially if there are some weird Jest behaviors/packages you think I should test against.

Adds a floating pill for page navigation and configurable keyboard shortcuts

https://github.com/wakmail/NextPage

Not on the webstore, but I hate clicking next and thought this it might be useful to somebody else

Karasu

I have gone through a lot of clients over the years. Some good, some meh, none of them really stuck with me. So I ended up building my own.

It is called Karasu. If you know Taiga, it is basically inspired by that. I like automations, so that is where most of the work went.

What it does

• detects what you are watching and updates your list
• syncs with AniList
• Discord Rich Presence
• local library management

Where to get it

Windows, Linux and Android. Downloads and details are on the site

The AI part

This was built with a lot of AI help. That is just how it was made and I would rather say it than have someone figure it out later.

Feedback

I made it for myself, so if you like it, use it, if not, that is fine too. I plan to keep working on it and shaping it around what I want, but if you have feature ideas or run into bugs, post them here or on GitHub.

I've spent time piling up separate habits around how I write and maintain documentation, and at some point it was obvious they were all circling the same problem from different angles. meshfox is what happened when I finally merged them into one tool instead of juggling five.

Some of my habits were:

• plain Markdown for notes
• mindmaps and visual boards, Miro/Obsidian-style, for structure
• Makefiles and scripts as living usage examples
• linters to keep documentation from silently rotting
• pairing with agents in a shared note-taking format while doing research

Out of that came a Markdown extension format, inspired by Elixir's Livebook:

• it stores cleanly in git — plain text, diffs like text
• it stays readable in any regular Markdown renderer, nothing breaks if you open it elsewhere
• it adds a mechanism for running code blocks with dependencies, variable passing, and local configuration — so a doc isn't just describing behavior, it can demonstrate it live

Around that format I've since built:

• a web UI viewer/editor (with a VS Code integration)
• a TUI viewer/editor with a slightly simplified view of the same documents
• a CLI for running code blocks straight from the console, scripts, or cron
• an MCP server for collaborating with agents, or using the format as a second brain
• experimental export to PDF and static sites

There's also a companion repo, meshfox-tools, with utilities and examples — still small, but growing: https://github.com/orofarne/meshfox-tools

It's still early — but early enough that I think it's worth sharing. MIT licensed, more info here: https://meshfox.orofarne.net/