value: raullen

value:
Hey HN, I built triplecheck because I wanted deep AI code review without paying $24/mo per seat.
The idea: instead of one LLM pass that drops comments (like CodeRabbit/Sourcery), triplecheck runs a full loop:
1. Reviewer finds bugs → structured findings with file, line, severity
2. Coder writes actual patches (search/replace diffs, not suggestions)
3. Tests run automatically to catch regressions
4. Loop until no new findings or max rounds
5. Judge scores the final result 0–10
The key insight: with local LLMs, compute is free, so you can afford to be thorough. Run 5 review passes from different angles, vote to filter noise, let the coder fix everything, and re-review until clean. Try doing that with a $0.03/1K token API.
What works well:
- Qwen3-Coder on vLLM/Ollama handles reviewer + coder surprisingly well
- Multi-pass voting genuinely reduces false positives — 3 passes agreeing > 1 pass guessing
- Tree-sitter dependency graph means the reviewer sees related files together, not random batches
- Scanned a 136K-line Go codebase (70 modules) — found real bugs, not just style nits
What's missing (honest):
- No GitHub PR integration yet (CLI only — you run it, read the report). This is the #1 gap vs CodeRabbit. It's on the roadmap.
- No incremental/diff-only review — it reviews whole files. Fine for local LLMs (free), wasteful for cloud APIs.
- Local LLMs still hallucinate fixes sometimes. The test gate catches most of it, but you should review the diff before merging.
Stack: Python, Click CLI, any OpenAI-compatible backend. Works with vLLM, Ollama, LM Studio, DeepSeek, OpenRouter, Claude CLI. Mix and match — e.g. local Qwen running on M3 Ultra for reviewer/coder + Claude for judge.
Would love feedback, especially from anyone running local models for dev tools. What review capabilities would make you actually use this in your workflow?

value: Show HN: Triplecheck – Review your code free with local LLMs

author: raullen


value: tweakyourpc

value: Built this after one too many production incidents caused by a renamed variable or missing key that CI never caught. EnvSentinel treats your .env as a versioned contract - you define the rules once in a JSON schema, then validate against it in CI, pre-commit, or locally. Also regenerates .env.example from the contract automatically so it never drifts. Pure Python stdlib, no external dependencies, 3.10+.

value: Show HN: EnvSentinel – contract-driven .env validation, zero dependencies

author: tweakyourpc


value: familytreeeasy

value:
I built this as a side project because I found existing family tree tools either too bloated or too manual—I spent more time dragging boxes and aligning lines than actually mapping my family history.
My goal was to make it instant: you just add the names, and the auto-layout engine handles the hierarchy and spacing automatically. It runs entirely in the browser and exports high-res PNG/JPGs.
Would love feedback on the layout logic (especially for complex families) and the overall UI flow. Happy to answer any questions!

value: Show HN: A simple, auto-layout family tree generator

author: familytreeeasy


value: bradkinnard

value:
I’ve been building ABES (Adaptive Belief Ecology System), a memory architecture for AI agents based on the idea that memory should manage belief state over time, not only retrieve prior text.
The system models memory as structured beliefs with explicit state, including confidence, salience, contradiction pressure, lifecycle status, memory tier, evidence balance, lineage, user and session scope, and decay behavior. Beliefs can be reinforced, weakened, contested, updated, mutated, or deprecated as new evidence arrives.
The goal is to support longer-running agents that need to deal with stale information, conflicting information, confidence change, and belief revision, rather than only recalling similar prior content.
Current implementation includes a structured belief model, reinforcement and decay mechanics, contradiction handling, tiered memory behavior, session isolation, API support, Docker support, and testing/evaluation infrastructure.
What has been verified so far in the project’s published tests and evals:
822 passing tests
a 1,000-prompt evaluation with an overall score of 825/1000 (82.5%)
reported category scores of 96.8% episodic memory, 94.4% working memory, and 92.8% semantic memory
a 15-block side-by-side evaluation against a raw Ollama baseline, where ABES passed 14/15 blocks and the baseline passed 6/15
a 200-prompt cognitive stress test reported as 3 consecutive runs at 200/200
Two easy verification points:
run PYTHONPATH=$PWD pytest tests/ -q from the repo root
inspect results/side_by_side_eval.json for the block-level comparison output
I do not consider internal tests and project-published evals to be sufficient external validation. The next stages are stronger benchmarking, improved contradiction handling and belief revision, stronger temporal and relational structure, longer-horizon testing, multi-agent shared memory work, and better observability of belief transitions.

value: Show HN: ABES – a memory architecture for belief revision in AI agents

author: bradkinnard


value: hyperstatic

value:
Hi HN,
I’m a programming beginner, and lately, I’ve been hopelessly addicted to a farming simulation on Roblox called Garden Horizons.
The core loop is simple: plant, grow, and harvest. However, the game uses a complex, non-linear economic system where crop value scales with the square of its weight.
Sell Price = Base Price × (Weight / Base Weight)² × Ripening × Color × Mutation × ...
Calculating the optimal time to harvest became a total ROI nightmare.
So, I built this tool to solve that: https://gardenhorizonscalculator.pro/
Data-Driven ROI: I collected raw data from the game and used Regression Fitting to verify the underlying math. The resulting model is highly consistent with in-game values.
Integrated Wiki: I aggregated scattered info from Discord and community forums into a structured, mobile-friendly guide for plants and mutations.
The Struggle: "Vibe Coding" and its Limits
I built this using Next.js through "Vibe Coding" (heavy AI assistance). While the AI was incredible for getting me from 0 to 1, I hit a massive wall during deployment.
I fell into "Deployment Hell"—failed over a dozen times. At one point, both the AI and I were just staring at the terminal, completely stuck. I realized then that while AI can write code, technical fundamentals are the ultimate safety net. It was only after diving into the documentation and developer forums that I understood the "why" behind the failure and finally got it live.
The Tool: It’s live, free, no sign-up required, and designed specifically for mobile-first use (since most players have it open on their phones while gaming).
I’d love to hear your feedback, especially from anyone interested in non-linear game economies or those who have thoughts on how a beginner can better navigate the "Vibe Coding" workflow.
URL: https://gardenhorizonscalculator.pro/

value: Show HN: Garden Horizons Calculator – Built by a Beginner via "Vibe Coding"

author: hyperstatic


value: BERTmackliin

value: Show HN: Anchor Engine – Deterministic Semantic Memory for LLMs local (<3GB RAM)

author: BERTmackliin


value: levmiseri

