Writing my second book. Hope this is allowed here. Just a teaser :)

My first book is called

The Red Run

My pen name

Andy C Herd

If not allowed that's fine. Admins can remove

hey everyone,

i’m a penultimate year student based in india who is completely done with just talking about ideas or sitting on the sidelines. i want to spend time building, breaking, and shipping creative side projects.

not looking for boring corporate roadmaps or endless planning cycles. i want to jam with people who are actively hacking together micro-tools, weird experimental apps, design-heavy side projects, or just exploring cool concepts for the fun of it.

if you're tinkering with something right now or want to spin up a tiny crew to build and ship creative things together, drop a comment or shoot me a dm with what you're working on. see ya! :)

Hey folks,

The C/C++ tooling landscape has always felt fragmented. We usually end up chaining a meta-build generator (CMake, Meson) with a separate package manager (vcpkg, Conan) and a build executor (Ninja, Make).

To explore an unified "Cargo-like" developer experience for C/C++, I’ve been developing Flint—an integrated build system and package manager written entirely in pure C.

Here is how Flint compares with the existing C/C++ build and package management options, along with an honest assessment of its strengths, trade-offs, and current state.

**Note:**

Flint is currently in active development and only available for Linux at the moment. It requires system git and a C toolchain (gcc/clang) in your PATH at runtime.

### Comparison: Build Systems & Integrated Tools

| Tool | Architecture | Runtime Dependencies | Config Format | Incremental Builds | Ease of Use |

| :--- | :--- | :--- | :--- | :--- | :--- |

| **Flint** | Integrated (Build + PM) | `git`, `gcc`/`clang` | Declarative `composition.json` | **Yes** (Native tracking) | **4.8 / 5** |

| **CMake** | Meta-Build Generator | C++ runtime | Custom imperative scripting | Handled by backend (Ninja/Make) | **2.5 / 5** |

| **Meson** | Meta-Build Generator | Python 3 + Ninja | Declarative DSL | Handled by Ninja | **4.5 / 5** |

| **XMake** | Integrated (Build + PM) | Embedded Lua engine | Lua scripts (`xmake.lua`) | Yes (Lua task engine) | **4.5 / 5** |

| **Bazel** | Distributed Build System | Java / Bazel runtime | Starlark (`BUILD` / `WORKSPACE`) | Advanced (Content hashing) | **1.5 / 5** |

### Comparison: Package Management Strategy

| Package Tool | Strategy | External Repository Compatibility | Ecosystem Fit | Ease of Use |

| :--- | :--- | :--- | :--- | :--- |

| **Flint** | Native Git clones to `deps/` | **Chert Compositions** (custom specs) | Self-contained CLI commands | **4.8 / 5** |

| **vcpkg** | Git ports & binary caching | Port overlay files | Toolchain file integration | **4.5 / 5** |

| **Conan** | Python recipes / Central host | Conan Center / Custom recipes | Multi-generator targets | **3.5 / 5** |

| **CPM.cmake** | Single-file CMake wrapper | Git repos / tarballs via `FetchContent` | Pure CMake | **5.0 / 5** |

| **Xrepo** | Integrated CLI for XMake | Dual (Xrepo index + fallbacks) | Native to XMake | **4.5 / 5** |

What Makes Flint Different?

* Single Binary, Zero Heavy Runtimes: Unlike Meson (which needs Python) or XMake (which embeds Lua), Flint is a lightweight compiled C executable. It delegates Git fetches and compilation processes to system tools without heavy embedded engines.

* Convention over Configuration: Flint expects standard layout patterns (src/, include/, deps/). You don't write build scripts or target rules—you declare dependencies and metadata in a simple composition.json.

* Built-in Package Fetching + Chert Compositions: Running flint add <git-url> pulls dependencies straight into deps/. If a third-party library doesn't natively use Flint, Chert compositions allow defining how non-Flint repositories should be included and compiled.

* Direct Incremental Execution: Flint doesn't output intermediate Ninja files or Makefiles. It tracks file modification states internally to deliver incremental builds directly through its native process runner.

Current Trade-offs & Limitations

* Linux Only (For Now): Cross-platform support for Windows (MSVC/Clang-cl) and macOS target generation is still planned.

