Show HN for October 8, 2025

Hi HN,

As a weekend project, I hacked together a physical phone, a Raspberry Pi running Asterisk and Twilio, to let toddlers safely make international calls.

I’ve documented the setup in this write-up and published the code + Ansible playbooks on GitHub so others can replicate it.

I built this so kids of expats can easily stay in touch with family on other continents.

Would love feedback from anyone who’s worked on something similar or tries building this themselves!

writeup: https://wip.tf/posts/telefonefix-building-babys-first-intern... github repos: - https://github.com/nbr23/ansible-role-telefonefix - https://github.com/nbr23/allo-wed

Hey HN! I'm José, and I built Recall to solve a problem that was driving me crazy.

The Problem: I use Claude for coding daily, but every conversation starts from scratch. I'd explain my architecture, coding standards, past decisions... then hit the context limit and lose everything. Next session? Start over.

The Solution: Recall is an MCP (Model Context Protocol) server that gives Claude persistent memory using Redis + semantic search. Think of it as long-term memory that survives context limits and session restarts.

How it works: - Claude stores important context as "memories" during conversations - Memories are embedded (OpenAI) and stored in Redis with metadata - Semantic search retrieves relevant memories automatically - Works across sessions, projects, even machines (if you use cloud Redis)

Key Features: - Global memories: Share context across all projects - Relationships: Link related memories into knowledge graphs - Versioning: Track how memories evolve over time - Templates: Reusable patterns for common workflows - Workspace isolation: Project A memories don't pollute Project B

Tech Stack: - TypeScript + MCP SDK - Redis for storage - OpenAI embeddings (text-embedding-3-small) - ~189KB bundle, runs locally

Current Stats: - 27 tools exposed to Claude - 10 context types (directives, decisions, patterns, etc.) - Sub-second semantic search on 10k+ memories - Works with Claude Desktop, Claude Code, any MCP client

Example Use Case: I'm building an e-commerce platform. I told Claude once: "We use Tailwind, prefer composition API, API rate limit is 1000/min." Now every conversation, Claude remembers and applies these preferences automatically.

What's Next (v1.6.0 in progress): - CI/CD pipeline with GitHub Actions - Docker support for easy deployment - Proper test suite with Vitest - Better error messages and logging

Try it:

npm install -g @joseairosa/recall # Add to claude_desktop_config.json # Start using persistent memory

Redstart is a lightweight Lisp interpreter written in C++ with a focus on shell scripting. It lets you combine the expressive power of Lisp with the practicality of the Unix shell: you can run commands, capture output, pipe between processes, and still use Lisp syntax for logic and structure. Think of it as writing your shell scripts in Lisp instead of Bash.

Hi HN!

I've recently been finding productivity in running parallel CLI coding agents(after not believing in them initially).

After having to do a ton of git stashing and branch fumbling, I decided I needed to something to more ergonomically run these agents in their own dedicated spaces.

I tried a lot of the existing products but they either were too convoluted or flat out didn't work. Some of them also seem to roll their own chat UI which I don't think is the right approach, I wanted to something to lightly wrap my terminal sessions.

So I built FleetCode! It uses git worktrees and let's you run multiple agents at once. It's made my multi agent coding workflow much easier.

It's free and open source, would love some feedback!

Hi HN! I built Oh Yah! to help my sons (age 7 and 10) stick to daily routines without constant reminders. The core idea: minimal distractions during tasks by locking navigation when a timer is running, plus optional photo-based task completion for accountability

Built with React Native/Expo and Firebase. The trickiest part was designing the UX to be simple enough for kids with minimal distractions while giving parents enough control – ended up with a task-definition system that lets parents create weekly schedules with daily toggles instead of duplicating tasks across days

It's on the App Store now after a few months of dogfooding with my family. There's a 1-month free trial, then it's subscription-based. Would love feedback from other parents dealing with similar challenges

I worked on early podcast software in 2004 (iPodder/Juice) and have been a heavy podcast consumer ever since. I wanted a podcast app that respects your privacy and embraces the open web—and to explore what's possible in the browser.

The result is wherever.audio, which you can try right now at the link above.

How it works: It's a progressive web app that stores all your subscriptions and data locally in your browser using IndexedDB. Add it to your home screen and it feels native. Works offline with downloaded episodes. No central server storing your data—just some Cloudflare/AWS helpers to smooth out browser limitations.

What makes it different:

- True local-first: Your data stays on your device

- Custom feeds: Add any RSS feed, not just what's in a directory

- On-device search: Search across all feeds and episodes, including your custom ones

- Podcasting 2.0 support: Chapters, transcripts, funding tags, and others