value:
This is a game I wish I had as a kid learning programming. The concept of it is fairly similar to other coding games like Screeps, but instead of a complex world with intricate mechanics, Yare is a lot more minimal and approachable with quick 1v1 <3 min matches.
It's purely a passion project with no monetization aspirations. And it's open source: https://github.com/riesvile/yare
The first version 'launched' several years ago and I got some good feedback here: https://news.ycombinator.com/item?id=27365961 that I iterated on.
The latest overhaul is a result of simplifying everything while still keeping the skill ceiling high. And at least the LLMs seem to struggle with this challenge for now (I run a small tournament between major models - results and details here: https://yare.io/ai-arena
I'd love to hear your thoughts

value: Show HN: 1v1 coding game that LLMs struggle with

author: levmiseri


value: YarkYao

value:
I built a personality test based on the five elements (Wood, Fire, Earth, Metal, Water) combined with yin-yang energy, giving 10 possible types.

  The test is free, 20 questions, takes about 3 minutes. No sign-up, no email gate.

  Tech stack: Next.js (App Router + React Server Components), Cloudflare Pages + Workers, Supabase for purchase records. Heavily optimized for Core Web Vitals — LCP under 1s, minimal JS on the server-rendered pages.

  A few decisions I made along the way:
  - SSR for all content pages (SEO), client components only where interaction is needed
  - Migrated from Vercel to Cloudflare for cost and edge performance
  - Local fonts instead of Google Fonts to cut render-blocking requests
  - Code-split below-fold components to reduce TBT

  The free result gives you your core type. There's an optional paid report ($7.99) for deeper insights — that's the only monetization. No ads, no data selling.

  Would appreciate any feedback on the experience or the tech choices.

  https://fiveelementstest.com

value: Show HN: A free personality test based on five elements

author: YarkYao


value: sthorat

value:
I built EV Mapping to answer the question EV owners actually ask: "Can I get there and back without charging?"
You pick your car, drop a start pin, set your current charge %, and hit Compute Reach. You get two circles — outer for one-way range, inner for round-trip — plus all charging stations within reach as pins. Click any pin to open navigation in Google Maps.
Stack: vanilla JS + Leaflet, no build step, hosted on Vercel. Charger data merges OpenChargeMap and OpenStreetMap Overpass with deduplication. 700+ EV presets across 20+ markets (US, EU, India, China, AU, etc.) synced every 12h via a Python pipeline on GitHub Actions.
The catalog pipeline ingests fueleconomy.gov, afdc.energy.gov, cardekho.com, and greenvehicleguide.gov.au, plus region-native seed files. It has anti-regression guardrails and a canary→stable promotion workflow so bad syncs don't silently ship.
https://ev-mapping.vercel.app
Source: https://github.com/novelmartis/ev-mapping
Feedback welcome — especially on range accuracy and charger pin coverage in non-US markets.

value: Show HN: EV range calculator – range circles and charger map (700 models)

author: sthorat


value: ardakaan

value:
We run an open startup and believe in sharing numbers publicly. But our setup was a mess: metrics lived in Stripe and PostHog, we'd pull them manually, paste into our CMS, and embed that on the site. Every update was a chore. Every number was stale.
Openboard connects directly to your data sources and generates a live public metrics page. No CMS middleman, no manual updates.
Currently supports Stripe (MRR, churn, active subscribers) and PostHog (visitors, signups, retention). Adding more integrations based on what people actually need.
The base version is free — sharing should be frictionless. Paid plans unlock more integrations and custom domains.
Would love feedback, especially from founders who already run an open page and know how annoying this problem is.
openboard.fyi

value: Show HN: Openboard – Live public metrics page for open startups

author: ardakaan


value: kinskrig

value:
Hey HN,
I want to introduce you to Cardrooms.app : a free, guest-friendly, competitive platform for shithead (with plans to expand into other card games).
I based the main game on shithead because it is the best game that combines strategy, memorization, luck, and complexity. If you're not familiar with the rules there is a play through tutorial as well as documentation on how to play on the app,
It's still a really new project (1.5 weeks old at the time of writing) so I suggest trying it out with friends as its really hard to get an open room. It's great to play with your card game buddies especially when you're separated by distance or have no physical cards on you.
If you decide to make an account, there is a robust ELO system to help you track your performance against other players, with a global ranking system and some ingame cosmetics to reflect your progress through the ranks.
Any feedback is much appreciated. I'd also love to hear any ideas you have for promoting it - Discord servers, Facebook groups etc. Not really sure where the big online communities hang out (apart from here).
If you enjoy it, tell your friends!

value: Show HN: CardRooms, a Competitive Cardgame Platform

author: kinskrig


value: Each day, a new unusual word with four possible meanings. Pick the right meaning to win. You have 3 tries per day.<p>A game I built to expand my own vocabulary, hopefully you find it fun too.

value: Show HN: VocabPop – Simple Word Game

title: Show HN: VocabPop – Simple Word Game


value: anwarfirst

value:
We just launched a free tier for Plexicus.
Previously, it was only available through paid plans, but many individual engineers and small teams wanted to try it without going through sales. So we decided to add a freemium option.
Would love to hear feedback from you guys

value: Show HN: Plexicus now has a free tier

author: anwarfirst

title: Show HN: Plexicus now has a free tier


value: Milkoo

value:
Show HN: Reelforge – AI tool for generating TikTok & Reels ad scripts
Text
I built a small AI tool that generates short-form ad scripts for TikTok, Instagram Reels, and YouTube Shorts.
You simply enter a product name, choose the platform, and select a tone.
The system generates a hook, main script, and call-to-action.
Demo
https://reelforge-ai1.vercel.app/
Built with Next.js and OpenAI.
Would love feedback from the community.

value: Show HN: Reelforge – AI tool for generating TikTok and Reels ad scripts

author: Milkoo


value: dafin

value:
Built this because I kept needing a quick sprite sheet tool while working on side projects and everything either required a download or had a paywall.
It runs fully in the browser, no upload to a server, no login. Supports:
- Packer mode: upload separate frame PNGs, reorder them, export as atlas + JSON
- Slicer mode: upload an existing sheet, define rows/columns, split into frames
- JSON metadata compatible with Phaser, custom WebGL renderers etc.
Works with Unity and Godot workflows too. Would love feedback on what's missing.

value: Show HN: Free in-browser sprite sheet packer and slicer with JSON export

author: dafin


value: overthinkerer

value: Show HN: Tailwatch – Hierarchical event monitor with push notifications

author: overthinkerer


value: SiteMgrAI

value: Show HN: PeakLevs – Track growth across 6 life domains

author: SiteMgrAI


value:
Hey HN, I built codebase-md because I was tired of manually writing and maintaining
context files for every AI coding tool.
The problem: Claude Code wants CLAUDE.md, Cursor wants .cursorrules, Codex wants codex.md,
Windsurf wants .windsurfrules — and each needs your project's architecture, conventions,
dependencies, and structure. Writing these by hand is tedious, and they go stale fast.
codebase-md scans your project once and generates all of them from one source of truth:

    pip install codebase-md
    cd your-project/
    codebase scan .
    codebase generate .

What it detects:
- Languages and frameworks (Python, JS/TS, Go, Rust — 50+ extensions)
- Architecture pattern (monolith, monorepo, microservice, library, CLI)
- Conventions (naming style, import patterns, design patterns) via tree-sitter AST
- Dependencies with health scoring (queries PyPI/npm registries)
- Git history, contributor analysis, file hotspots
It also has a smart context engine — you can query `codebase context "how does auth work"`
and it returns the most relevant project context using TF-IDF scoring.
Built with Python 3.11+, Pydantic v2, tree-sitter, and Typer. 354 tests, MIT licensed.
First release (0.1.0) just went up on PyPI. Looking for feedback and contributions —
especially around adding more language grammars (Go/Rust tree-sitter support) and
new output formats. Issues tagged "good first issue" on the repo.
Happy to answer any questions!

value: Show HN: Codebase-md – Creates Claude.md, .cursorrules, AGENTS.md from any repo


value: thomasBln

value:
Hi HN,
A small pipeline that scans external discussions (HN, news, X), clusters problem narratives, and tracks frequency shifts over time.
It produces a daily Telegram digest highlighting emerging signals.
Repo contains architecture and implementation details.

value: Show HN: Detecting problem–market drift with an OpenClaw agent

author: thomasBln


value:
Hi HN,
I’m building a voice-first AI language teacher in the browser using:
- Next.js
- Gemini Audio API for STT
- Gemini TTS
- Supabase
The product vision is a structured AI “language university” rather than a general chatbot.
Right now my biggest technical problem is:
How would you implement lightweight browser-native lip sync for a static avatar image while TTS audio is playing?
I’ve tried:
- Three.js + VRM (too heavy / unstable for this use case)
- simple canvas mouth animation
- CSS-only pulse effects
I want:
- something realistic enough to feel alive
- low dependency weight
- web-compatible
- stable on mobile
Secondary issues:
- MediaRecorder reliability on mobile Safari
- reducing transcript latency
- voice UX for guided teaching rather than free-form chat
Demo:
https://koshe-al.onrender.com
Repo:
https://github.com/Bugsbuny24/Koshe-Al-
Would love technical suggestions, architecture criticism, or examples of similar systems done well.

value: Show HN: Koshei AI – a voice-native AI language university (A1 to D2)


value:
Most MCP examples look clean when the client and server run on the same machine.
That breaks once the MCP server is remote. Tools that expect local files cannot access them, and tools that generate files leave those artifacts stranded on the server.
I built remote-mcp-adapter to bridge that gap. It stages client-side files for upstream tools, captures output artifacts, and keeps normal MCP traffic flowing through unchanged.
Repo: https://github.com/aakashh242/remote-mcp-adapter
Would love feedback from people building remote or centralized MCP setups.

value: Show HN: Making remote MCP servers handle local files and generated artifacts


value: nicbarth

value: Tried using doing some desktop automation by sending codex screenshots and stepping through generated instructions. It's rough, but it (mostly) works. In the screenshot it accidentally presses 71336 haha.

value: Show HN: Desktop Automation with Codex

author: nicbarth

title: Show HN: Desktop Automation with Codex


value: reviewpulse

value:
We built an agentic coding tool that runs on iPad. Claude reads your codebase, plans changes, edits files, and pushes to
GitHub — autonomously, in a loop. 7 integrated tools (Read, Write, Edit, Glob, Grep, Bash, Git), all executing locally on
the device.
The shell is a JS polyfill (~25 Unix commands with pipes, chaining, and redirection). Git uses isomorphic-git. API calls
stream token-by-token via SSE.
We used it to develop itself — dogfooding from day one.
We've hit iPad platform limits: no persistent background processes, no real shell for builds/tests, iOS purges IndexedDB
after 7 days. Looking for collaborators to solve the last-mile problem — especially anyone with experience in iOS hybrid
apps, WebContainers, or keeping background servers alive on iOS.
Repo: https://github.com/M8seven/claude-mobile
Detailed writeup: https://github.com/M8seven/claude-mobile/issues/1

value: Show HN: Claude Code for iPad – Agentic AI coding tool with file ops, Git, shell

author: reviewpulse


value: xdasf

value: Show HN: Introducing Kite AI Agent: Conversational Operations for Kubernetes

author: xdasf


value: muhammadbaibars

value: Show HN: I measured my context switching by scanning Git commits

author: muhammadbaibars


value: hubab

value:
I use dictation daily for writing and prompting agents. Existing dictation apps worked well for me, but recurring cost and unclear data handling pushed me to build my own: Utter
Core idea

  - Free with local models

  - Also free with BYOK

  - Sub-second transcription and post-processing

  - More than transcription: custom prompt-based post-processing

What it does

  - Dictation with customizable shortcuts, including toggle or hold-to-talk

  - Modes let you save different model + prompt setups for different workflows

  - Last-used mode remembered per app & per-mode shortcuts

  - Meeting recording with speaker-labeled transcripts, summaries, and action items

  - Audio/video file transcription, watched folders

  - Local audio/transcript retention & auto-export of transcripts

  - Context-aware post-processing, with visibility into exactly what context was used

  - Link summarization (Web, YouTube, PDF, DOCX, PPT) + follow-up AI chat

  - Markdown note editor

  - iPhone app with dictation keyboard

Privacy, custom post-processing, and frictionless phone-to-desktop capture were major motivators for me: I wanted to record ideas on walks, have longer recordings turned into clean Markdown notes, and avoid sending personal voice notes to the cloud. Utter requires no account or registration, syncs through iCloud, supports fully local workflows (for example, local transcription with Parakeet plus local post-processing with Ollama or LM Studio), and includes a built-in Markdown editor.
Curious to hear what dictation app users think, especially where this still falls short.

value: Show HN: Utter, a free local dictation and meeting notes app for Mac and iPhone

author: hubab


value: Show HN: Mt – Knowledge graph with spaced repetition


value: HPSimulator

value:
Hi HN,
I built Human Psychology Simulator to explore an idea: can we approximate how visitors psychologically experience a website before running real traffic?
Most founders rely on analytics, A/B testing, or heatmaps after users arrive. But I wanted to experiment with predicting behavioral friction earlier.
The tool runs a simulation and generates a report including:
• Trust score
• Conversion probability
• Hesitation zones
• Persuasion signals
• Priority fixes
To make it interesting, I also generated reports for ~100 well-known websites to create a public leaderboard.
Curious to hear feedback from the HN community:
Does the concept make sense?
What signals would you expect a system like this to evaluate?

value: Show HN: Tool that simulates how visitors psychologically experience websites

author: HPSimulator


value: bolitupac

value:
Hi HN,
I’ve been working on a small tool called PR AI to help review pull requests faster using AI-assisted context.
The idea is to load the PR diff and let the AI analyze it directly, so you can discuss the changes, risks, and possible improvements without switching between tools.
What it does so far:
Connects to GitHub and loads PR diff context
Import diffs from GitHub, file upload, or paste
Renders readable diffs inside the workspace
Chat with AI using the active PR context
Structured review output (summary, risks, recommendation)
Right now I’m focusing on:
Better traceability from AI comments to exact changed lines
Improving the signal-to-noise ratio in reviews
Keeping the interface lightweight while adding deeper audit signals
It’s still early but already able to load and analyze real PRs.
If you review pull requests often, I’d love to hear:
What would make an AI PR reviewer actually useful for you?
What kind of issues should it prioritize detecting?

value: Show HN: AI pull request reviewer that analyzes Git diffs

author: bolitupac


value: dbdoc

value: Show HN: Alt – No-code API load testing tool

author: dbdoc


value: theidioticdev

value: I made an OS sim in Python so linux newbies can learn how to navigate their system from terminal and break stuff without messing their system

value: Show HN: PenguWarpOS – OS SIM made in py for Linux newbies

author: theidioticdev


value:
I built ChaosRank after noticing that most chaos engineering teams pick
targets by gut feel or random selection. A payment service with 15
downstream dependents isn't the same risk as a logging sidecar, but
tools like LitmusChaos treat them identically.
ChaosRank takes your Jaeger trace export and incident history CSV and
produces a ranked list of services to target, with a suggested fault
type and confidence level for each.
The risk score combines two signals:
- Blast radius: blended PageRank + in-degree centrality on the
  dependency graph (captures both deep chains and shallow-wide hubs)
- Fragility: per-incident traffic-normalized severity with exponential
  decay (normalization order matters — post-hoc normalization produces
  ranking inversions at high traffic differentials)
Evaluated on the DeathStarBench social-network topology (31 services)
from the UIUC/FIRM dataset (OSDI 2020). Found seeded weaknesses in 1
experiment on average vs 9.8 for random selection across 20 trials.
Output formats: Rich terminal table, JSON, and LitmusChaos ChaosEngine
YAML (pipeable directly to kubectl apply).
To try it without your own traces — sample data is included:

  pip install chaosrank-cli
  git clone https://github.com/Medinz01/chaosrank
  cd chaosrank
  chaosrank rank \
    --traces benchmarks/real_traces/social_network.json \
    --incidents benchmarks/real_traces/social_network_incidents.csv

Known limitations: async dependencies (Kafka, SQS) don't appear in
trace spans so blast radius is underestimated for event-driven
architectures. Jaeger JSON only for now — OTel OTLP is next.
Happy to discuss the algorithm design, particularly the PageRank
direction choice and why per-incident normalization matters.

value: Show HN: ChaosRank – which microservice should you break next?


value:
Hey HN,
I kept running into the same problem on backend projects: emails arrive in all kinds of formats invoices, order confirmations, shipping notifications — and I'd write a regex parser that worked fine until the sender slightly changed their template. Then it'd silently break.
LLM-based extraction fixes the brittleness but you still have to wire up the prompts, handle schema validation, manage retries, and get it into your backend reliably. It's a surprisingly annoying amount of plumbing for something that should be solved infrastructure.
So I built ParseForce: you define a JSON schema, point a mailbox at your system, and parsed+validated JSON gets delivered to your webhook. There's a CLI for local dev (listen + replay), delivery observability in the dashboard, and idempotent webhook delivery with event replay for when things fail.
Free tier is 50 emails/month, no credit card. Would love feedback from anyone who's dealt with this problem — especially if you have a use case it doesn't handle well.
https://parseforce.io

value: Show HN: ParseForce – I got tired of brittle email parsers so I built this


value: Installing a new operating system turned out to be less about the OS and more about understanding the disk underneath it. While preparing my system for a Debian dual boot setup, I explored Linux disk partitions, cleaned caches and unused packages, and discovered that my system usage dropped from 80GB to just 47GB.

value: Show HN: What Installing a New OS Taught Me About Disk Partitions


value: karanzhacker

value:
Hey HN, I'm Karan.
As a frontend dev, I got tired of constantly rewriting animation boilerplate just to get the easing and interactions feeling right.
I built ogBlocks to scratch my own itch.
It’s a copy-paste library of interactive UI components.
I used Framer Motion for the complex stuff—focusing heavily on tweaking springs and inertia so the physics actually feel natural—and pure CSS for the lighter elements.
Would love your feedback on the code structure, performance, or any specific animations you think are missing from the ecosystem.
I know you'll love the library
Take a look and happy to answer any questions

value: Show HN: OgBlocks – A zero-install animated UI component library

author: karanzhacker


value:
As a side project for a hockey manager game, I created a small audio tracker, "HM Tracker," which was used to make the game's music.
It is a browser-based tracker-style music workstation. All sound is procedurally generated from oscillators - no samples, no plugins.
The UI lets you edit patterns on a step grid, pick instruments and chords, then export as a standalone JS music engine or WAV file. Built with vanilla JS and the Web Audio API (best experienced on a desktop browser).
Made in the '90s demoscene spirit (at least the looks, anyway).
Would love any feedback!

value: Show HN: Procedural Music Workstation in the Browser


value:
I'm a solo carpenter, and I got tired of paying $39–150/month for software built for 20-person operations.
So I built FieldFlow — invoicing, scheduling, and client management in one place. No fleet tracking, no dispatching, no features I'd never use.
It's free right now. I'm not trying to make money yet — I just want to know if I've actually solved a real problem. Once it's worth paying for, I'm thinking $9/month, just enough to cover server costs.
If you're a solo contractor and want to try it, I'd love brutal feedback.
 https://fieldflow-nine.vercel.app/auth

value: Show HN: Dead-simple job management tool for solo contractors ($0 for now)


value: terrymaster

value:
  I've been building a modern take on a MUD (multiplayer text RPG) with Claude Code over the past few weeks. Kotlin server, Android client, React-based world editor. The usual hobby project stuff.

  The interesting part is the agent pipeline that grew around it:

  - A /game-designer agent reads all the world data files, models the combat math, and produces balance proposals with specific JSON changes
  - A /playtest agent connects to the running game server over WebSocket, creates a character, explores, fights NPCs, loots items, and files GitHub issues for bugs it encounters
  - A /worldmaker agent drives the world editor in a real browser via Playwright — clicks through zone editing, NPC configuration, item creation, and files issues when things break
  - A /bugfixer agent picks up those issues and submits fixes

  Each agent has persistent memory across sessions, so the game designer remembers its previous balance audits and the playtester remembers what areas it's already explored.

  The game itself is a modern take on '90s MUDs like MajorMUD — tick-based combat, NPC behaviors (wander, patrol, pursuit), spells, skills, stealth, loot tables, vendors, trainers. 4 zones, 25 rooms, 17 NPCs. Everything is data-driven JSON — the world editor exports .nmd bundles (ZIP archives) that the server loads at startup, similar to DOOM's WAD files.

  The world editor has a visual zone map where you place rooms on a shared coordinate grid, click to connect exits, and configure NPC patrol routes by clicking rooms on the map. All zones share one global coordinate space so rooms can't overlap across zones.

  ~45k lines of code, 830 tests across server/shared/maker, 460 AI-generated assets (images and audio). The agents have filed about 40 GitHub issues so far, most of which are legitimate.

  It's a hobby project — combat balance is rough, there's no quest system yet, and it needs real multiplayer stress testing. But the feedback loop of building features and then having agents test them in the actual running application has been a surprisingly effective workflow.

value: Show HN: NeoMud – A multiplayer dungeon game with AI agents that QA and playtest

author: terrymaster


value:
I've been thinking about how AI will change advertising. Instead of static banners or landing pages, what if an ad was a conversation?
I built a demo to explore this: a fictional luxury EV brand called Vela, with an AI sales consultant named Stella you can actually talk to. Ask her about range, pricing, comparisons to competitors — she knows the product inside out.
Try it here: https://99helpers.com/tools/vela-chat
The idea is simple: instead of cramming everything into a hero section and hoping someone scrolls, you let the customer ask what they actually care about. The AI handles objections, comparisons, and details on demand.
Built with my own platform (99helpers.com) which lets you give an AI chatbot a knowledge base and embed it anywhere. This is one use case I hadn't fully considered until recently — using the chatbot not for support, but as the ad itself.
Curious what HN thinks. Is conversational advertising compelling, or just a gimmick?

value: Show HN: I built an AI-powered advert – is this the future of advertising?


value: ScottHudson

value:
I built a small internal tool because our team had a constant problem keeping track of who was onsite, remote, or unavailable.
Different teams were using whiteboards, spreadsheets, or chat messages and it was messy for operational teams that just needed a quick "who is around" view.
So I built a simple real-time dashboard that shows everyone's status at a glance.
It runs locally, has no external dependencies, and can be deployed in a few minutes.
Technically it's a small Node.js application using a SQLite database with a simple web dashboard, designed to run entirely on-prem without requiring cloud services.
It has been running internally for a while and is now also running in production inside a government environment, so I decided to clean it up and release it publicly.
Curious what the HN crowd thinks.

value: Show HN: Attendr – lightweight self-hosted staff presence dashboard

author: ScottHudson


value: WingenderA

value:
Introducing React Native View Recorder!
The ultimate library to record any native View in your app and export it as a video or an image. No server required, MIT Licensed.
- Record or snapshot any arbitrary View in React Native, whole app dashboard or only part of it
- Supports recording Skia Canvas
- You have frame-by-frame control over the video you're recording
- Add your audio file or mix in the audio frame by frame
- Fully native, no FFmpeg binaries
- Control FPS, bitrate
- Support for H.264, HEVC, and transparency
Star it on GitHub: https://github.com/Rednegniw/react-native-view-recorder
Check out the docs: https://react-native-view-recorder.awingender.com/

value: Show HN: A library to turn any React Native View into a video or an image

author: WingenderA


value: Show HN: PACO A tool to find Dependency Confusion vulnerabilities


value: nakaiwilliams

value:
Solo dev from South Africa. Spent 3 months building this.
Every AI meeting tool sends conversations to the cloud. I trained my own PII model - 72M words, 100% catch rate on real meetings. Before anything touches AI, names become aliases, amounts scramble, identifiers vanish.
Everything runs on-device. Nothing leaves your machine.
Free for now - can't afford Apple's $99 notarization yet. Happy to answer questions about the tech.

value: Show HN: Veil – On-device meeting transcription with 100% PII redaction

author: nakaiwilliams


value: gustavogb

value:
Hi HN! I'm Gustavo, building LiveTok (https://www.livetok.ai) – AI agents that handle phone calls and WhatsApp for veterinary clinics.
Vet clinics lose clients to missed calls. The front desk is juggling check-ins, anxious pet parents in the waiting room, and a phone that won't stop ringing. After hours, it goes to voicemail – and most people just call the next clinic on Google instead of leaving a message.
We built LiveTok to answer every call, 24/7. The AI receptionist books appointments, answers common questions about hours and services, and routes to a vet tech when the conversation needs human judgment. It handles the routine stuff so your staff can focus on the animals in front of them.
Clinics using it are seeing up to 40% more appointments – mostly from calls that previously went unanswered or to voicemail.
Setup takes about 5 minutes – connect your phone number, add your clinic's info and availability, and it's live. No coding required.
The interesting technical challenge has been voice quality and natural conversation flow. People calling about their pets are often stressed or in a hurry. The AI needs to sound calm, get to the point quickly, and know when to hand off rather than frustrate someone who needs a real person. We've tuned latency and interruption handling specifically for these high-stakes, emotionally-charged calls.
This month we're offering free trials – if you run a vet clinic or know someone who does, we'd love to have you try it. For the first few customers, we're also offering custom integrations with your practice management software if needed.
Demo: https://www.livetok.ai/industries/veterinary
Would love feedback from anyone who's built voice AI or worked on vertical SaaS for local businesses. What's worked for you on go-to-market?

value: Show HN: LiveTok – AI Receptionist for Veterinary Clinics

author: gustavogb


value: mybets

value:
Hi HN,
I'm the solo developer behind MyBets.gg.
I built this because trying to build a reliable bet tracker in Excel eventually becomes a nightmare of broken formulas, manual data entry, and fragmented history across different sportsbooks.
The goal of the project is to treat sports betting less like gambling and more like day trading. A good bet tracker shouldn't just record wins and losses; it needs to focus strictly on unit sizing, closing line value (CLV), and long-term bankroll management.
From a business standpoint, I managed to get 4 paying users ($60 MRR) early on, but then completely hit a wall. I realized that trying to rank a bet tracker on Google as a solo dev is a brutal SEO battle against massive casinos and affiliates. It burned me out, and I took a month away from the keyboard.
I'm back now, focusing purely on improving the product, the data visualization, and finding organic ways to grow.
I know gambling isn't everyone's cup of tea here, but from a pure data and analytics perspective, I'd love any harsh feedback on the UI, the data visualizations, or how the dashboard handles the math.
Happy to answer any questions about challenges of building in this space.

value: Show HN: Mybets.gg – A bet tracker and analytics dashboard

author: mybets


value: HiTechK

value: Show HN: VibeSing – Trend-driven voice cloning pipeline for social music sharing

author: HiTechK


value: beyhang

value:
Testing AI agents is painful. Every test run calls the LLM API, costs real money, takes minutes, and gives different results each time. CI? Forget about it.
Evalcraft fixes this with cassette-based capture and replay — think VCR for HTTP, but for LLM calls and tool use.
How it works:
1. Run your agent once with real API calls. Evalcraft records every LLM request, tool call, and response into a JSON cassette file.
2. In tests, replay from the cassette. Zero API calls, zero cost, deterministic output.
3. Assert on what matters: tool call sequences, output content, cost budgets, token counts.

  run = replay("cassettes/support_agent.json")
  assert_tool_called(run, "lookup_order", with_args={"order_id": "ORD-1042"})
  assert_tool_order(run, ["lookup_order", "search_knowledge_base"])
  assert_cost_under(run, max_usd=0.01)

It's pytest-native — fixtures, markers, CLI flags. Works with OpenAI, Anthropic, LangGraph, CrewAI, AutoGen, and LlamaIndex out of the box. Adapters auto-instrument your agent with zero code changes.
Also ships with golden-set management, regression detection, PII sanitization, and 16 CLI commands for inspecting/diffing cassettes.
555 tests, MIT licensed, `pip install evalcraft`.
Repo: https://github.com/beyhangl/evalcraft
PyPI: https://pypi.org/project/evalcraft/
Docs: https://beyhangl.github.io/evalcraft/docs/
Would love feedback from anyone testing agents in CI.

value: Show HN: Evalcraft – cassette-based testing for AI agents (pytest, $0/run)

author: beyhang


value: pranshuchittora

value: Show HN: Simvyn – open-source Universal mobile devtool

author: pranshuchittora


value: vpuna

value:
Author here. I'm a software engineer who started writing hard science fiction on the side. I built this tool because I wanted to write in plain Markdown and go straight to Amazon KDP without touching Word, InDesign, or Vellum.
The workflow: I write stories in .md files, one heading per chapter, --- for scene breaks. When I'm ready to publish, I run one command and get a paperback PDF, hardcover PDF, and Kindle EPUB with correct margins, typography, and scene breaks. The tool wraps Pandoc and XeLaTeX with a custom LaTeX template and a Lua filter that handles the scene break conversion. Commander.js is the only Node dependency.
I used this to publish my first novelette, a hard sci-fi story called "The Pull" about an astrophysicist mapping the Zone of Avoidance behind the Milky Way. The science in the story is grounded in real astrophysics (the Great Attractor, large scale cosmic flows, the Zone of Avoidance). I also built an author website at 'alanvoss.me' with Next.js and Payload CMS, deployed as a static site on Vercel, where you can read the first chapter and see the characters.
On AI use and Graphics: The story concept and science are mine. I used Claude Opus 4.6 to help with some character dialogue and for grammar and spelling checks. Character portraits on the website were generated with Midjourney and OpenAI image models. Book covers were made in Canva.
The tool itself is simple (~200 lines of JS), but it solved a real problem for me. The KDP margin requirements are fiddly, especially the difference between paperback and hardcover inner margins, and getting scene breaks to render correctly in both LaTeX and EPUB needed the Lua filter approach. Hopefully useful to other developers who write.
Please let me know if you have any questions about the tool, the publishing process, or KDP in general.

value: Show HN: Markdown-to-Book – Convert Markdown to KDP Ready PDFs and EPUBs

author: vpuna


value: kitasan

value:
Hey HN,
Just dropped v0.1.0 of OxiLean yesterday.
It's a full Interactive Theorem Prover written 100% in Rust (1.2 million lines across 11 crates). Inspired by Lean 4, implements Calculus of Inductive Constructions, universe polymorphism, dependent types, full tactic framework (intro/apply/simp/ring/omega etc.), and even LCNF-based codegen.
Key points that actually matter:
- Kernel has literally zero external crates and zero unsafe. Memory-safe by design, no unwraps, explicit errors everywhere.
- Runs in the browser via WASM (npm package @cooljapan/oxilean ready).
- REPL works out of the box: cargo run --bin oxilean
- No C/Fortran anywhere — unlike original Lean.
Repo: https://github.com/cool-japan/oxilean
WASM demo snippet in README if you want to play instantly.
On my machine I've already proven 99.24% of MathLib4's 179,668 declarations (aiming for 100% in 0.1.1 soon). Been grinding this because I got tired of C++/OCaml build hell in formal methods tools.
Curious what you think — especially if you're into formal verification in Rust or using Lean.

value: Show HN: OxiLean – Pure Rust Interactive Theorem Prover (Zero C Deps, WASM)

author: kitasan


value:
We built Nean Project for software teams running complex, multi-level projects. https://www.neanproject.com/
Nean Project is a task-tree planner with unlimited nesting (areas → features → flows → tasks → subtasks). It also has Smart Views: you can filter/search inside a project and results keep their hierarchy context (parent path stays visible), so it’s not a disconnected list.
When decisions happen, you can attach the “why” as comments/notes on the relevant task/node, so context doesn’t disappear into chat scrollback and the plan becomes a lightweight knowledge base over time.
Free Demo is available. We’d love feedback:
Does “filtered view with parent path context” solve a real pain for you?
What do you use today for deep project breakdowns + decision tracking?
Anything you’d expect from this workflow that’s missing?

value: Show HN: Nean Project – task-tree planning and Smart Filtering


value: Sharanxxxx

value:
Hi HN,
I’m building WiseLocals to solve the lack of transparency in international
sourcing. Most businesses lose margins to opaque intermediaries or face
high fraud risks when sourcing from major manufacturing hubs.
We’ve developed a platform that connects businesses directly with vetted
local experts, moving away from the "middleman" model that often
complicates the supply chain.
Key Technical/Process Focus:
* Multi-tiered verification: A rigorous onboarding process to verify
  local agent identity and expertise.
* Milestone-based payments: Funds are held and only released once
  both parties are satisfied with the service.
* Performance Analytics: Using data-driven insights to track vendor
  reliability over time.
* Direct Project Management: A dedicated interface for real-time
  communication and project tracking.
I’d love to hear your thoughts on how to further automate trust in
cross-border B2B transactions!

value: Show HN: WiseLocals – Vetted B2B sourcing agents for manufacturing hubs

author: Sharanxxxx


value: Martibis

value:
Hi HN, I built Boosterpack Forms, a form backend for developers.
The idea is simple: point any HTML form at the API, and it blocks spam invisibly, delivers submissions straight to your email or webhook, and stores nothing.
I built it because I kept running into the same tradeoff with forms on websites and client projects: the simpler tools were fast but limiting, while the more advanced ones often came with dashboards, stored submissions, more complexity, and more overhead than I actually wanted.
What I wanted was something closer to:
- invisible spam blocking
- no CAPTCHA for visitors
- email and webhook delivery
- simple integration with HTML forms
- no dashboard required
- less privacy/GDPR overhead
So that's what I built. There’s a free tier as well.
Would love feedback, especially from people building websites, client projects, or lightweight products. Curious whether this "barebones vs bloated platform" gap is something others have run into too.

value: Show HN: Boosterpack Forms – block spam, deliver instantly, store nothing

author: Martibis


value: johannesmi

value:
I think filesystems are the right abstraction for agent memory. Not vector databases, not key-value stores, not custom memory APIs.
Why? Because agents already know how to use files. Claude Code writes notes to ~/.claude/. Cursor stores context in project files. Every coding agent that works well has converged on the same pattern: just use files. The model doesn't need to learn a new API, and you don't need a retrieval pipeline.
The problem is that real filesystems don't work in production.
agent-vfs gives each user a virtual filesystem backed by a single database table. 11 operations (read, write, edit, ls, grep, glob, etc.), SQLite for local dev, Postgres for production. Works with the Vercel AI SDK, OpenAI SDK, and Anthropic SDK out of the box.
npm install agent-vfs
GitHub: https://github.com/johannesmichalke/agent-vfs

value: Show HN: Agent-vfs – Virtual filesystem for AI agent memory

author: johannesmi


value:
Hi HN - I am building Twick, a React video editor SDK for teams that want to ship video workflows inside their product.
Core features:
- Drag and drop video editor UI with timeline + canvas (`@twick/studio`)
- Auto Caption flow for generating timed captions from video
- Asset management for both user uploads and public assets
- Modular packages if you want headless/custom UI (`@twick/timeline`, `@twick/canvas`, `@twick/live-player`)
- MP4 export in browser (`@twick/browser-render`) or server-side (`@twick/render-server`)
Live demo:
https://development.d1vtsw7m0lx01h.amplifyapp.com
Repo:
https://github.com/ncounterspecialist/twick
I would love feedback focused on adoption and product direction:
1) Which SaaS categories should I target first with this stack?
2) For those categories, which features are mandatory before production adoption?
3) What would make you choose an open-source SDK like this over building in-house or using a hosted API?