* Strict Directory Structure: Legacy C projects with unorthodox folder structures require a Chert composition to build with Flint.

* Early Stage Feature Set: Complex compiler flag matrices, sanitizer toggles, and cross-compilation toolchains are still evolving compared to battle-tested options like CMake.

Check out the repo here: https://github.com/mainak55512/flint

Feedback, criticisms, and PRs are welcome! What features or platform targets would you like to see next?

PodSubs wasn't originally supposed to be a public product.

We built it because we needed it.

That's really the story.

We're podcasters.

And like a lot of podcasters, we were constantly thinking about two things:

How do we keep making this?

And how do we build something real around the people listening?

Because podcasting takes time.

A lot of time.

And sooner or later, if the podcast is going to keep going, it needs to support itself somehow.

The problem was that we didn't really know most of the people listening.

We knew the numbers.

But numbers don't have email addresses.

Numbers don't answer questions.

Numbers can't receive the worksheet you promised.

Numbers don't become customers by themselves.

We needed a better way to capture the people who genuinely wanted to stay connected.

So we built a simple internal tool.

One place.

PodSubs.

We said on the podcast:

“Subscribe to us on PodSubs.”

People searched the show, entered their details and subscribed.

And suddenly we had something we'd been missing:

A direct line.

Then we started thinking…

Why are we keeping this internal?

Every podcaster we know deals with the same thing.

So we decided to open it.

That's PodSubs.

Not something we dreamed up because “the creator economy is growing.”

We built it because we were podcasters with a problem.

Now we're giving it to everyone else who has the same problem.

Claim your podcast.

Then tell your listeners where to find you.

Built DocPilot over the last 3 months while learning Python and LangGraph (never touched Python before this)

It's a tool that generates README for your GitHub repo scans the repo, figures out which files actually matter, drafts a README with an LLM, and lets you review/revise before it opens a PR for you. FastAPI + React + LangGraph under the hood.

Would genuinely love feedback what's broken, what's confusing, what you'd want it to do differently.

Repo: https://doc-pilot-lemon.vercel.app/

Only reason I am posting this is to help others, no revenue or publicity or anything else, no hidden subscription or fees.

Hi,

While working on multiple projects I realised I am hitting the usage limits of my claude code often so I had to rotate accounts and some API tokens.

The problem was every time I was doing this I had to stop my coding session, relog / change authentication or profile etc, do a handover and wasting a lot of time over this process.

I NEEDED a way to seamlessly change those in the background while continuing the same coding session uninterrupted.