- Auto-generated chapters: For popular shows that don't have them

- AI-powered discovery: Ask questions to find shows and episodes (this feature does use anonymized analytics while we work out the prompts)

- Audio-guided tutorials: Interactive walkthroughs with voice guidance and visual cues

The basics work well too: Standard playback features, queue management, speed controls, etc.

I'm really interested in feedback—this is more passion project than business right now. I've been dogfooding it as my daily podcast app for over a year, and I'm open to exploring making it a business if people find it valuable. Curious if there are unmet needs that a privacy-focused, open web approach could address.

Hi HN, my name is Philip, I’m the co-founder of Glasskube and one of the creators of HyprMCP.

Everything started when we did what everyone was doing at the time — building a remote MCP server and launching it for marketing purposes. Building the first local MCP server for testing was quite simple, and we had our first tools ready within a day. The next step was turning that into a production-ready remote MCP server.

As we exposed the MCP server to our users, we wanted to authenticate them with our existing authentication methods. We dove deep into authentication. Our approach was to build an auth proxy and plug it in front of our MCP. It took a while to figure out Dynamic Client Registration (DCR) and the OAuth spec, and especially the gaps between existing OIDC IDPs and what LLM clients needed.

We thought authentication would be the hard part — but it wasn’t. When we shared the MCP server with a few friendly startups, we realized that different MCP clients behave differently. Especially if something didn't work, it was hard to figure out the root cause. We ended up storing all the raw gRPC method calls to see if the initialization and subsequent requests worked. This is especially useful if you are on a serverless environment with limited debugging functionality, like Cloudflare Workers.

Once we solved auth and compatibility, we launched to a small customer base — done, right? Unfortunately, not quite. Technically everything was working, but when we started talking to users, they told us the MCP server didn’t always respond with the right tools for their prompts. We had a working enterprise-grade MCP server — but it wasn’t very smart. After talking to some startup friends, we realized we needed an evaluation layer. That’s when we added prompt analytics — letting us see which prompts triggered which tools and how well they performed. That alone dramatically improved our MCP’s behavior and overall user experience.

After building all of this into our proxy, we realized that everyone building a remote MCP was facing the same challenges. So we decided to package it all up and release it to the community.

We’re thrilled to launch and open-source HyprMCP. It acts as a proxy that you can plug in front of your MCP server(s) with zero code changes. You get authentication, logging and debugging, prompt analytics, and an MCP connection instructions generator.

Under the hood, HyprMCP leverages dynamic Kubernetes Operators (Metacontroller) to automate infrastructure provisioning.

On the roadmap: MCP aggregation — combining multiple MCP servers under one single remote URL for large organizations running servers with different lifecycles. All of it without storing end user credentials on the server and connecting the MCP to the organizations existing authentication methods.

You can check the project out on GitHub: https://github.com/hyprmcp/jetski

For testing, we also have a hosted version here: https://app.hyprmcp.com

We even created a demo video on YouTube: https://www.youtube.com/watch?v=m2-YyfjXap4

We’d love to get your feedback, hear what features are missing, and learn how you’re building and running your own MCP servers.

vcluster is an open source tool for Kubernetes multi tenancy and over the years it has matured to have hosted controlplane virtual cluster, shared virtual clusters but the host cluster problem was always there. With vcluster standalone, you can now create the first cluster also with the same developer experience and consolidate the multiple vendor problem. With this, you can now use vcluster for entire multi tenancy spectrum. Feel free to discuss, happy to answer any questuons.

TLDR Type one sentence describing the business you want to start. FounderBox returns a full “business kit”: your company name, incorporation guidance, website, Stripe checkout, supplier matches, ads, and a basic SOP to operate.

Why we built this

We all know this pain: Starting a small business today means gluing together five consultants, seven subscriptions, and hundreds of small tasks, even though 90% of it has already been automated by AI.

You have lawyers charging $1,200 to file basic paperwork, marketing consultants writing the same “About Us” copy with ChatGPT, and agencies billing $3K to embed a Stripe button. The process feels broken optimized in parts, but still fragmented and overpriced.

We wanted to fix that. We built FounderBox.dev to collapse the entire “consulting chain” into one seamless prompt → company pipeline. Instead of paying for each disconnected step, you get an orchestrated system that does the whole job, end-to-end.

We believe the consulting and services industry law firms, marketing agencies, operations consultants is about to go through its “Napster moment.” AI has automated the heavy lifting, but the industry still charges human-era prices. FounderBox is our attempt to *democratize entrepreneurship* giving anyone, anywhere, the ability to start a business without gatekeepers, invoices, or endless glue work.