value: Show HN: Twick – React SDK for building timeline-based video editors


value: dj-trondheim

value: Show HN: Sample Size Calculator for A/B Tests (client-side, no dependencies)

author: dj-trondheim


value:
I built cpx, a modern take on cp that adds progress bars, resumable copies, and parallel file copying.
It’s written in Rust and aims to make copying large directories less opaque and faster while staying simple to use.
Repo:
https://github.com/11happy/cpx
Would love feedback.

value: Show HN: cpx – cp with progress bars, resume and parallel copying


value: ronreiter

value: Show HN: Moltty – Organized, Persistent AI Coding Sessions

author: ronreiter


value: jairooh

value: Show HN: AgentShield – Real-time monitoring for AI agents in production

author: jairooh


value: powerwild

value:
Hi HN,
I built DataQueryAI to let people run queries on their databases using plain language — no SQL knowledge required.
Key points:
- *Local-first AI*: runs on your machine using the Ollama engine, no data leaves your device.
- Supports Postgres, MySQL, and SQL Server.
- Exports results to CSV, Excel, or HTML.
- Supports English, Vietnamese, German, French, Italian, Portuguese, Hindi, Spanish, and Thai.
- Windows x86/x64, macOS ARM64/x64, Linux coming soon.
Pricing:
- Free Forever: single DB profile, CSV export.
- Pro Monthly: $16/mo, multiple DBs, Excel/HTML export.
- Pro Lifetime: $79 one-time, multiple DBs, full export support.
The goal was to make querying databases fast, private, and accessible to non-technical users. Would love feedback from HN on:
- Usefulness for your workflow
- Any features you’d like next
- Thoughts on local-first AI tools for privacy
Happy to answer questions.