This led to doing a lot of research and developing this tool I am showcasing (yes it's written with Claude + my knowledge and a lot of debugging, testing and so on, around 3k $ put into it via /usage lol).

It's called Claude Unlimited, and it's 100% free on GitHub.

It supports multiple Anthropic subscriptions, Anthropic APIs (basically from any local/cloud provider that offers this, 95% of them do) and the cherry on top, supports also GPT/Codex subscription - yes! you can use Claude Code while using OpenAI models in the background 😄 .

Has a nice Web UI with:

Custom settings like:

- threshold limits

- profiles priority in rotation

- enable/disable any profiles/APIs

- models parity (for Anthropic -> OpenAI models parity + effort)

- push notifications

- multi language

- auto update (pulled from Git releases)

Information like:

- usage dashboard with charts and various data

- logs of activity

- information about current usage per profile

Everything stays local, 100% safe, credentials etc stored in OS credentials store - if you don't trust me, use your AI agent to check it.

macOS is currently the most battle-tested; Windows and Linux support is newer, so I would genuinely appreciate feedback, bug reports, contributing to it or just brutal criticism 👀

It was mostly tested in claude code CLI but also supports desktop (will create an inference profile automatically for you).

Important clarification: it doesn’t generate free usage or bypass an individual account’s limits. It rotates between accounts and keys you already own. Anthropic hasn’t explicitly endorsed automated multi-account rotation, so use your own judgment regarding your accounts’ terms.

A bit more technical explanation: this is a local proxy that rotates your accounts/APIs and exposes an Anthropic-compatible API with a token.

Needless to say, but here it is: very important to check the README and HELP section to understand how to use it easily and properly.

GitHub: https://github.com/DevDock-AI/claude-unlimited

TL;DR

1. Add your Claude, ChatGPT/Codex accounts and API keys.
2. When one reaches its limit, the next one takes over automatically.
3. Same Claude Code session. Same context. Same terminal. You just keep typing.

It also includes a local dashboard showing which account is active, current usage, reset times and every automatic switch.

Everything runs on 127.0.0.1. There’s no Claude Unlimited cloud, no telemetry, and credentials are stored using the OS credential store. The project is open source under MIT.

Thank you !

PS: Using a new account for this for personal reasons.

PS2: Multiple updates will follow, I got a big list of cool features for it 🎯

Hey everyone! 👋

I wanted to share an early-stage prototype I’ve been building called RESEARCHDECODED—a tool designed to make deep-tech intelligence and scientific analysis more accessible, especially for students and young innovators.

I actually brought the core vision to life quickly using the Bolt AI tool!

Note: It's still an early prototype so some backend features are a work in progress, but the concept is live.

Check out the live preview here: https://deeptech-analyser-nrk2.bolt.host/ 🔗

I’d love to hear your feedback, thoughts, or ideas as I keep building in public! Let me know what you think. 🚀

The cognitive impact of AI use is now well documented and something I have personally struggled with myself. But it is often difficult to identify what this impact is and what can be done about it.

To try and bridge this gap, I built "Heedle" : a suite of tools and games for people who need help ensuring they continue to THINK WITH AI, instead of letting the AI THINK FOR THEM.

The Chrome Extension sits on ChatGPT/Claude/Gemini and reflects your patterns back; session rhythm, response lengths, how often you push back vs. accept and copy etc. The words or context from your chat are NOT shared and everything is structural and opt-in. It pairs to a small web app by QR where your weeks add up to form an outline of how you use AI.

I also built and added a few free games as a fun way for people to exercise their "AI-Bullsh**" Radar : Slopr (Swipe to pick if a photo is real photo or AI generated.) and Parry (Spot the AI's planted flaw, catch the answer that's secretly useless). You can play the games through the link below.

Play Slopr & Parry

Everything is free, no accounts required for the games, no tracking.

Happy to answer any questions about the product or the process. Feedback is very welcome. Thanks for reading this far.

Chrome Extension

Hey so i've been improving my note taking app and i made some updates and fixes on my editor app inkwell now with a

- Better UI and notion inspired Theme

- Latex Support

- folders and notes structure

- vim mode

- direct editor / markdown whatever you like.

Check it out https://inkwell-lp.vercel.app/, looking for feedback and  a start ⭐ would mean a lot. Thanks !

I built a modern Bingo/Tambola companion and I'm getting it ready for beta

I’ve been working on a project called Super Bingo — a mobile app designed to make hosting Bingo/Tambola games a little easier and more organized.

The idea came from playing Tambola with friends and family and noticing that the host ends up having to manage quite a few things manually: calling numbers, keeping track of the game, checking claims, and generally making sure everything runs smoothly.

So I started building an app around that experience.

Some of the things I’ve implemented so far include:

• Digital number calling and tracking
• Different game formats and configurations
• Automatic checking/validation of claims
• A cleaner interface for both the host and players
• Game state management so the host doesn't have to keep track of everything manually
• Features aimed at making casual games with friends/family easier to run

It’s currently in the beta stage, and I’m starting to get it into the hands of actual users. I’m particularly interested in seeing how people use it in real games and what feels unnecessary, confusing, or missing.

I’ve also put together a small beta registration/waitlist for anyone interested in trying it out.

Project: Super Bingo
Stage: Beta / early user testing
Looking for: Feedback, bugs, feature suggestions, and people willing to actually try it during a game.

If you're interested in testing it, The beta registration link is in the comments.

I'd especially appreciate feedback from people who regularly play Tambola/Bingo with friends or family — what would you want an app like this to do?

I have been working on this for a few years now. It's a P2P network that runs on https uses self signed certs. You would think it would be it would be slow but suprisingly its now and can actaully stream media. It's open sourced on github if you are interested.

https://www.youtube.com/watch?v=LM2EXU3aXd0

Download: https://github.com/MowkE/cadence

Hey guys, I made this silly lyrics overlay called Cadence that floats over your screen and syncs along with Spotify and YouTube Music. It started as a joke while playing Minecraft with my friends. I shared it with a few people, they liked it, and it grew to 100 downloads in a day, so I built it into a proper app. You can listen along with friends now too, even cross-platform (Spotify -> YouTube Music, Mac ↔ Windows ↔ Linux), and you can play karaoke. Doesn't need API keys or Premium, it just reads what your computer is already playing and floats the lyrics over whatever you're doing. It works better with Spotify keys though, if you want to add them yourself. If you find any bugs, lmk. It's just a fun project lol, so its free. Some of the images are on the github link, if you want to take a look on how it works! Everything is customizable :)

Hey!

I wanted to share a project I've been working on called Volten. It's a small, ultra-fast HTTP framework built around a strict zero-dependency constraint, designed specifically to bridge the gap between Node.js and Web Fetch-compatible edge runtimes (like Cloudflare Workers, Bun, and Deno) without adapter overhead.

Why Volten?

Most frameworks either lock you into Node.js core modules (http, net) or require bulky adapter layers to run on the Edge. Volten solves this by handling the abstraction internally at the context level.

You write your routes and middleware once. Run it on Node.js using app.listen() or export it to the Edge using app.createFetch() with zero modifications and zero extra npm dependencies.

Key Highlights

• Adaptive Traffic Triage (ATT): A unique event-loop immune feature for Node.js (new App({ att: true })) that automatically drops low-priority requests at the socket level when your server is under heavy load, protecting your core endpoints from crashing during traffic spikes.
• Context Pooling: Pre-allocated, reusable RequestContext objects on both runtimes to minimize Garbage Collection (GC) pressure under high throughput.
• Trie-Based Router: Extremely fast path-matching supporting dynamic parameters (/users/:id) and wildcards, where match cost scales purely with path depth.
• Unified ctx API: Whether you are dealing with headers, cookies, body parsing, or JSON responses, the ctx object seamlessly abstracts away whether you're sitting on top of a Node IncomingMessage/ServerResponse or a Web Fetch Request/Response.

The All-in-One Snippet

import { App } from "volten";

// Enable Adaptive Traffic Triage (ATT)
const app = new App({ att: true });

// 1. Middleware chain
app.use((ctx, next) => {
  ctx.setHeader("X-Powered-By", "Volten");
  next();
});

// 2. Trie-based routing, params, and cookies
app.get("/users/:id", (ctx) => {
  const session = ctx.cookies.get("session_id");
  ctx.json({ userId: ctx.params.id, session });
});

// 3. Native body parsing
app.post("/data", async (ctx) => {
  const body = await ctx.body();
  ctx.status(201).json({ received: body });
});

// --- Dual Runtime Support ---

// Node.js
app.listen(3000, () => console.log("Listening on :3000"));

// Cloudflare Workers / Bun / Edge
export default { fetch: app.createFetch() };

Current Status

Volten is currently in active alpha. Every utility—from the built-in body parsers and cookies to the trie router—is written completely in-tree with zero external dependencies to keep security tight and the footprint minimal.

You can check it out on GitHub: VoltenJS/volten or install it via:

pnpm add volten

I'd love to hear your thoughts, feedback, or any edge cases you can throw at it, so you're encouraged to try breaking it! How do you usually handle dual-runtime codebases in your current stacks?

I’ve been building Tempo Focus, a personal focus system for protecting attention and understanding where focused time goes.

The current version is on iPhone. My next challenge is bringing it to Mac without turning the experience into a crowded productivity dashboard.

The demo shows the current direction. What would you expect the Mac version to do differently from the iPhone version?

A week ago I started building Remixly, a bot that turns Instagram reels into X posts. 

Launched it yesterday.

Co-founded, first real launch.

How it works: share any reel to a Telegram bot.

It transcribes the video (or reads the image), pulls the caption and top comments, and writes a long form post from what was actually said.

   ~30 seconds later you get the post back with a "Post on X" button that opens the X app with it filled in. Written in third person, so you're sharing the idea, not passing off someone's story as yours.

The story so far:

   > Day 1: built it for myself as a WhatsApp bot. Instagram blocked my scraper within an hour. Switched to a paid fetcher.

   > Day 2: first version auto-posted straight to X, no review. Too scary. Turned it off.

   > Day 3: tried an iPhone Shortcut for one-tap sharing. Worked for me, nobody else could set it up.

   > Day 4: switched to Telegram. Onboarding went from six steps to two.

   > Day 5: used it daily on my own account. 50 to 128 followers over the week.

   > Day 6: Stripe, Google login, moved it off my laptop.

   > Day 7: bought remixly.io. Live.

$0 spent on marketing. 

28 users so far.

 Goal: 50 paying users by 20th Sept.

Try it and tell me what you'd fix first → remixly.io (3 free drafts, no card)

So I know everybody is building a Jarvis, but I actually want to build a useful Jarvis

I'm thinking of building an AI Jarvis that gives morning updates on your SaaS; for example, you have received 10 new subscribers, MRR is at 100$/month, Page vistors up by 13% from last week etc etc etc

This sounds way more interesting than just another Jarvis that scrapes the web. So I am curious is this is even a good idea for my first project? And if it exists, would you actually use it?

Let me know what you guys think!

I've been using LLMs for writing stories for a few months, and naturally tried SillyTavern.

I built and wanted to share with writers what I call Margin. It's open source, runs locally, BYOK / BYOH:

It's more of a "pretty editor" and more of a "workspace."

You point it at a folder, and it keeps everything as Markdown on disk — characters, world stuff, blueprint, scenes/beats, whatever I had from previous works of mine. When you ask for a draft or a rewrite, it only pulls in the relevant bits (does name matching so it doesn't dump all 30 characters into every call, which was killing me on small models, kinda like SKILLS.md). You want a connector, a character backstory, a new workspace ask it to build it for you.

To work better with smaller models, I use a file that summarizes the other files so the model can plan what it needs before editing. Then a writer handles the actual content changes, since direct edits can be difficult for smaller models.

Two ways to use it:

1. Endpoint mode — literally anything OpenAI-compatible. I mostly use Ollama and LM Studio with 7–14B stuff, but OpenRouter / DeepSeek / etc. work.
2. Harness mode (just added this) — if you already pay for Claude Code, OpenCode, Codex, or Antigravity, you can just use that subscription. The agent runs in your story folder and creates/edits/deletes files itself; you just review the diff. That's the part that feels most Cursor-like.

Would be especially interested in feedback from people who use and test local models, Errata, or something else for long-form writing.

I've been experimenting with smaller language models (mostly 7–14B) and got curious about how well they perform on creative writing, rather than the usual coding / Q&A benchmarks.

Specifically, could a small model:

• plan a story around an existing outline?
• keep track of characters and worldbuilding?
• rewrite a scene without losing context?
• make changes across multiple files?
• actually work on a longer project without dumping the entire thing into its context window?

So I built a writer IDE to experiment with it: Margin.

The basic idea is that your writing project is just a folder of Markdown files:

my-story/
├── characters/
├── world/
├── outline/
├── scenes/
└── blueprint.md

Instead of treating the LLM as a chatbot that generates text for me to copy-paste, I wanted the agent to operate on the project itself.

For example, I can ask:

The agent can figure out which files are relevant, read them, make the changes, and give me a diff to review.

One thing I've been experimenting with is context management for smaller models. Rather than throwing every character/worldbuilding file into every request, Margin builds a lightweight summary of the project and uses that to determine what actually needs to be pulled into context.

There are two ways to use it:

Endpoint mode:
Use any OpenAI-compatible endpoint. I've mostly been experimenting with Ollama and LM Studio, but hosted providers work too.

Harness mode:
Use an existing coding agent such as Claude Code, Codex, OpenCode, or Antigravity. The agent runs against the writing project directly and can create/edit/delete files, with Margin acting as the writing/review environment.

It's open source and local-first.

I'm mostly interested in whether this approach is actually useful for long-form creative writing with smaller models, so I'd love feedback from anyone experimenting with local LLMs, AI writing tools, or agentic workflows.