Our goal isn’t to replace humans; it’s to *free humans from the admin* and let them build the part that matters the vision.

Early access

We’re currently accepting our *first 500 founders* to test the closed beta. You’ll get full access to the “one-prompt business builder,” early feedback calls, and lifetime founder pricing when we launch publicly.

Join the waitlist: https://founderbox.dev/ We’d love your feedback especially from folks who’ve built legaltech, no-code, or supplier-API products. Are we overshooting or undershooting what “one-prompt company formation” should mean?

Vincent lets users safely grant apps/agents limited, revocable permission to use their wallets. Think “OAuth for crypto actions”: you define scopes (e.g., “rebalance stables on Aave up to $1k/day”), users approve, and your app runs within on-chain guardrails. Non-custodial. Built with Lit Protocol's decentralized programmable signing.

Hey everyone

I wanted to share something I made: vcdir.com - a global, 100% free directory of 1300+ venture capital firms.

Most VC databases I found were either outdated, overly complex, or hidden behind a paywall.

So I decided to make one that’s:

It’s 100% free to browse, no signup or paywall required.

It lists 1,300+ VC firms from around the world (and the number keeps growing).

Lets you filter by country, continent, investment phase, and market focus

Each firm’s page includes basic informations like short description portfolio links, website, contact info, investment focus.

Includes categories, breadcrumbs, and a bookmarks for easy navigation and browsing

I wanted a better domain, but everything decent was taken or insanely priced :(

If you ever find yourself fundraising, or just wonder who’s really out there backing startups feel free to check it out :)

Hey HN,

I'm Willem from Confident Security, we've built CONFSEC, a provably private AI inference engine. Today, we're excited to open-source twoway: https://github.com/confidentsecurity/twoway

twoway is a Go package that makes it easy to implement secure, encrypted request-response flows. It powers CONFSEC's blind prompt handling, ensuring no one, not even us, can see client requests.

We built twoway on Cloudflare's circl/hpke, it uses Hybrid Public key Encryption to implement two flows: - A one-to-one flow where a sender communicates with a single receiver. This flow is fully compatible with RFC 9458 Oblivious HTTP (OHTTP), and the chunked OHTTP draft RFC. - A one-to-many flow where a sender communicates with one or more receivers. Similar to the Apple's PCC's request flow.

Other features include: - Compatibility with any transport, twoway deals with just the messages. - Chunked messages. - Allows for custom HPKE implementations for specialized needs like cryptographic hardware modules.

Our README has clear examples to get you started, all you need to do is go get and try an encrypted "Hello world" exchange.

Our team will be popping in to answer questions, we'd love to hear your feedback.

Cheers! Willem

Hi! I built SEE (Semantic Entropy Encoding) because the “data tax” (storage/egress) and the “CPU tax” (decompress/parse) keep rising together.

Tradeoff: it’s not always smaller than Zstd, but it stays searchable while compressed and minimizes I/O. Key numbers (demo): combined≈19.5% of raw, skip≈99%, lookup p50≈0.18 ms (bloom≈0.30).

10-min reproduction (no marketing): 1) Download the Demo ZIP (Release). 2) Follow README_FIRST.md. 3) Run `python samples/quick_demo.py` → prints ratio/skip/bloom + p50/p95/p99.