value: Show HN: DataQueryAI – Turn plain text into SQL locally

author: powerwild


value: iamleojiang

value: Hey HN,<p>I am Leo Jiang, founder of Gro. I built this to solve the problem of fragmented sales stacks where teams waste hours between lead databases and outreach tools. Gro is a unified AI sales agent that combines a 1b+ contact database with AI propensity scoring and automated outreach across Email and LinkedIn. By putting prospecting and engagement into one workspace, we eliminate manual data hunting so sales reps can focus on closing deals. I would love your thoughts on our approach to automated B2B growth.

value: Show HN: I made a tool that automates B2B outreach with a 1B+ contact database

author: iamleojiang


value: rane

value: Show HN: Git-surgeon – Hunk-level Git primitives for AI agents

author: rane


value: caballeto

value:
Hi HN, I'm Vlad. I've been building MCP servers and related tooling for a while now, and I kept hitting a class of bug that no unit test caught: someone on the team renames a tool parameter or tweaks a tool description, all the tests pass, but the AI agent that was calling that tool silently breaks. This happens because the model reads tool descriptions and parameter schemas to decide which tool to call and how, so a renamed parameter or a reworded description isn't just a cosmetic change — it directly affects the model's behavior.
The MCP spec doesn't have tool versioning available yet, and there's no static artifact describing what a server exposes. The tools/list just returns whatever's in memory at runtime and there's nothing to commit or diff against, which means changes slip through that can break downstream workflows without noticing.
The same problem for HTTP was already solved a long time ago with VCR.py, and I realized the same pattern works here. mcp-recorder captures the full MCP interaction sequence — initialize, tools/list, tools/call — into a JSON cassette file. Because it records complete protocol exchanges rather than just schema snapshots, you're testing actual behavior: if a tool call that used to return a specific format now returns something different, or a capability quietly disappears during the handshake, the cassette catches it. From that single recording you can replay it as a mock server (no API keys, fully deterministic), or verify your changed server against it and catch any diff:
Verifying golden.json against node dist/index.js

  1. initialize [PASS]

  2. tools/list [PASS]

  3. tools/call [search] [FAIL]

    $.result.content[0].text: "old output" != "new output"

  4. tools/call [analyze] [PASS]

Result: 3/4 passed, 1 failed
Non-zero exit code on any mismatch, so it plugs straight into CI.
You can try it right now with minimal setup, there's a public demo server and a scenarios file included:
pip install mcp-recorder
mcp-recorder record-scenarios scenarios.yml
mcp-recorder verify --cassette cassettes/demo_walkthrough.json \
  --target https://mcp.devhelm.io
It works with both HTTP and stdio transports. Scenarios are defined in YAML so it works with MCP servers in any language, and there's a pytest plugin if you want tighter integration. Secret redaction and environment variable interpolation are built in.
To make sure this actually works on real codebases, I submitted several PRs to production MCP servers: monday.com's MCP server (https://github.com/mondaycom/mcp/pull/222), Tavily's MCP server (https://github.com/tavily-ai/tavily-mcp/pull/113), and Firecrawl's MCP server (https://github.com/firecrawl/firecrawl-mcp-server/pull/175). They went from zero schema coverage to full tool surface verification with a clean schema diff available on each tool change. One big benefit is that you can do verification and replay with no API keys — deterministic responses, no live requests to real servers.
I wrote up a deeper dive into the schema drift problem and the VCR pattern for MCP here: https://devhelm.io/blog/regression-testing-mcp-servers
mcp-recorder is MIT-licensed and on PyPI. Source is at https://github.com/devhelmhq/mcp-recorder — issues and PRs are welcome.
I'm building more tooling around MCP and agent reliability, so if you're dealing with similar problems, I'd genuinely like to hear what's been painful for you.

value: Show HN: mcp-recorder – VCR.py for MCP servers. Record, replay, verify

author: caballeto


value:
I built Ledgi because I wanted to track my net worth across UK-specific stuff: ISAs, pensions, property, investments, debt.
Most finance trackers are US focused or want you to connect your bank. Ledgi is manual entry only, with AES field level encryption on all financial data.
There's also an open source CLI and a Claude Code skill. You authenticate with scoped API keys (accounts:read,holdings:write, etc.) and an AI agent can query your data directly. I use it to ask things like "what's my net worth breakdown?" or "how much ISA allowance do I have left?"
https://ledgi.app
CLI: https://github.com/LedgiApp/ledgi-cli
Claude skill: https://github.com/LedgiApp/skills
happy to hear your feedback!

value: Show HN: Ledgi: UK net worth tracker with a CLI for AI agents


value: falsename

value:
  Single Rust binary. Manages multiple AI coding agent sessions in tmux — Claude Code, Codex CLI, Gemini CLI side by side. Dashboard gives you tabs (F1–F11) to see each agent's terminal live.

  The agents get personas, persistent memory across sessions, and can message each other directly. Cross-machine P2P works over TLS 1.3 so crews on different machines collaborate.
  My favorite part: a dedicated archivist agent that never writes code, just indexes the entire repo on every push so other agents stop burning context grepping for files but ask him questions instead.

Free account, created during first run.

value: Show HN: Metateam: run many Claude/Codex/Gemini CLI instances in one terminal UI

author: falsename


value: mabsrencode

value:
I built Easemonitor to keep track of service uptime, response times, SEO, vulnerability scans, etc.
It's 100 % open‑source (GPL‑3), runs in Docker on a cheap VPS and includes:
NestJS API + worker with BullMQ queues
NextJS frontend with SSR caching & image optimization
Prometheus metrics, Loki logs, Grafana dashboards, Jaeger tracing
JWT rotation, WAF rules, CSP/HSTS, CVE audit scripts
Webhook DLQ, queue dashboard, healthchecks, maintenance mode
You can try it on my demo https://easemonitor.com
Would love feedback, contributions, or ideas for features.

value: Show HN: Easemonitor – self‑hosted uptime and performance monitoring

author: mabsrencode


value: GiornoJojo

value:
Roast AI products which are coming from all over the world.
Throw tomatoes and flip-flop.
And enjoy the rest of your day.

value: Show HN: Glad-AI-Tor – We Gamified an Arena in Order to Judge Vibecoded Products

author: GiornoJojo


value: Show HN: Portal – self-hosted E2E TLS tunnel for localhost (ngrok alternative)


value: bartmichalak

value:
Hi, I'm Bart, one of the maintainers of Open Wearables.
For the past few months we've been building an open-source, self-hosted backend that normalises health and fitness data from multiple wearable providers (Garmin, Whoop, Apple Health, Samsung Health and others) into a single AI-ready REST API - and thought it was worth sharing here too :)
We built this out of our own experience doing custom wearable integrations for clients, and from working with paid SaaS solutions that often lack the flexibility to customise data pipelines or debug what's actually happening under the hood. Surprisingly, there weren't any mature open-source projects filling this gap.
What you get:
- A single normalised API covering 60+ health metrics (cardiovascular, sleep, body composition, activity, respiratory) and 80+ workout types across all supported providers
- A dashboard to manage users, API keys, and sync status — with a full view of each user's health data across connected devices
- An AI layer via MCP, letting you plug users' health data into any LLM or build a custom agent around it
- Open-source mobile apps for SDK-based providers (like Apple Health) so you can quickly test how data flows from device to your platform end-to-end
On the roadmap: more providers, deeper AI features, direct wearable connections via BLE/ANT+ and performance and stability improvements to support enterprise deployments.
Happy to answer any questions. If this solves a problem you've been dealing with - give it a try, open an issue or contribute. All feedback welcome!

value: Show HN: Open Wearables – self-hosted wearable data platform with an AI layer

author: bartmichalak


value: alessandroetc

value: Show HN: KudoSnap – Anonymous positive polls that turn Slack into a kudos loop

author: alessandroetc


value: viiictordotcom

value:
Intrinsic is a terminal tool I built to analyze companies from financial statements.
It’s an ncurses TUI written in C++ that stores data locally in SQLite. The goal is a fast keyboard-driven workflow for tracking companies and computing metrics like P/E, EV, ROE, margins, etc.
The project is written in C++ and distributed as a Nix package (Linux/macOS, WSL on Windows).

value: Show HN: Intrinsic – Terminal stock analysis tool (C++ / ncurses / SQLite)

author: viiictordotcom


value: oldskultxo

value:
A few months ago I tried to write an interactive fiction novel.
It turned into a software project.
As the story grew, managing the structure quickly became difficult: branches, conditions, narrative state… everything started getting messy.
At some point I opened Visual Studio to try to solve the problem for myself. The initial idea was simple: separate the prose from the runtime logic that drives the story.
That experiment slowly turned into a small ecosystem called iepub:
• a structured format for interactive books
• a reader runtime that interprets that format
• and a visual editor designed for writing interactive fiction
The editor tries to feel like a normal writing tool (something closer to Google Docs) but designed for branching narrative. It lets you define narrative conditions, attach variables to sections, configure probabilistic events (like dice rolls), create narrative variants, and visualize the structure of the story as a graph.
Most of the development ended up happening with AI agents (Codex) acting as development partners, which turned into a surprisingly effective workflow for iterating on architecture, UI components and debugging.
If anyone is curious:
Project:
https://iepub.io
Article about the development process:
https://medium.com/@santi.santamaria.medel/interactive-ficti...
Happy to answer questions about the project, the architecture, or the AI-assisted development workflow.

value: Show HN: I tried writing an interactive novel and accidentally built a platform

author: oldskultxo


value: bkrisa

value: Show HN: I made a recent sales notification popup

author: bkrisa


value: FabriceHategeki

value:
TypR is a statically typed language written in Rust that compiles down to plain R code using S3 classes. The goal is to bring type safety to R without leaving the ecosystem — the generated output is idiomatic R you can drop into any existing project.
The compiler uses monomorphization to resolve generic types at compile time, so there's no runtime overhead. The type system supports structural typing, interfaces, and generics.
It's still in alpha, but here's what's available so far:
GitHub: https://github.com/we-data-ch/typr
Binaries (Windows/Mac/Linux): https://github.com/we-data-ch/typr/releases
Online playground: https://we-data-ch.github.io/typr-playground.github.io/
VS Code extension with LSP: https://marketplace.visualstudio.com/items?itemName=wedata-c...
Docs (WIP): https://we-data-ch.github.io/typr.github.io/
Known limitations: the standard library is minimal so the user need to type some existing functions/variables with signatures, error messages need work, and the LSP is basic. Positron and Neovim support are in progress.
Would appreciate feedback on the type system design or ideas for use cases that would make this useful in practice.

value: Show HN: TypR – A typed R that transpiles to idiomatic R via S3 classes

author: FabriceHategeki


value: riegerj

value:
I built DiffDeck because I was struggling to review larger pull requests in
GitHub, especially ones with a lot of AI-assisted code.
GitHub's diff view works well for smaller changes, but once a PR gets big I
usually want more of an editor-style workflow while reviewing ie see the
surrounding code, jump to related symbols and files, and mark off what I have already reviewed and I felt Github's interface was really frustrating  me.
DiffDeck opens a GitHub pull request in a review workspace with:
- full file context
- go-to-definition and references for TS/JS
- review notes
- per-file reviewed state and review progress
- hide/checkoff reviewed files
One thing I wanted was for it to feel closer to VS Code than a traditional PR tool. You can jump around the codebase while reviewing, and features like go-to-definition are meant to feel familiar if you already spend most of your time in an editor.
Right now it requires GitHub sign-in, because the point is to open pull
requests you already have access to and review them with more context than
GitHub's diff view gives you. I considered making a public demo, but that felt less representative than letting people try it on their own PRs.
This is an early alpha. Right now the code navigation features are focused on TypeScript and JavaScript codebases. The main thing I'm trying to learn is whether this is actually a better review workflow than staying in GitHub's PR UI. For now you can feel free to review a single PR.
I'd especially like feedback from people who review large PRs or AI-generated code:
- what still feels missing
- whether this solves a real problem or just one I personally had

value: Show HN: DiffDeck, a PR review tool with file context and code navigation

author: riegerj


value: burlakovlm

value:
I’m trying to sanity check an idea with people who work with regulated systems.
In many organisations we have scanners for code, monitoring for systems, and multiple layers of controls and audit. But the business process itself is rarely checked for logical vulnerabilities before it goes live.
Processes like KYC onboarding, approvals, payments or compliance workflows are often designed in meetings and documented later. Over time more controls get added and monitoring improves, but the underlying process logic is rarely tested.
Which raises a simple question: can this process be bypassed?
I started experimenting with describing processes as state machines and running static checks on them. Things like reachability, missing review steps, irreversible actions without compensation, and similar structural issues.
The idea is to detect what you might call "business process vulnerabilities by design" before the process is deployed.
The page explains the concept and shows a small prototype. The prototype lets you describe a process as a state machine and run automated checks against rule sets (for example operational risk or resilience rules).
What I’m mainly trying to understand is whether this is actually a real problem in practice.
For people working in fintech, banking, risk or operations:
Do process bypasses or design gaps show up in real systems?
How are new processes usually reviewed before they go live?
Where do things tend to break down?
Paper: veilgovernance.com/research/missing-first-line-of-defence

value: Show HN: Checking if financial processes can be bypassed before deployment

author: burlakovlm


value: ijonis

value:
Hey HN, I built geo-lint — an open-source linter for content (Markdown/MDX) that checks 92 deterministic rules across SEO, GEO (Generative Engine Optimization), content quality, and technical issues.
GEO is the idea that AI search engines (ChatGPT, Perplexity, Claude) cite content differently than Google ranks it. Things like question-formatted headings, FAQ sections, entity density, E-E-A-T signals, and citation-ready statistics all matter for whether an LLM will pull from your content. geo-lint has 35 rules specifically for this.
The interesting part is the lint loop. It ships as a Claude Code skill — you run /geo-lint audit and it spawns parallel subagents, one per file. Each agent reads the violations, edits the content, re-lints, and repeats until clean (max 5 passes). The linter is fully deterministic (no LLM in the rules themselves), so the agent gets unambiguous violation + suggestion pairs to act on. Zero hallucination risk in the analysis layer.
It also works without Claude Code — npx geo-lint --format=json gives you a flat JSON array any agent (Cursor, Copilot, Windsurf) can consume. The rules are the same either way.
MIT licensed, zero runtime deps beyond gray-matter. npm: @ijonis/geo-lint
GitHub: https://github.com/IJONIS/geo-lint

value: Show HN: Geo-lint – Claude Code skill that auto-fixes SEO/GEO violations in loop

author: ijonis


value: I build this tool for using port forwarding with mosh (if too lazy to open my vscode). Hope it is helpful and hear your help on further improving it.

value: Show HN: Port Forwarding Wrapper for Mosh


value:
I've been experimenting with MCP-based agents for some of my daily workflows
(checking assigned issues, gathering context, drafting plans, etc.).
With most agent frameworks, tool calls run in a loop like this:
agent → tool → agent → tool → agent → tool
Each step goes back through the model. For tools returning large payloads,
this adds latency and burns tokens.
So I built a small tool that converts an MCP server into a Python skill.
It introspects the server and generates a typed Python class where each tool
becomes an async method.
Example:

    issue = await github.get_issue(issue_id)
    docs = await search.web_search(issue.title)

The agent can process results locally in code and only return the final output.
This also enables progressive disclosure. Tools can return large responses,
but the agent can filter or aggregate data in code instead of sending
everything back into the model context.
The generated skills include a `SKILL.md` file and can be reused later,
so useful workflows can be saved and run again as scripts.
Still a work in progress, but already useful in my own setup.
Would love feedback from others experimenting with MCP or similar patterns.
Repo:
https://github.com/manojbajaj95/mcp-skill

value: Show HN: MCP-skill – generate Python skills from MCP servers


value: iamovi

value:
Built this as an experiment in removing permanence from developer communication. Every post, comment, and interaction hard-deletes after 24 hours via pg_cron — not hidden, actually gone from the database.
Stack: React + Vite, Tailwind, Supabase, Vercel. Fully open source: github.com/iamovi/genjutsu
Happy to answer questions about the architecture or the ephemeral deletion logic.

value: Show HN: Genjutsu – Dev social network where posts vanish in 24h

author: iamovi


value:
Running Claude Code on a remote server via SSH means Ctrl+V image paste doesn't work —
  xclip reads the server's clipboard, not your local Mac's.

  cc-clip fixes this with a transparent bridge:

    Local Mac clipboard → HTTP daemon → SSH tunnel → xclip shim → Claude Code

  A local daemon serves your clipboard over loopback. SSH RemoteForward tunnels it to the
  remote. A bash shim intercepts exactly the two xclip calls Claude Code makes and fetches
  images through the tunnel. Everything else passes through to real xclip.

    cc-clip setup myserver

  One command: installs deps, configures SSH, starts daemon, deploys to remote.

  Security: loopback-only, session-scoped token (12h TTL), token via stdin not args.

  macOS → Linux (amd64/arm64). v0.2.0 just released. Looking for feedback on different
  distros, Wayland setups, and edge cases.

  https://github.com/ShunmeiCho/cc-clip

  ---
  3. X/Twitter

  I built cc-clip — paste images into remote Claude Code over SSH, as if it were local.

  Local clipboard → SSH tunnel → xclip shim → Claude Code

  One command setup:
  $ cc-clip setup myserver

  No changes to Claude Code. Works with any terminal.

  Looking for feedback & bug reports

  github.com/ShunmeiCho/cc-clip

  #ClaudeCode #SSH #DevTools

value: Show HN: Cc-clip – Paste images into remote Claude Code over SSH


value: zskov

value: Built this for my own automation service work—details in first comment.

value: Show HN: Flospect – Catalog, share and document your automation flows

author: zskov


value: Show HN: AI load balancer and API translator


value: jnsquire

value: Show HN: Dapper – Debug Adapter for Python

author: jnsquire


value: aaaljaz

value:
I've built https://confidentialinference.net/ to make it easy for myself (and others) to explore which confidential inference providers exist and more importantly which models are available and how much they cost.
The pricing varies significantly across providers as you can see on https://confidentialinference.net/models.
Data collection is semi-automated as some providers make it very hard to find the information at all, let alone pull it automatically. If anyone knows of any other provider that isn't on the list let me know.

value: Show HN: Confidential Inference Provider Comparison

author: aaaljaz


value: jonas-is-coding

value:
Built a custom RL environment in Python/Gymnasium to benchmark PPO against a Destination Dispatching algorithm. 20 floors, 4 elevators, probabilistic traffic patterns with morning/evening rush simulation.
Key result: 84% reduction in average passenger wait time. Currently adding realistic elevator physics (acceleration curves, door cycles).
Github: https://github.com/jonas-is-coding/elevator-ai

value: Show HN: PPO agent reduces elevator wait times by 84% vs. classical dispatching

author: jonas-is-coding


value: blueblazin

value:
Hi HN, inspired by the Cursor team's attempt to use agents to vibe code a browser, I decided to try something a bit easier but still challenging enough to push the limits of current coding agents.
The result is a Python 3.14 targeting python interpreter written in Rust entirely by a single coding agent (Codex) in 30 days.
While the main focus is a native interpreter (macOS and linux atm) there is also a limited-functionality WASM version that you can try immediately on the website!
This was purely a fun project and I certainly had a lot of fun. My main role was playing pretend technical program manager and trying to prevent the agent from derailing (which it did very regularly). But anyway, 30 days, 342k lines of code, and nearly 2000 commits later, I have something that works.
I thought I'd be done in 3-5 days, then 2 weeks, then 3, before it was ready after 30 days. Feel like I've learned a lot more about these strange, impressive, and frustrating creatures that are agentic coding models as well.
Still a long way to go, and I will also be adding some performance benchmarks and test results in the coming days, but there it is.

value: Show HN: AI agent coded Python 3.14 interpreter in Rust

author: blueblazin


value: Fubwubs

value: Show HN: DNS Bench – Test public DNS-over-HTTPS servers from the browser

author: Fubwubs


value: julianrubisch

value:
I've been a freelance developer for years and always struggled with planning my weeks and tracking project budgets. I use Harvest for time tracking, but it doesn't give me a weekly view or budget visibility until it's too late.
So I built Crow's Nest – a work week planner and budget visibility layer that sits on top of Harvest. It pulls your time entries and shows you:
- Your week laid out by project and capacity (before Monday hits)
- Real-time budget progress for each project
- The gap between what you planned and what actually happened
It's not a Harvest replacement – just the planning layer that's missing. You need an active Harvest account to use it.
Why I'm sharing it on HN: I'd love technical feedback from fellow freelancers and builders. The product is early (two alpha users), and HN's constructive criticism has always been invaluable for my projects.
Technical details: Ruby on Rails with heavy usage of Web Awesome and Phlex
Biggest challenges:
1. Mapping Harvest's time entry data to a weekly planning model
2. Creating a simple UI that doesn't add cognitive load
3. Handling timezone differences for freelancers working with global clients
Try it: https://mycrowsnest.app
Would appreciate feedback on:
- Does this solve a real problem for freelancers who use Harvest?
- What features would make it indispensable?
- UX/UI improvements
I'm the developer, building this in the open. All feedback welcome.

value: Show HN: Crow's Nest – a weekly planner and budget tracker for Harvest users

author: julianrubisch


value:
Most social apps are built around follower graphs and broadcast reach. I’ve been experimenting with what happens if groups are the core structure instead.
I built Aligno around that idea: chat, posts, events, and shared boards designed for shared momentum, alongside personal goal tracking.
I’m sure variations of group-based social apps have existed before, but this is my take. The idea came from noticing how hard it can be to find intentional communities of people working toward the same goals — and how motivation and momentum tend to fade as life gets busier.
Currently it’s iOS only. If the idea resonates and feedback is strong, I’ll likely bring it to Android as well.
Curious what builders here think. Looking for honest product critique and edge-case feedback.

value: Show HN: Followers are a bad primitive – I built a group-first social app


value: marlburrow

value: Show HN: KinBot – Self-hosted AI agents that build their own web apps

author: marlburrow


value: rtuyeras

value:
I built an open-source desktop app for running and monitoring Python agents that talk over TCP.
It works on macOS, Linux, and Windows. The basic idea is simple: if a repo has an `agent.py` entrypoint, the app can import it from GitHub, install `requirements.txt` if needed, connect it to a TCP server, and show what it is doing in one UI.
Current features:
* import agent repos from GitHub, including private repos
* run agents through `agent.py`
* optional `requirements.txt` support
* optional `id.json` for agent metadata
* connect agents to TCP servers
* inspect message flow in one place
* map/network view showing where connected servers are
I originally built this because managing multiple agents by hand across terminals and scripts gets messy fast.
This is not an agent framework. It is more of an operational layer for Python repos that already follow a simple entrypoint and communicate over TCP.
Repo: https://github.com/Summoner-Network/summoner-desktop
Demo: https://youtu.be/yvD712Uj3vI
Interested in feedback on whether this workflow makes sense, and what might be missing for real multi-agent setups.

value: Show HN: Desktop app to run Python agents over TCP with live server geolocation

author: rtuyeras


value: ashannon

value: Show HN: Live HTML email playground – preview Gmail/Outlook rendering

author: ashannon


value:
I’ve been exploring the NPPES dataset, the federal registry that assigns NPI numbers to every healthcare provider in the U.S. It currently has about 9 million records and grows by ~30k per month, but accessing it usually means downloading multi-gigabyte CSVs or using the CMS lookup that returns one provider at a time.
I built NPIScan to make the dataset browsable. You can search by name, NPI, specialty, or location and drill down from state → city → ZIP code. Each provider has a profile with credentials, practice locations, taxonomy codes, and digital health endpoints.
A few interesting patterns from the data:
- 2025 had ~631k new NPI registrations, the largest jump on record
- Behavior Technicians grew to ~526k providers and are now among the largest specialties
- California alone has ~1.1M providers (~12% of the country)
- Only ~0.5% of providers have registered digital health endpoints
Tech stack: Next.js, PostgreSQL, Meilisearch, Redis.
The main challenge was making 9M records feel fast to browse. I solved it with denormalized listing tables, Meilisearch full-text search, and Redis caching for aggregated queries. Most pages respond in <40ms after cache warmup.
Curious to hear feedback from anyone working with healthcare data.

value: Show HN: NPIScan search 9M U.S. healthcare providers from the NPI registry


value: mahmedalam

value:
Hey HN.
I’m a 17-year-old developer, and I recently needed to compress a lot of images for a small website I was working on.
Most tools I found required uploading files to their servers.
That made me uncomfortable, especially since many of the images belonged to clients.
I also ran into another issue: many tools were slow at compressing multiple images because of server uploads.
So I decided to build something that works differently.
I built ConUtil, an image toolkit that runs entirely in the browser.
Ahmed

value: Show HN: I made a privacy-first browser-based image compressor

author: mahmedalam


value: ismdeep

value: git-credential-pass is a Git credential helper backed by pass.

value: Show HN: Git-Credential-Pass

author: ismdeep

title: Show HN: Git-Credential-Pass


value: marcohaber

value: Show HN: Interactive 3D globe of EU shipping emissions

author: marcohaber


value: MonoEarthwalker

value: Show HN: Local-first Gmail and LinkedIn writing copilot built with Claude

author: MonoEarthwalker


value: squidleon

value:
I've been building a modern Ultima Online server emulator from scratch. It's not feature-complete (no combat, no skills yet), but the foundation is solid and I wanted to share it early.
What it does today:
- Full packet layer for the classic UO client (login, movement, items, mobiles)
- Lua scripting for item behaviors (double-click a potion, open a door — all defined in Lua, no C# recompile)
- Spatial world partitioned into sectors with delta sync (only sends packets for new sectors when crossing boundaries)
- Snapshot-based persistence with MessagePack
- Source generators for automatic DI wiring, packet handler registration, and Lua module exposure
- NativeAOT support — the server compiles to a single native binary
- Embedded HTTP admin API + React management UI
- Auto-generated doors from map statics (same algorithm as ModernUO/RunUO)
Tech stack: .NET 10, NativeAOT, NLua, MessagePack, DryIoc, Kestrel
What's missing: Combat, skills, weather integration, NPC AI. This is still early — the focus so far has been on getting the architecture right so adding those systems doesn't require rewiring everything.
Why not just use ModernUO/RunUO? Those are mature and battle-tested. I started this because I wanted to rethink the architecture from scratch: strict network/domain separation, event-driven game loop, no
  inheritance-heavy item hierarchies, and Lua for rapid iteration on game logic without recompiling.
GitHub: https://github.com/moongate-community/moongatev2

value: Show HN: Moongate – Ultima Online server emulator in .NET 10 with Lua scripting

author: squidleon


value: Biki-dev

value:
Hi HN! I'm Biki, the author.
Own-term is a TypeScript framework that lets developers create interactive terminal portfolios, runnable by anyone with Node.js via `npx own-term`.
The idea: instead of a portfolio website, your portfolio is a CLI experience — with commands like `about`, `projects`, `skills`, `contact`. You configure it with a TypeScript config file and can distribute it on npm.
Technically it uses inquirer for the interactive prompts, chalk + gradient-string for terminal colors, and a simple plugin API that lets you register custom commands.
The project is MIT licensed and actively looking for contributors — several good-first-issues are open covering test coverage, live theme switching, and tab completion.
Happy to answer any questions about the architecture or design decisions.

value: Show HN: Own-term – run your developer portfolio in the terminal (npx own-term)

author: Biki-dev


value: jtccc

value:
AI can build products now.
But it still doesn't talk to users.
I built a small MCP server that lets AI agents run real user interviews and return structured insights (themes + quotes).

value: Show HN: Let AI agents run real user interviews

author: jtccc


value: voodoowakanda

value:
I bought the domain swipeforsex.com mostly because I thought the name was funny.
Instead of parking or selling it, I decided to build a small experiment around it: a dating site that removes the usual pretending and focuses on what many dating apps quietly optimize for anyway.
The idea was simple: what happens if you remove the euphemisms and make the intent explicit?
The project is intentionally minimal. I built it quickly just to test whether people would actually use something this direct or if the entire premise would fail.
I'm mostly curious about two things:
1. Whether the blunt positioning changes user behavior compared to typical dating apps.
2. Whether the domain itself drives curiosity traffic.
Would love feedback from HN about the idea, UX, or whether this is a terrible concept.
Happy to answer any technical or product questions.

value: Show HN: Swipeforsex.com – an experiment in honesty in dating apps

author: voodoowakanda


value: johndamaia

value:
As a developer, I always wanted to explore/design a new email experience. Email is one of those tool we check daily but its underlying experience didn’t evolve much. I use Gmail, as probably most of you reading this.
Arc brought taste to browsing the web. Cursor created a new UX with agents ready to work for you in a handy right panel.
So, I tried to bring them all together [0].
I’d genuinely love to hear what you think, especially if you use email for work!
(Note: this is a frontend demo with mock data)
[0] https://demo.define.app

value: Show HN: Define.app – email app for the next generation

author: johndamaia


value:
I built a native macOS fiction writing app that uses AI to understand your
manuscript, not just generate text.
Key features:
- AI entity extraction: reads your prose and proposes structured character
  profiles, location entries, and timeline events
- Continuity checking: catches attribute conflicts, timeline contradictions,
  and dead characters reappearing
- Worldbuilding dashboard: 12 categories with templates (fantasy, sci-fi,
  historical)
- 8-format export: ePUB, PDF, DOCX, Final Draft, Markdown, HTML, RTF,
  Plain Text
- 4 AI providers: OpenAI, Anthropic, Gemini, or local Ollama
Tech stack: SwiftUI, SwiftData, Cloudflare Workers (for the MAS proxy
variant). The Direct variant sends AI requests directly to the provider
using the user's own API keys — I never see their manuscripts.
The AI proposal system uses structured JSON schemas — the LLM returns
typed proposals (character profile, timeline event, relationship, etc.)
that the user can accept into their worldbuilding database. Not just
free-text chat.
Two distribution channels:
- Direct: $79 lifetime (BYOK + Ollama). Pre-sale from $39.
- Mac App Store: Free + optional AI subscriptions through a Cloudflare
  Worker proxy.
Site: https://litestep.com/writers-studio
Happy to talk about the architecture (structured AI proposals, multi-
provider abstraction, StoreKit 2 integration, Cloudflare Worker proxy
design) if anyone's interested.

value: Show HN: Writers Studio – macOS writing app with AI entity extraction


value: shoenot

value:
This is an ncdu clone written in Rust that I figured others might find useful! The main things that differentiate it from ncdu are:
- It's very fast. In my benchmarks it's often twice as fast.
- It allows you to send files to trash rather than permanently delete.<p>Please try it out and lmk if I can improve on anything!

value: Show HN: diskard – A fast TUI disk usage analyzer with trash functionality

author: shoenot


value: jmkni

value: Show HN: De-AI-ifier – Make your AI slop look like it was written by a human

author: jmkni


value: ratwolf

value: Show HN: Hopalong Attractor. An old classic with a new perspective in 3D

author: ratwolf


value: tommywilczek

value:
I'm a solo dev and I built a visual novel-style RPG where you type what you want to do and an AI game master responds in real time. Free alpha, plays in the browser.
What makes it different from AI Dungeon: the AI doesn't just generate text. It emits structured commands that change the music, move NPCs between locations, give/remove items, swap character portraits based on emotional reactions, and trigger cutscenes. Cinematic stills are generated on the fly with Flux 2 Klein 4B, and characters are voiced in real time via Inworld. Separate AI agents maintain a quest journal and write save summaries. The result feels more like a tabletop RPG session than a chatbot conversation.
The world is hand-crafted, not AI-generated. I wrote all the locations, characters, and lore by hand (Himalayan fantasy setting inspired by travel through Nepal and Bhutan). The AI's job is to run the game inside that authored world. Everyone explores the same world, every playthrough is different.
Stack: Godot 4.5 client, FastAPI backend, WebSocket streaming. Some AI calls use Gemini 3.1 Flash Lite, others use Claude Haiku 4.5 (cannot wait for 4.6). Cutscene images generated on the fly with Flux 2 Klein 4B. Voice TTS via Inworld.
Every turn costs real money in AI inference and I'm covering it until the $100 runs out (which will be a while because these models are SO cheap to run). Happy to answer questions about the architecture.

value: Show HN: Voiced, image-based D&D inspired AI-native RPG

author: tommywilczek


value: pivovarit

value:
I love the scriptability of Docker CLI, but for everyday operations (logs, exec, start/stop) it means a lot of repetitive typing and looking up container ids.
That's why I built tdocker, which is supposed to feel like docker ps on steroids, which has just the things you do dozens of times a day.
Would love some feedback, especially on you think is missing (or what I should resist adding)

value: Show HN: A minimalist Docker TUI for everyday stuff

author: pivovarit


value: MattRos

value:
Hi HN, I'm Matt. I've spent over 15 years running an MSP (B-Comp Services) and managing infrastructure. One of the biggest, most persistent headaches my team and I face is tracking exactly what changed in a network config between the time it worked and the time it mysteriously broke.
Most existing solutions we evaluated were heavily bloated, wildly expensive, or required giving a third-party platform "God mode" write access to the crown jewels of the network. That never sat right with me from a security perspective.
I built IronDiff to solve this problem with a strict focus on security and simplicity. It is a SaaS platform designed to provide automated backups and deep analysis of your network configurations without the typical overhead.
Here is what makes it different:
Minimal Access via SSH: I designed IronDiff specifically so the platform doesn't need complex APIs or unrestricted agents. It connects via standard SSH and is strictly programmed to only issue the specific commands required to pull your configurations. It does what it needs to do and stays out of the way, keeping your attack surface as small as possible.
True Visual Diffs: Instead of making you manually compare raw text files in Notepad during a 2 AM outage, IronDiff provides a clean, side-by-side visual comparison of configuration changes over time. You can see exactly which line of code changed on a firewall, router, or switch at a glance.
Automated Backups: No more relying on engineers remembering to manually export configs. IronDiff automates the collection process on a schedule so you always have a reliable, point-in-time recovery option.
Built for Multi-Tenancy: Since I built this to scratch my own itch managing multiple clients, it natively handles multi-tenant MSP and enterprise environments effortlessly.
I'm officially launching it this morning. I would absolutely love to hear your feedback, hear how you handle this problem today, or answer any questions you have about the architecture.
Link: https://irondiff.com

value: Show HN: IronDiff – Network Config Backup and Analysis

author: MattRos


value:
A fun weekend project: https://www.modembin.com
It's a pastebin, except text/files are encoded into .wav files using real FSK modem audio. Image sharing is supported via Slow-Scan Television (SSTV), a method of transmitting images as FM audio originally used by ham radio operators.
Everything runs in the browser with zero audio libraries and the encoding is vanilla TypeScript sine wave math: phase-continuous FSK with proper 8-N-1 framing, fractional bit accumulation for non-integer sample rates, and a quadrature FM discriminator on the decode side (no FFT windowing or Goertzel), The only dependency is lz-string for URL sharing compression.
It supports Bell 103 (300 baud), Bell 202 (1200 baud), V.21, RTTY/Baudot, Caller ID (Bellcore MDMF), DTMF, Blue Box MF tones, and SSTV image encoding. There's also a chat mode where messages are transmitted as actual Bell 103 audio over WebSocket... or use the acoustic mode for speaker-to-mic coupling for in-room local chat.

value: Show HN: Modembin – A pastebin that encodes your text into real FSK modem audio


value: jack-lin

value: Show HN: Squawk – Detect and stop behavioral anti-patterns in AI coding agents

author: jack-lin


value:
I built a GraphQL Federation v2 gateway in pure Go.
What's supported
All core Federation v2 directives work out of the box:
- @key — simple, composite, nested ("coord { lat lng }"), multiple @key per type,
  @key(resolvable: false)
- @external — correct ownership filtering; stub references (e.g. a service that
  declares a type only to satisfy a key) are never mistaken for entity owners
- @requires — chained dependency injection resolved in topological order
- @provides — skips unnecessary _entities fetches when the parent service already
  covers all requested child fields
- @shareable — prefers the parent subgraph to avoid extra entity fetches
- @override — field ownership migration between subgraphs
- @inaccessible — enforced at both schema composition and query validation
- @interfaceObject — interface types as entities with inline fragment resolution
- @composeDirective — custom directive preservation with consistency validation
- @tag, @link
Operations: query and mutation. Independent subgraph fetches run in parallel;
mutations execute sequentially per the GraphQL spec. Partial responses are
supported — a failed subgraph sets that field to null and appends an error, but
execution continues for unaffected fields.
What's intentionally not supported
- Subscription — requires stateful WebSocket connections, which contradicts the
  stateless design. Every request is fully self-contained.
- @authenticated / @requiresScopes / @policy — authorization belongs outside
  the gateway layer.
- @defer / @stream — requires long-lived streaming connections.
- Federated Tracing (ftv1) — Apollo Studio-specific protocol.
- @override(label) — progressive override; planned for a future release.
Performance
Go's http.DefaultTransport caps MaxIdleConnsPerHost at 2, which was a hard
throughput ceiling. The gateway defaults to 32 (configurable via gateway.yaml).
Query plans are cached per query string.

  Go Gateway:    ~4,380 req/s
  Apollo Router: ~2,771 req/s  (concurrency 50, 10k requests, Docker networking)

135+ integration tests across 8 domain scenarios (EC, Fintech, SaaS, Social,
Travel, nested @key, multiple @key, @provides).
GitHub: https://github.com/n9te9/go-graphql-federation-gateway
Happy to hear about Federation v2 edge cases you've hit in production.

value: Show HN: Stateless Go GraphQL Federation Gateway, 1.58x Faster Than ApolloRouter


value: Show HN: ClaudeOS – What if Claude Code managed your operating system?


value: theredsix

value: Show HN: Deterministic browser control for AI agents (~90% on Mind2Web)

author: theredsix


value: Show HN: Agent Toolbox – 13 utility tools as one MCP server and REST API


value: cdknorow

value:
Corral is an open-source orchestration layer that runs multiple AI agents side-by-side in parallel git worktrees, backing them with `tmux`, and tracking the history and context of each session in a local SQLite database.
Instead of losing track of terminal sessions, Corral gives you a unified web dashboard (FastAPI + SQLite WAL) where you can:
- *Track activity live* via pane capture and real-time status pulses.
- *Search your entire session history* (using FTS5) across Claude and Gemini.
- *Auto-summarize* past sessions.
- *Take the helm* (send commands, change modes, or kill a wandering agent directly from the UI).
It’s completely open source and currently supports Claude Code and the Gemini CLI natively (though any agent can be integrated by emitting simple `||PULSE:STATUS||` tokens to stdout).
You can try it out via `pip install agent-corral` or check out the code and the underlying architecture in the repo.
I’d love to hear your thoughts, feedback, or any war stories about dealing with terminal fatigue from running agents! Happy to answer any questions about the implementation.

value: Show HN: Corral – An open-source orchestration layer for AI coding agents

author: cdknorow


value:
I built a backtesting platform where the market simulator runs in the browser using WebAssembly, while trading strategies run locally on your machine.
Running the simulator in the browser keeps the SaaS setup simple (no installation), while still allowing strategies to run in a fully unrestricted local environment.
I started working on this while experimenting with AI coding agents writing trading strategies. Most backtesting platforms execute strategies inside their own infrastructure, which usually means restrictions on compute, libraries, GPUs, or external APIs.
This system separates the simulator and the strategy runtime.
Architecture roughly looks like this:
Browser
↓
WebAssembly market simulator
↓
WebSocket
↓
Local Python strategy
Because strategies run locally, the strategy environment is effectively unrestricted. You can use GPUs, external APIs, local datasets, or basically any Python library.
This setup also works well with AI coding agents (like Claude Code). An agent can write strategies, run backtests, analyze results, and iterate.
The platform also exposes APIs designed for autonomous agent workflows where an AI agent can run strategies, evaluate results, and improve them in a loop.
On the analysis side, positions are traced at the ticket level rather than immediately aggregated, so the lifecycle of each ticket can be inspected in the UI. There are also diagnostics like exit analysis, MFE/MAE statistics, equity curves, and drawdown analysis.
The backend is a lightweight Django service running on AWS.
It's still early and probably rough in places, but curious what people think.
It's currently free during preview while I gather feedback.
App:
https://app.hawk-backtester.com
Python client library:
https://github.com/nima555/hawk-bt

value: Show HN: Market Trade Simulator for AI Agent with No Strategy Restrictions


value: clkao

value:
Agentlore syncs your team's AI coding agent conversations to shared storage, links them to git commits and PRs, and makes them searchable. Built on top of agentsview[0] by Wes McKinney, which indexes local sessions from various coding agents into a SQLite database.
I built this because I wanted to understand my own agent usage patterns. I mostly use Claude Code, and agentsview was already doing the hard work of collecting sessions locally.
Then I wanted to sync sessions across my machines so everything was searchable in one place. When I found interesting new approaches with coding agents (superpowers, gsd, higher-order prompting) that I wanted to share with friends and teammates. I ended up creating gists, which is a terrible way to share conversations.
These clicked together into agentlore. A daemon watches agentsview's local database, masks secrets, and syncs conversations to ClickHouse. A web UI lets you browse, search, and filter across all your sessions.
The part I'm most excited about is git linking. Agentlore parses tool calls for git commit and gh pr create invocations, extracting commit SHAs and PR URLs. So you can go from a commit to the full conversation that produced it. Every conversation gets a shareable permalink, so you can drop it in a PR comment or Slack and people can see exactly what happened.
What I'm hoping to see play out:
- Review agents should get more accurate when they have the conversation context, what was intended and what was manually tested, not just the diff.
- People can learn from each other. Someone figures out a better way to prompt for refactoring, the whole team can see how they did it.
- Context stops disappearing. When you pick up code someone else wrote with an agent, the conversation is right there instead of lost on their machine.
This is early and likely broken in places. Would love feedback.
Demo: https://demo.agentlore.io/sessions/589b7dd5-93ad-4dc0-8e6f-d... (the conversation the built this project. you can see all subagent sessions, but not all commits are captured yet)
[0] https://github.com/wesm/agentsview

value: Show HN: Agentlore – searchable team log for AI coding agent sessions

author: clkao


value:
I'm 15 and built ContextFlow AI — paste any YouTube URL and it generates viral Reddit posts, X threads, and LinkedIn content in seconds.
Tech stack: React 19, FastAPI, Supabase, Groq (Llama 3.3 70B), Stripe.
Free tier available — 5 generations/day. Would love feedback from HN.

value: Show HN: ContextFlow – YouTube videos to viral social content (built by a 15yo)