ROI quick math: Savings/TB ≈ (1 − 0.195) × Price_per_GB × 1000 (e.g., $0.05/GB → ~$40/TB). NDA/VDR (private, no confidential info in public): [https://docs.google.com/forms/d/e/1FAIpQLScV2Ti592K3Za2r_WLU...]

Happy to answer technical questions (schema-aware layout, delta strategy, bloom density, skip heuristics, failure modes).

Mirrow is a TypeScript DSL that compiles to SVG with compile-time syntax checking and type safety. It reduces boilerplate while catching SVG errors before runtime. Key features:

Attribute validation at compile time Inline events (on:click, @hover) Zero-config CLI: npx mirrow -i input.mirror -o output.svg Works as static SVGs or components

Playground: https://mirrow.app/playground GitHub: https://github.com/MirrowApp/mirrow Built this because hand-writing SVG is error-prone and existing tools don't catch mistakes until runtime. Would love feedback on DX and docs!

This is an experiment i did in the past 3 weeks where i used AI (GPT 4.1 and Claude 4) to recreate my Declarative framework in c# which uses Html + Json in 6 languages.

I was suprised that AI can not only implement the logic in multiple languages, it can go from static typeed languages like c#, rust and go to dynamic languages like php and javascript in node.js to javascript at the client.

Another think i was suprised is that AI can even create the Index page by itself using the 4 declarative rules for which AI implemented the logic.

Even though it is not vibe code, since i controlled the structure of the implementation and asked ai to implemented extensive features like testing, structure dumps to validate the implementation, i have not reviewed the implementation and only in c# which i am familiar with i have briefly reviewed and i can see it is not optimal for implementating future declarative abstractions, but it works.

The implementation is complete to build static web apps using any client side framework

My takeaway using AI is implementing interative loops where you ask something, but also show how the AI can verify whether it has satisfied your requirement was the trick which helped it to complete the implementation in c# and using C# as the prompt helped AI to complete the other langs iteratively.

The output is published in smallest machine in fly under 6 different apps, namely https://csharpassembler.fly.dev/, https://rustassembler.fly.dev/, https://goassembler.fly.dev/, https://nodeassembler.fly.dev/, https://jsassembler.fly.dev/

I couldn’t find a privacy-friendly and reliable voice typing app for my daily Linux use, so I built one.

This project uses Whisper.cpp for offline speech recognition and is written in Go. It works both on X11 and Wayland and aims to be a drop-in solution for dictation and voice commands on Linux desktops.

The goal is to provide a fast, local, and privacy-respecting alternative to Dragon or cloud-based STT tools.

Repo: https://github.com/AshBuk/speak-to-ai Issues: https://github.com/AshBuk/speak-to-ai/issues

I’d appreciate feedback, testing on different distros/desktops, and any contributions or ideas for improvement.

An LLM assistant runs entirely in your browser, all web-based.

Kostenloser KI-Musikgenerator für deutsche Songs. Text rein → professioneller Song in wenigen Minuten.

Gebaut für Content Creator, die Copyright-freie Musik brauchen.

https://kisongerstellen.com/ GitHub: https://github.com/kisongerstellen

Probiert es aus!

This is a tool that I have long wished somebody else would make. I'm struggling to produce a good one-line or even one-paragraph description of what exactly it does, but a good analogy is the Linux kernel's `menuconfig` or CMake's curses-based `ccmake` configuration editor, except that rather than operating on a highly constrained config file format, it can edit basically any textual format in place, as long as that format has some notion of comments. The comments then can be made to hide "meta-instructions" that confy understands: define a number of typed parameters, perform some simple computations on them, and either inactivate or activate (by (un)commenting) designated blocks of the "object-level" file, or outright regenerate them from a template. As a basic example, you could write

//! bool $flag = true;

//! if($flag) {

printf("The flag is true!");

//! } else {

//-printf("The flag is false!");

//! }

and confy would expose a graphical interface to toggle "$flag" on or off, and comment/uncomment the appropriate line of text in the file, while also saving the updated initial value in the first line that defines $flag in the file.

Interaction is possible both via a curses-style terminal interface, and by scriptable getters/setters (like `confy filename.txt set variableName true` or `confy filename.txt get variableName`).

github repo: https://github.com/zhangchenchen/tier_list_maker

I create this tool using next js + shadcn + tailwind. I know it is simple, still learn a lot during vibe coding.

Hey HN! I'm Jet, building LlamaPReview.

Most AI code reviewers only see the diff. They miss the real risks: a function rename that breaks 5 other files, a dependency change that shifts your architecture, a "small" PR that actually rewrites your auth logic.

We built a context retrieval engine that pulls in related code from across the repo before analysis. On complex PRs, it auto-generates Mermaid diagrams showing cross-file impacts.

Technical challenges: 1. Deciding which files are "related" without analyzing the entire repo every time (we use code graphs + call chains + git history) 2. Fitting it into LLM context limits (we rank by relevance and truncate aggressively) 3. Auto-detecting when to trigger deep analysis vs fast review (~35% of PRs end up needing it)

It's live now, free for all public repos. For private repos, we're trying to figure out a sustainable model: first 3 PRs get deep analysis free, then you choose between our always-free basic tier or a paid tier with persistent code knowledge graphs.

The controversial part: to do deep analysis well, we need to build a knowledge graph of your codebase (classes, methods, call chains). For private repos, this means storing structural metadata. Some teams are fine with this. Others want zero-knowledge architecture where even metadata is encrypted client-side.

Questions for HN: 1. What signals would YOU use to detect "this PR is complex enough to need deep analysis"? 2. Would you pay for code review tooling, and if so, what's your threshold? 3. Is storing structural metadata (no code content) acceptable, or is Zero-knowledge Storage the only way?

Site: https://jetxu-llm.github.io/LlamaPReview-site/

I'm here for the next few hours to answer technical questions or get roasted for my monetization strategy.