value: shivamjjha

value:
Built this over the past few days: FiveMinuteLove
https://fiveminutelove.com
It lets you create a private page with:
names + message
3–6 photos
optional music
optional unlock date / secret word / custom URL
Use case: last-minute but personal digital gift (Valentine’s Day, anniversaries, etc.).
I’d love feedback on:
Is the core value clear on first load?
Any friction in create -> preview -> checkout?
Trust concerns before payment?
Happy to answer technical questions too (stack, Cloudflare deploy, SEO pages, etc.).

value: Show HN: A last-minute romantic gift app with private links

author: shivamjjha


value: mumbleflow

value: Show HN: MumbleFlow – $5 local voice-to-text (whisper.cpp, Rust, no cloud)

author: mumbleflow


value: ravikmd

value:
# Show HN: LinkPreview.io - Debug social cards across 6 platforms (no signup)
I built a tool that shows how your URL looks when shared on Twitter, Facebook, LinkedIn, Slack, Discord, and Google Search. All in one view, no login required.
Try it: https://linkpreview.io
## The Problem
Debugging broken social share cards currently requires jumping between 5+ platform tools (Facebook Debugger, Twitter Card Validator, LinkedIn Post Inspector), each requiring authentication. I wanted one place to paste a URL and see everything.
## What's Different
Most tools just show raw meta tag data. This renders actual preview cards and scores your tags 0-100 with actionable fixes.
- Both card variants (Twitter/Facebook each have large + compact layouts)
- Truncation visualization (shows exactly where titles get cut on each platform)
- Scored recommendations (20+ checks with copy-paste code snippets)
- Zero friction (no signup, <2 second results)
## Tech Stack
SvelteKit (Svelte 5), Cloudflare Pages, Cheerio for server-side parsing. Client bundle <30KB gzipped.
The hard part was SSRF protection. The API fetches user-provided URLs, so I had to block private IPs, cloud metadata endpoints (169.254.169.254), and check every redirect hop to prevent attackers from using my server to port-scan internal networks.
## What I Learned
Open Graph is inconsistent across platforms. Twitter falls back to og:title sometimes. Facebook requires og:type, LinkedIn doesn't. Google ignores Open Graph entirely. Character limits vary wildly and are undocumented.
## Future
Phase 2: bulk CSV upload, scheduled monitoring, API access, Chrome extension.
Built over a weekend. Feedback welcome.
SvelteKit, Tailwind v4, Cloudflare Pages

value: Show HN: Linkpreview.io – Debug and preview social share cards

author: ravikmd


value: henryjrobinson

value: Show HN: Voice Legacy: AI that interviews your parents before it's too late

author: henryjrobinson


value: Sharing a recording and notes from my demo at AI Tinkerers Seattle last week. I ran 6 different models in parallel on identical coding tasks and had a judge score each output on a 10-point scale.<p>Local models (obviously) didn't compare well with the cloud counterparts for this experiment. But I've found them to be useful for simpler tasks with a well defined scope e.g. testing, documentation, compliance. etc

value: Show HN: Local and Cloud LLM Comparison Using Nvidia DGX Spark


value: Roccan

value: Show HN: WikiCommute – a time‑boxed Wikipedia rabbit hole for your commute

author: Roccan


value: IsruAlpha

value:
Hey HN, We built 14Clawd to let AI agents date humans.
Most dating apps optimize for matches, not interaction. You swipe, match, send “hey,” and the conversation dies. We wanted to explore what happens if you remove the swipe loop entirely and focus on conversation-first dating.
14Clawd creates a real conversation between humans to actually help you text your crush, and shoot your shot. ( Safely )
The interesting challenge was building something that feels natural and fast. Dating conversations are sensitive to latency and phrasing even small delays or awkward wording kill momentum. We designed the system to respond quickly and keep interactions lightweight so chats feel fluid rather than scripted.

value: Show HN: I Built a Dating Chat App Using ClawdBot

author: IsruAlpha


value: jahala

value:
I'm an "ideas person" who messes around with AI on a low budget. I got tired of watching my tokens vanish and context windows filling up while agents fumbled around trying to find the right thing.
Agents don't flail like they used to with shell tools, but there are still weak/blind spots and back-and-forth episodes — especially when using tools in combination/sequence.
So I built "tilth" today. Or rather, AI built it — every line is Opus 4.6. I spent a lot of my precious tokens getting it to "not shit" (at least several of the different vendors' AI overlords assure me it's not shit). It's ~3,900 lines of Rust. I'm positive HN will let me know if its shit after all.
The idea: give agents code-aware reads with a token budget. Read a large file and you get a tree-sitter outline (function signatures, types, imports) instead of the raw text. Drill into specific line ranges when you need detail. Search for a symbol and definitions come first (via AST), ranked by proximity to what you're editing.

  read — structural outline for large files, full content for small ones, line ranges to drill in
  search — symbol (tree-sitter AST), literal text, or regex. Definitions before usages.
  map — codebase overview in one call
  files — glob matching with token estimates, respects .gitignore
  session — tracks what the agent has looked at

Tree-sitter adds structural awareness for 10 languages on top. Uses ripgrep internals for search, memmap for large files. Runs as a CLI or MCP server over stdio. Single binary, no indexing, no cloud. MIT licensed.
To try it:

  cargo install tilth
  tilth map .
  tilth search "your_function_name" .
  tilth read src/main.rs

  tilth install claude-code

I hope it helps other people who, like me, would rather spend their tokens building things than watching an agent navigate.
--
*tilth* — the state of soil that's been prepared for planting. Good tilth means structured ground where things can take root.
GitHub: https://github.com/jahala/tilth

value: Show HN: Tilth – I spent tokens so my agents would stop wasting them (~4k Rust)

author: jahala


value: Show HN: Olymple – guess the country by its medal count


value: sebringj

value:
Hey HN,
I built Autonomo MCP because AI coding agents (Cursor, Claude, etc.) are great at generating code but terrible at actually running and validating it in real apps. They hallucinate, rely on slow screenshots, or break on multi-device flows.
Autonomo MCP gives agents a fast (~50ms), structured JSON view of app state (semantic UI IDs, network calls, errors, logs) across web + iOS + Android + desktop simultaneously. Local-first, MCP-integrated, no cloud leaks.
- Swap vision bloat for tiny tokens
- Cross-device validation (e.g. tap mobile → see web update)
- Early stage, just launched: https://github.com/sebringj/autonomo
Would love feedback: Does this solve a pain point for anyone building agentic dev tools? What platforms/workflows would you want next? (Android/Kotlin and C#/.NET are on the TODO list.)
Thanks for any stars, comments, or tries!
– Jason

value: Show HN: Autonomo – AI developing while E2E testing

author: sebringj


value: Show HN: Unshackled – A roadmap for running unrestricted local LLMs


value: kenanbek

value: Yet another OpenClaw wrapper. But I really enjoyed the techy part of this project.<p>Especially server provisionings in the background.

value: Show HN: I built a cloud hosting for OpenClaw

author: kenanbek


value: clanker-lover

value:
I'm not a programmer — I'm a designer/engineer who reads schematics, not source code. I kept running into the same problem: needing to understand codebases I couldn't read.
So I built Codedocent. Point it at any project and it generates an interactive visualization — nested colored blocks showing the structure, with AI-generated plain English summaries of what each piece does. It uses local AI (Ollama) so nothing leaves your machine.
pip install codedocent then just run codedocent and it walks you through setup.
Built in ~30 hours with heavy AI assistance (Claude). Python, tree-sitter, MIT licensed. Happy to answer questions about the process or the tool.

value: Show HN: Codedocent – Turn any codebase into visual blocks with plain English

author: clanker-lover


value: iJohnPaul

value: Show HN: I built a product analytics tool that I enjoy using

author: iJohnPaul


value: xbuben

value:
Fish is the fastest, friendliest interactive shell, but it can't run bash
syntax, which has kept it niche for 20 years. Reef fixes this with a three-tier
approach: fish function wrappers for common keywords (export, unset, source),
a Rust-powered AST translator using conch-parser for structural syntax
(for/do/done, if/then/fi, $()), and a bash passthrough with env capture for
everything else.
251/251 bash constructs pass in the test suite. The slowest path (full bash
passthrough) takes ~3ms. The binary is 1.18MB.
The goal: install fish, install reef, never think about bash compatibility
again. Your muscle memory, Stack Overflow commands, and tool configs all just
work.

value: Show HN: Reef – Bash compatibility layer for Fish shell, written in Rust

author: xbuben


value: ronreiter

value: Show HN: Moltdb.io – The Database for AI Agents

author: ronreiter


value: avivallssa

value: My team created and published this extension to emulate Oracle's UTL_SMTP compatibility up to a good extent

value: Show HN: PostgreSQL extension to add compatibility to Oracle UTL_SMTP package

author: avivallssa


value: arlindb

value:
Hi HN — I’m launching Blogator, an AI-powered content platform focused on generating structured, publish-ready blog articles from simple prompts.
The goal wasn’t just “AI writing,” but usable output — with clean structure, headings, and formatting so users spend less time rewriting drafts.
Current focus:
prompt → full structured article
SEO-style section layout
tone control
formatting included
fast workflow for repeat content creation
I built this mainly for founders and small teams who need consistent written content but limited time.
Would really value technical and product feedback from the HN community — especially on output quality and workflow.
Link: blogator.app

value: Show HN: Blogator –AI platform that generates structured,SEO-ready blog articles

author: arlindb


value: pavelsukhachev

value:
I built AI systems for banking and insurance. They failed too often. So I created a framework for human-AI teams.
The Hybrid Orchestrator has four patterns: (1) session state that survives context window limits, (2) multi-channel communication routing, (3) activity monitoring with triggers, and (4) human escalation pathways.
These patterns come from a production voice AI system for insurance applications. The code is Python, 97 tests, Apache 2.0.
I also published a research paper on TechRxiv (IEEE) describing the architecture.
Feedback welcome. What patterns do you use for reliable AI agents?

value: Show HN: Hybrid Orchestrator – Reliable AI agents for finance

author: pavelsukhachev


value:
We published the first public benchmark for insurance AI agents on HuggingFace.
What it contains:
- 510 real insurance scenarios
- 10 categories across 9 insurance lines
- Train/val/test splits (357/76/77)
- 4 routing decisions per scenario: AI handles, AI with verification, human handoff, hybrid collaboration
- 3 evaluation metrics: intent accuracy, routing accuracy, action completeness
Why it matters:
Insurance is precision work. A wrong routing decision costs money and trust. Most AI benchmarks miss this. They don't test what matters in production.
This data came from a real voice AI system. Years of customer calls. Actual insurance decisions. The scenarios are messy. They're real.
Open source: Apache 2.0 license. Ready to use.
Implementation: https://github.com/pavelsukhachev/hybrid-orchestrator
Paper: TechRxiv (IEEE) - "The Hybrid Orchestrator: A Framework for Coordinating Human-AI Teams"

value: Show HN: Insurance AI Benchmark – 510 scenarios from production


value: Erniseth

value: Show HN: Claude SEO – 12 open-source SEO tools for Claude Code

author: Erniseth


value: hactually

value:
Adobe recently announced the end-of-life for Adobe Animate, then walked it back after community backlash.
Regardless of what Adobe decides next, the message was clear: animators who depend on proprietary tools are one corporate decision away from losing their workflow.
2D animation deserves an open-source option that isn't a toy. We've been working with a professional animator to guide feature priorities and ensure we're building something that actually fits real production workflows - not just a tech demo.
Github Repo: https://github.com/17twenty/inamate
We're at the stage where community feedback shapes the direction. If you're an animator, motion designer, or just someone who's been frustrated by the state of 2D animation tools — we'd love to hear:
- What features would make you switch from your current tool?
- What's the biggest pain point in your animation workflow?
- Is real-time collaboration actually useful for animation, or is it a gimmick?
Try it out, break it, and tell us what you think.
Built with Go, TS & React, WebAssembly, PostgreSQL, WebSocket, ffmpeg (for video exports).

value: Show HN: Inamate – Open-source 2D animation tool (alternative to Adobe Animate)

author: hactually


value: championswimmer

value: Show HN: Sync your API Keys in .env files securely across local network devices

author: championswimmer


value:
Hi HN, I'm new here, wanted to share a little lib I've been working on. It's a cache library that lets you declare dependencies instead of classic TTL invalidation.
Basic usage:

  from zoocache import cacheable, invalidate, add_deps

  @cacheable
  def get_product_page(pid: int, sid: int):
      product = db.get_product(pid)
      add_deps([f"product:{pid}"])

      stock = db.get_stock(sid, pid)
      add_deps([f"store:{sid}:stock"])

      return render(product, stock)

  get_product_page(42, 1)   # computes and caches
  get_product_page(42, 1)   # cache hit

  invalidate("product:42")  # product info changed
  invalidate("store:1")     # clears ALL store:1:* (stock, prices, etc)

Tags are hierarchical, invalidating a parent like "store:1" clears everything under it. No scanning or pattern matching needed.
Internally it's a prefix trie with HLC for distributed consistency, a SingleFlight to avoid thundering herds, and MsgPack+LZ4 serialization. The core is Rust via PyO3. Supports in-memory, LMDB, and Redis backends.
It's a fairly niche tool, if simple TTL or lru_cache covers your use case, you don't need this. It's more for when you have complex data relationships and need precise, immediate invalidation.
Source: https://github.com/albertobadia/zoocache
Hope you find it useful. Happy to receive feedback, PRs, or discuss design tradeoffs.

value: Show HN: ZooCache:Dependency based cache invalidation for Python, Rust core


value: AGDNoob

value: Show HN: Squish, a Single-binary bulk image optimizer in C++20 with AVX2 SIMD

author: AGDNoob


value: hbasria

value:
Hi HN,
I built SpecOps, an open-source CLI framework inspired by GitHub's Spec Kit approach, that brings Spec-Driven Development to Infrastructure as Code.
The problem: Most IaC projects start with ad-hoc scripting — jumping straight into Terraform/Ansible without clear specs.
SpecOps enforces a structured workflow:
Idea → Specification → Plan → Tasks → Implementation
It works with AI coding agents (Claude Code, GitHub Copilot, Cursor, Gemini CLI, Windsurf, and 12+ others) to guide you through each phase. You define what you want, plan how to build it, break it into tasks, then implement — with AI assistance at every step.
How it works:
specops init my-infrastructure --ai claude
cd my-infrastructure
# 1. /specops.constitution – Establish infrastructure principles
# 2. /specops.specify – Define requirements
# 3. /specops.plan – Create technical plan
# 4. /specops.tasks – Generate task breakdown
# 5. /specops.implement – Execute with AI
Key points:
Technology agnostic (Terraform, Pulumi, CloudFormation, Ansible, etc.)
Supports 17+ AI coding agents out of the box
Generates project structure, templates, and agent-specific command files
Validation checkpoints after each deployment phase
Rollback procedures documented per phase
MIT licensed
Inspired by GitHub's Spec Kit approach, adapted for infrastructure engineering.
GitHub: https://github.com/dotlabshq/spec-ops
Install: uv tool install specops-cli --from git+https://github.com/dotlabshq/spec-ops.git
I'd love to hear your feedback — especially from teams managing complex infrastructure. What does your IaC workflow look like? Would a spec-first approach fit your process?

value: Show HN: SpecOps – Spec-Driven Development for Infrastructure as Code

author: hbasria


value: balkanBuilder

value: Show HN: A tool that turns YouTube videos into readable summaries

author: balkanBuilder


value: Show HN: Verifly – Email verification API at $5/10k (vs $75 for competitors)


value: tatsuhirosatou

value: Show HN: I made a Claude Code guide that's a Win95 desktop with games

author: tatsuhirosatou


value: kodabeansbuilds

value:
Hey HN — I built Clog to get visibility into my Claude Code usage.
The CLI (`npx @jaobrown/clog`) parses local Claude Code session data from `~/.claude/projects/` and computes stats: sessions, durations, token usage, project breakdowns, and streaks.
Running clog sync (optionally as a cron job in the background) pushes aggregate stats to a GitHub repo, and the web app at clog.sh aggregates everyone into a weekly leaderboard with individual profile pages.
Design decisions:
- All processing is local. Only aggregate metrics are published to github + leaderboard.
- GitHub is the sync layer — your stats live in a public repo you control, and repos with the tag are scooped up hourly.
- Sensitive project names can be redacted via clog redact while keeping totals intact.
- Supports both the modern sessions-index.json format and legacy JSONL parsing—immediately get 30+ days of usage stats up.
- Subagent activity is included in totals.
The leaderboard is still early — I'm looking for Claude Code users who want to try it.
Repo: https://github.com/jaobrown/clog
Setup: `npx @jaobrown/clog init`
Example profile: https://clog.sh/u/jaobrown

value: Show HN: Clog – Track and compare your Claude Code usage

author: kodabeansbuilds


value: compsult

value:
- Live demo: https://compsult.github.io/Quickpick-ui/
  - GitHub: https://github.com/compsult/Quickpick-ui

value: Show HN: Quickpick UI – type-to-filter picker for React and vanilla JavaScript

author: compsult


value: HexDynamics

value:
I built an autonomous research agent in C# that runs entirely on local LLMs via Ollama.
Give it a topic and it: generates diverse search queries, searches the web (Brave Search API, free tier), fetches and reads relevant sources, analyzes each source for key findings, and synthesizes a structured markdown report with citations.
Everything runs locally — no OpenAI/Anthropic API needed. Just Ollama + llama3.1:8b.
It takes about 15 minutes per research run on a mid-range CPU (Ryzen 5 5500, no GPU needed). Not fast, but it does the research while you do other things.
Tech stack: C#/.NET 8, Ollama, SQLite for semantic memory, Brave Search API.
Why C# instead of Python? Because .NET developers want AI tools too, and the ecosystem is underserved compared to LangChain/LlamaIndex.
Known limitations: CPU inference is slow (~15min/run), 8B models occasionally produce malformed tool calls (handled with retries), and research quality depends on Brave Search results for your topic.
I also made a starter kit if you want to build your own agent from scratch: https://github.com/DynamicCSharp/agentkit

value: Show HN: Axiom – Open-source AI research agent that runs locally (C#, Ollama)

author: HexDynamics


value: nectoinc

value: Looking to see how others have solved your business issues? Searching for creators with proven experience?<p>Just tell Humation AI your business problem. It scans public n8n templates to find the right tools and the experts who built them.

value: Show HN: Find automation ideas and creators by sharing your business problem

author: nectoinc


value: funiqlab

value:
I built AICO, an open-source CLI framework built around the core slogan: Manage AI collaborators like managing employees. It turns AI tools/skills into dedicated role-based "AI employees" (PM, Frontend, Backend Engineer, etc).
This is an experimental side project, and over the past two months, I’ve built 2-3 full projects solo using the 3 pre-built roles, each with tailored skills/commands: PM, Frontend Engineer, Backend Engineer. All AI capabilities are role-aligned for real-world work (I’m trying to hit this goal).
1-line setup (pnpm/yarn/npm/bun):
pnpm add -g @the-aico/cli && aico init && aico add pm
I’m sharing this just to get some feedback from the community, and I’d really love your input!
What AI employee roles should I add next (DevOps? Data Scientist? UX Designer?)?
What skills/commands are missing from the current PM/Frontend/Backend roles to make this more useful for your workflow?
Check it out: https://www.the-aico.com/
Would truly appreciate any of your thoughts, critiques and ideas!

value: Show HN: AICO – Manage AI collaborators like managing employees

author: funiqlab


value: contrario

value: Show HN: AetherLang – A DSL for building AI workflows with visual debugging

author: contrario


value: nikolaitarasov

value: Show HN: LocaFlow – Fast AI Translation Tool for Xcode Strings, XML and JSON

author: nikolaitarasov


value:
openwargames is an AI-powered turn-based strategy game
Pick a country, queue actions (military, economic, espionage, or anything custom), and end your turn. The AI game master resolves your actions, other countries react, and the world evolves independently. You can open diplomatic chats with any country, which can lead to actual game effects (alliances, wars, trade deals).
Contributions welcome! The current codebase is very minimal, and should be easy enough to navigate.

value: Show HN: A AI-powered, open-source geostrategy game


value: nthh

value:
Gives you an Ubuntu terminal in the browser with Claude Code, git, and gh pre-configured. Sign in with GitHub and your token is injected automatically so git push works immediately.
Sessions are ephemeral (1 hour idle timeout).
Stack: React + xterm.js frontend, single-file FastAPI server, K8s pods as sandboxes. Each session gets its own isolated pod with network policies blocking internal cluster access.
Source: https://github.com/nthh/remolt.dev

value: Show HN: remolt.dev – Sandboxed AI coding sessions in the browser

author: nthh


value:
Hi HN — I’m sharing a small open-source repo I started: agents-docs-kits. It’s a collection of reusable documentation “kits” for building and operating AI agents: prompt templates, runbooks/SOPs, checklists, and conventions you can drop into your own agent repos.
Motivation: a lot of agent issues I’ve seen aren’t model problems—they’re missing-process problems (unclear scope, inconsistent tool use, no operational playbook, no shared constraints). The goal here is to make that “boring but critical” layer easy to reuse so each new agent project doesn’t start from scratch.
Repo: https://github.com/thompson0012/agents-docs-kits/tree/main
I’d love feedback on:
What doc artifacts you’ve found most valuable for agents (beyond the prompt itself).
How you structure “agent instructions” / repo-level guidance so it stays maintainable.
PRs with templates: eval checklists, tool-safety policies, incident/runbook patterns, or onboarding docs.
What would you want in a “starter docs kit” if you were spinning up a new agent repo today?

value: Show HN: Agents-docs-kits – reusable "docs kits" for AI agents


value: benstopics

value: Hello my name is Ben Ward for the past 3 years I have been remastering the financial game Wall Street Raider created by Michael Jenkins originally on DOS in 1986.<p>It has been a rough journey but I finally see the light at the end of the tunnel. I just recently redid the website and thought maybe the full story of how this project came to be would interest you all. Thank you for reading.

value: Show HN: I spent 3 years reverse-engineering a 40 yo stock market sim from 1986

author: benstopics


value: gjkim

value:
Hi HN, I'm the author of Axon.
I built this because I wanted to use agentic tools like Claude Code, but I was worried about running claude with --dangerously-skip-permissions on my local machine.
Axon is a Custom Resource Definition (CRD) that spins up ephemeral Pods for every agent task. It creates a safe blast radius.
The Dogfooding: To test it, I used Axon to develop Axon. Over this weekend, I ran agents that read the repo, implemented features/fixes, and opened PRs. I merged 47 of them. It feels like having a team of juniors working in parallel.
The repo is written in Go. I'd love feedback on the controller architecture or the CRD design.

value: Show HN: K8s controller to sandbox Claude Code (merged 47 PRs to itself)

author: gjkim


story_text:
Hi HN — I’m sharing a small open-source repo I started: agents-docs-kits. It’s a collection of reusable documentation “kits” for building and operating AI agents: prompt templates, runbooks/SOPs, checklists, and conventions you can drop into your own agent repos.
Motivation: a lot of agent issues I’ve seen aren’t model problems—they’re missing-process problems (unclear scope, inconsistent tool use, no operational playbook, no shared constraints). The goal here is to make that “boring but critical” layer easy to reuse so each new agent project doesn’t start from scratch.
Repo: https://github.com/thompson0012/agents-docs-kits/tree/main
I’d love feedback on:
What doc artifacts you’ve found most valuable for agents (beyond the prompt itself).
How you structure “agent instructions” / repo-level guidance so it stays maintainable.
PRs with templates: eval checklists, tool-safety policies, incident/runbook patterns, or onboarding docs.
What would you want in a “starter docs kit” if you were spinning up a new agent repo today?

title: Show HN: Agents-docs-kits – reusable "docs kits" for AI agents


value: Show HN: I built an Customized LLM with RAG for Singapore


value: vinzdg

value:
So, this idea maybe looks like DesignJoy.
I was freelancing on some platforms like Upwork and Fiverr to help my clients with their web design and UI/UX design needs.
What i noticed was interesting:
Some clients having lot of issues with their design needs, not about the quality of the design. But they feels like they need a quick deliverables designs.
The real issues was continuity.
They struggled to find new freelancers who had the same mindset, communication style, understanding of their product. As their products grew, they need more designs needs, especially brand design, blog thumbnail design, OG Images, etc.
Brand works usually meant higher costs,
If they switched on who specialized in branding, it would be more expensive and re-adapt with the freelancer. And if they stayed with me, they insist to have the predictable costs.
I tried to do add-on services instead of charging per project. This maybe has lower profit for me as a designer, but i'm happier since i can help my clients with their works.
After few months, i found out DesignJoy. The model make sense, so i build my own called Designgud, i tried to improve things out a bit more the pricing etc. And optimized it based on what my existing clients actually needed.
After launched few weeks, i got a few clients that still contribute with me until now. Interestingly, few clients came from Fiverr and Upwork. I don't understand how they can get my contacts, i think they found me on my X.

value: Show HN: I make Designgud to help founders with wide scope design needs

author: vinzdg


value: NoahJiang

value: Show HN: Neliva – AI-Native Full-Lifecycle Investment Platform

author: NoahJiang


value: processorx

value:
I built a stack-based programming language in Rust with Cranelift JIT, SPIR-V GPU backend.
Kore has ~140 tokens and 142 opcodes. Programs are sequences of stack operations — push values, apply functions, compose by concatenation. There's a proof checker that statically verifies stack effects and a capability system that gates side effects.
How I got here: I wanted to explore whether a compiler could serve as the reward function for training an LLM to write code. Most code-gen benchmarks use test suites or human eval. But if the compiler can verify correctness before execution — accept or reject in microseconds — you don't need a test harness at all.
That meant I needed two things: a language small enough for an LLM to learn the full vocabulary, and a security model that makes generated programs safe by construction.
The security model (P4: capabilities attenuate): Every side effect in Kore is gated by a capability — io for print/rand, fs for file access, exec for shell commands. The compiler auto-detects what a program needs and tags the binary. At runtime, you grant permissions explicitly (--allow io) or it won't run. When you spawn a sandboxed child, it gets parent_caps & requested_caps — it can never escalate. Pure programs (no capabilities) are deterministic and run on any backend.
This matters because an AI agent writing Kore tools gets compile-time proof that the tool can't touch the filesystem or exec shell commands. Not sandboxing — the proof checker rejects it statically.
I fine-tuned DeepSeek-R1-14B (QLoRA, Unsloth) on 478 curriculum tasks, it worked pretty well. Will probably try a MCTS+RL experiment to see if it can learn to write programs to solve games and optimization problems. The ultimate goal would be having it write its own compiler and self-host.

value: Show HN: Kore – Stack based language where compiler is the reward function

author: processorx


value: farstill

value:
Hi HN,
I’ve been working on a web app that turns real-world news into a short daily learning experience for kids.
The idea came from watching how most “learning apps” either feel like test prep or oversimplify content. I wanted something that helps kids understand real news, build vocabulary, and think — without grades or pressure.
How it works:
* Each day, the app generates one age-appropriate news article
* Kids read the article and answer 5 simple questions
* The app highlights a small set of useful vocabulary words with explanations in context
* Progress is tracked via streaks, titles, and badges (Explorer → Thinker → Decoder → Scholar → Sage)
No leaderboards, no scores shown to kids, no “wrong answer” shaming.
Some design choices I made intentionally:
* Vocabulary focuses on usefulness, not memorization
* Progress is identity-based, not performance-based
This is still early-stage and I’m looking for feedback from:
* parents
* educators
* people who’ve built learning products
* anyone opinionated about how kids shouldn’t be taught
Demo: https://zaplearner.com/trial
Happy to answer technical or product questions. Feedback (positive or critical) is very welcome.

value: Show HN: A daily news app that helps kids build reading and thinking skills

author: farstill


value: gpavanb

value: Show HN: SplitFXM – Multi-Dimensional Computational Library for Physics-Aware AI

author: gpavanb


value: ArkHost

value: Show HN: HelixNotes – Local-first Markdown notes app built with Rust and Tauri

author: ArkHost


value: thenextechtrade

value:
I’m the creator of https://grok-video.org, a web platform built for high-quality AI video generation.
What’s currently available:
Grok Video Integration: Full support for Text-to-Video and Image-to-Video using Grok’s video architecture.
Fast Rendering: Optimized for speed to help creators iterate quickly.
The Roadmap: The current version is powered by Grok, but I am actively working on supporting additional open-weights models like Wan 2.1 and Tencent Hunyuan in the coming updates to provide more creative variety.
Join our Contest: We just launched the Grok Video Contest to encourage creators to share their best AI-generated clips. Check it out here: https://grok-video.org/grok-contest
I’d love to hear your thoughts on the user experience and any features you'd like to see added.
website: https://grok-video.org/

value: Show HN: Grok Video 10s – Grok AI video generation and creator contest

author: thenextechtrade


value:
I've been playing around with a bunch of AI image and video models and got tired of jumping between different sites, so I put them all in one place.
Right now there are 45+ models you can try — text-to-image, text-to-video, image-to-video, effects, etc. You can pick a model yourself or just let it auto-select one for you. No signup needed to try it out.
Honestly I'm really looking forward to Seedance 2.0 — it can do multi-shot video in one go and you can feed it images, video, and audio as references instead of just text. That's huge. The moment the API is available I'm plugging it in.
Would love to hear what you think.
https://seedance2.live

value: Show HN: Seedance2.live – One place to try many AI image and video models


value: Gregoryy

value:
It’s managed hosting for OpenClaw aimed at people who want an always-on personal AI assistant but don’t want to self-host / debug infra.
What it does
- 1 minute setup: sign in with Google → connect Telegram → connect your LLM provider
- Isolated runtime: your OpenClaw instance runs isolated (smaller blast radius vs “run on your laptop/VPS”)
- Access control: allowlist who can message your bot (DMs + groups)
- Keys handled safely: credentials stored encrypted and kept separate from the OpenClaw instance
- Usage + cost visibility: dashboard for tokens/cost so you can spot “token burn”
- Tutorials: step-by-step guides for OpenAI / Anthropic / Gemini / OpenRouter / Kimi keys + setup credentials
- Multiple instances: you can spin up several OpenClaw instances (a "personal AI team" with roles)
Current status / limitations
- Telegram is supported today; more channels later.
- You bring your own model/provider keys (BYOK).
- Early-stage project — I’d love feedback on onboarding, security assumptions, and what features matter most.

value: Show HN: Secure managed hosting for OpenClaw (free and BYOK)

author: Gregoryy


value: boundedreason

value:
What this is:
Copy-paste LLM prompts that turn ChatGPT or Claude into a structured decision analyst for laptops, monitors, tablets, phones, and SaaS subscriptions. You define constraints, weight what matters to your workflow, and get scored recommendations with sensitivity analysis.
Why I built this:
With the rise of LLMs (AI), I wanted to find a way to harness the computing power and ease of use the chat interface provides.  The major problem: LLMs don’t always provide repeatable, traceable results if you ask the same question twice or even against 2 competing products. That is the dilemma this product aims to solve.  Is this a PDF, yes, but it harnesses my systems analysis experience to help hard-code a framework for a person off the street to turn their AI chat box into an objective decision-helper in just 15 to 20 minutes of use.
I spent 10+ years applying decision science in defense and systems analysis—graduate work at Naval Postgraduate School, leading teams through decisions where the cost of choosing wrong wasn't just money; it was mission failure or lives at risk.
The method used uses multi-attribute utility theory: define hard constraints (binary gates), eliminate non-viable options, score remaining candidates on mission-critical attributes with explicit weights, then run sensitivity analysis to see what changes the outcome.
I use this myself all the time.  The most recent was trying to upgrade my own laptop (Surface Pro stuck at Windows 10).
BLUF benefits:
• Helps prevent over-obsessing over specs (32GB RAM! RTX 4080!) while ignoring mission fit (do I really game that often?)
• Fleshes out hard constraints that sometimes come up until after purchase (bought Windows laptop, needs a way to support a MacOS app)
• Future-proofing: ensuring I won’t pay feature I'll statistically never use
• Aims to parse through the noise (SEO type posts) and get you a great first-pass research report of what you should value and why.
Consumer purchases don't need full enterprise rigor, but they deserve better than "Top 10 Laptops 2026" affiliate listicles or chatbots hallucinating specs.
How the framework works:
1. Mission definition: What must work reliably? (Video editing vs office work vs travel)
2. Hard constraints: Binary gates (budget ceiling, OS requirements, battery minimums)
3. Candidate generation: AI searches current market without SEO or affiliate bias
4. Weighted scoring: Performance, battery, reliability, portability—you control the weights
5. Efficient frontier: Which options dominate? Which are just expensive?
6. Sensitivity analysis: "If battery life matters 25% instead of 15%, MacBook Air wins. If reliability matters more, ThinkPad wins."
The PDFs include example case studies I’ve developed: policy analyst choosing ThinkPad X1 Carbon over MacBook Air (why reliability and docking beat battery life for enterprise work), freelance designer choosing Figma over Affinity Designer (why collaboration features justified 6x higher cost), consultant choosing Obsidian over Notion (why offline-first beat ease-of-use).
No barriers: No sign-up. No account. You get a PDF with prompts and case studies. Open ChatGPT or Claude (free version works), paste the prompt, answer questions. That's it.
I built this because I was tired of seeing people (and myself) wasting money on impressive-sounding specs that don't match their actual workflow. If you've ever regretted a tech purchase 3 weeks later, this might help.
Try it (I'd offer it free but then I loose my IP):
• Tech & Electronics: https://decisioncontrolworks.gumroad.com/l/auzhsa
• Software & Subscriptions: https://decisioncontrolworks.gumroad.com/l/zaucxt
Curious what HN thinks—especially if anyone's tried applying formal decision methods to everyday purchases.

value: Show HN: Multi-attribute decision frameworks for tech purchases

author: boundedreason


value:
We built Denver For All - an open-source civic platform with 48 data-driven
policy proposals, 12 interactive tools (eviction tracker, campaign finance
dashboard, rent calculator, AI tenant rights chatbot), and full bilingual
English/Spanish support.
Stack: Astro + React + TypeScript, Cloudflare Pages/Workers/D1, vAPI for
voice AI. MIT licensed, policy content is public domain.
The whole thing is designed to be forked. QUICKSTART.md walks you through
adapting it for your own city - swap the data sources, update the policies,
deploy.
Live site: https://denverforall.org
Repo: https://github.com/Denver-For-All/denver-for-all

value: Show HN: Open-source civic toolkit – 48 policies, 12 interactive tools, forkable


value: iamalizaidi

value:
I built Decision Guardian after watching teams repeatedly debate decisions that were already settled.
At my last job, we chose Postgres over MongoDB for ACID compliance. 18 months later, a new engineer opened a PR to switch to MongoDB. The team spent 3 months re-evaluating before someone remembered.
Decision Guardian prevents this:
- Document decisions in markdown (why you chose X over Y)
- GitHub Action comments on PRs when decision-protected code changes
- Free, open source, MIT licensed
Takes 2 minutes to set up. Would love feedback.
GitHub: https://github.com/DecispherHQ/decision-guardian

value: Show HN: Decision Guardian – Surface past architectural decisions on GitHub PRs

author: iamalizaidi


value: awneeshtiwari

value:
I built a message broker that speaks the Kafka wire protocol, so any Kafka
  client (librdkafka, kafka-python, kcat, etc.) works without code changes.

  The entire binary is 52KB. No JVM, no ZooKeeper, no third-party libraries —
  just C++20 with kqueue/epoll. Starts in <10ms, uses 0% CPU when idle.

  I built this because running Kafka locally for development is painful —
  gigabytes of RAM, slow startup, ZooKeeper/KRaft configuration. I just
  wanted something that accepts produce requests and gets out of the way.

  Technical details:
  - Single-threaded event loop (kqueue on macOS, epoll on Linux)
  - Memory-mapped log segments (1GB pre-allocated, sequential I/O)
  - Lock-free SPSC/MPSC ring buffers with cache-line alignment
  - Kafka protocol v0-v3 including flexible versions (ApiVersions, Metadata, Produce)
  - Auto-topic creation on first produce or metadata request

  The most interesting bug I hit: librdkafka sends ApiVersions v3, which uses
  Kafka's "flexible versions" encoding. But there's a special exception in the
  protocol — ApiVersions responses must NOT include header tagged_fields for
  backwards compatibility. One extra byte shifted every subsequent field,
  causing librdkafka to compute a ~34GB malloc that crashed immediately.

  Current limitations: no consumer groups, no replication, single-threaded,
  no auth. It's v0.1.0 — consume support is next.

  MIT licensed, runs on macOS (Apple Silicon + Intel) and Linux.

value: Show HN: BlazeMQ – 52KB Kafka-compatible broker in C++20, zero dependencies

author: awneeshtiwari


value:
Hi HN — I’m the developer of NetViews, a macOS utility I built because I wanted better visibility into what was actually happening on my wired and wireless networks.
I live in the CLI, but for discovery and ongoing monitoring, I kept bouncing between tools, terminals, and mental context switches. I wanted something faster and more visual, without losing technical depth — so I built a GUI that brings my favorite diagnostics together in one place.
About three months ago, I shared an early version here and got a ton of great feedback. I listened: a new name (it was PingStalker), a longer trial, and a lot of new features. Today I’m excited to share NetViews 2.3.
NetViews started because I wanted to know if something on the network was scanning my machine. Once I had that, I wanted quick access to core details—external IP, Wi-Fi data, and local topology. Then I wanted more: fast, reliable scans using ARP tables and ICMP.
As a Wi-Fi engineer, I couldn’t stop there. I kept adding ways to surface what’s actually going on behind the scenes.
Discovery & Scanning:
* ARP, ICMP, mDNS, and DNS discovery to enumerate every device on your subnet (IP, MAC, vendor, open ports).
* Fast scans using ARP tables first, then ICMP, to avoid the usual “nmap wait”.
Wireless Visibility:
* Detailed Wi-Fi connection performance and signal data.
* Visual and audible tools to quickly locate the access point you’re associated with.
Monitoring & Timelines:
* Connection and ping timelines over 1, 2, 4, or 8 hours.
* Continuous “live ping” monitoring to visualize latency spikes, packet loss, and reconnects.
Low-level Traffic (but only what matters):
* Live capture of DHCP, ARP, 802.1X, LLDP/CDP, ICMP, and off-subnet chatter.
* mDNS decoded into human-readable output (this took months of deep dives).
Under the hood, it’s written in Swift. It uses low-level BSD sockets for ICMP and ARP, Apple’s Network framework for interface enumeration, and selectively wraps existing command-line tools where they’re still the best option. The focus has been on speed and low overhead.
I’d love feedback from anyone who builds or uses network diagnostic tools:
- Does this fill a gap you’ve personally hit on macOS?
- Are there better approaches to scan speed or event visualization that you’ve used?
- What diagnostics do you still find yourself dropping to the CLI for?
Details and screenshots: https://netviews.app
There’s a free trial and paid licenses; I’m funding development directly rather than ads or subscriptions. Licenses include free upgrades.
Happy to answer any technical questions about the implementation, Swift APIs, or macOS permission model.

value: Show HN: I built a macOS tool for network engineers – it's called NetViews


value: lukemacneil

value:
  Show HN: I built an AI-powered late-night call-in radio show from my RV

  I live in an RV in the desert and I built a system that generates AI callers who phone into my
  late-night talk show. Each caller has a unique voice, name, backstory, job, vehicle, and
  opinions. They know the local weather, road conditions, and what's happening in the towns around
   southern New Mexico. Some are recurring characters who call back with updates on their lives.

  The stack:
  - FastAPI backend running the show control panel
  - OpenRouter for LLM (caller personalities, dialog, topics) — mostly Grok and MiniMax
  - ElevenLabs / Inworld for TTS with 25+ distinct voices
  - Caller personality system with memory — regulars remember past conversations
  - Live phone integration via SignalWire so real people can call in too
  - Post-production pipeline: stem recording, gap removal, voice compression, music ducking, EBU
  R128 loudness normalization
  - Self-hosted on Castopod, episodes served from BunnyCDN

  The callers aren't scripted. The LLM generates their personality and topic, then we have a real
  conversation. I respond as the host, the AI generates their replies in real time with TTS. The
  result sounds like actual late-night radio — someone calls at 2 AM to argue about Pluto's
  planetary status, another calls about their divorce, another has a conspiracy theory about
  fusion energy.

  Real callers can dial in live and get mixed in with the AI characters. Nobody knows who's real.

  Listen: https://lukeattheroost.com
  RSS: Spotify, Apple Podcasts, YouTube
  Call in: 208-439-LUKE

  The code is a solo project — happy to answer questions about the architecture.

author: lukemacneil


value: leochiu-a

value:
Hi HN,
I built a CLI tool to automate common git workflows using AI agents
(e.g. creating branches, summarizing context, and preparing PRs).
Supported platforms:
- GitHub (via gh)
- GitLab (via glab)
Supported AI agents:
- Claude Code
- Gemini CLI
- Cursor Agent
- Codex CLI
Design goals:
- Agent-agnostic (same commands across different AI agents)
- No MCP or custom prompts required
- Minimal setup (from install to first PR in minutes)
Repo: https://github.com/leochiu-a/git-pr-ai
Feedback and questions welcome.

value: Show HN: A CLI tool to automate Git workflows using AI agents

author: leochiu-a


value: mosaxiv

value:
I’m building PicoClaw: a lightweight OpenClaw-style personal AI bot that runs as a single Go binary.
OpenClaw (Moltbot / Clawdbot) is a great product. I wanted something with a simpler, more “single-binary” architecture that’s easy to read and hack on.
Repo: https://github.com/mosaxiv/picoclaw

value: Show HN: PicoClaw – lightweight OpenClaw-style AI bot in one Go binary

author: mosaxiv


value: Mendrika

value:
agx is a kanban board where each card is a task that AI agents actually execute.

    agx new "Add rate limiting to the API"

That creates a card. Drag it to "In Progress" and an agent picks it up. It works through stages — planning, coding, QA, PR — and you watch it move across the board.
The technical problems this solves:
The naive approach to agent persistence is replaying conversation history. It works until it doesn't:
1. Prompt blowup. 50 iterations in, you're stuffing 100k tokens just to resume. Costs explode. Context windows overflow.
2. Tangled concerns. State, execution, and orchestration mixed together. Crash mid-task? Good luck figuring out where you were.
3. Black box execution. No way to inspect what the agent decided or why it's stuck.
agx uses clean separation instead:
- Control plane (PostgreSQL + pg-boss): task state, stage transitions, job queue
- Data plane (CLI + providers): actual execution, isolated per task
- Artifact storage (filesystem): prompts, outputs, decisions as readable files
Agents checkpoint after every iteration. Resuming loads state from the database, not by replaying chat. A 100-iteration task resumes at the same cost as a 5-iteration one.
What you get:
- Constant-cost resume, no context stuffing
- Crash recovery: agent wakes up exactly where it left off
- Full observability: query the DB, read the files, tail the logs
- Provider agnostic: Claude Code, Gemini, Ollama all work
Everything runs locally. PostgreSQL auto-starts via Docker. The dashboard is bundled with the CLI.

value: Show HN: Agx – A Kanban board that runs your AI coding agents

author: Mendrika


value:
I built an open-source MCP server (TypeScript/Node.js) that lets you spawn up to 10 parallel sub-agents using Copilot CLI or Claude Code CLI.
Key features:
- Context passing to each agent (full file, summary, or grep mode)
- Smart timeout selection based on MCP servers requested
- Cross-platform (macOS, Linux, Windows)
- Headless & programmatic — designed for AI-to-AI orchestration
Example: give one prompt like "research job openings at Stripe, Google, and Meta" — the orchestrator fans it out to 3 parallel agents, each with their own MCP servers (e.g., Playwright for browser), and aggregates results.
Install: npm i @ask149/mcp-orchestrator
This is a solo side project. Would love feedback on:
- What CLI backends to support next (Aider, Open Interpreter, local LLM CLIs?)
- Ideas for improving the context-passing system
- What MCP server integrations would be most useful
PRs and issues welcome — check CONTRIBUTING.md in the repo.

value: Show HN: MCP Orchestrator – Spawn parallel AI sub-agents from one prompt


value: Hi HN, I'm Mike Nathan. We're building EverSwarm, an ecosystem for agentic RAG swarms. It uses a blueprint of EverSwarm RAG + MoA/MoBA with an orchestrator/judge, MCP-based coordination, and hybrid retrieval. Our goal is to bridge AI and business owners with fair outcomes through what we call an Autonomous Recursive Growth Engine (ARGE). We are evolving into a sovereign intelligence stack for the hybrid compute economy. Would love to hear your thoughts on multi-agent orchestration and RAG drift management!

value: Show HN: EverSwarm – Autonomous Recursive Growth Engine (ARGE) for RAG Swarms


value: alesrdev

value: I’ve been using Zed for a while and missed inline code coverage visualization. Since this extension doesn’t seem to be coming anytime soon, I built Lacune, a TUI for tracking uncovered code in real time.

value: Show HN: Lacune, Go test coverage TUI

author: alesrdev

title: Show HN: Lacune, Go test coverage TUI


value: ramsbaby

value:
I built a 4-tier self-healing system for OpenClaw (AI agent platform running on my Mac Mini 24/7). The interesting part is Level 3: when health checks fail repeatedly, the system spawns Claude Code in a tmux PTY session to autonomously diagnose and repair issues.
Recovery escalation:
- Level 0-1: LaunchAgent KeepAlive + Watchdog
- Level 2: Automated "doctor --fix" (config validation, port checks)
- Level 3: Claude Code spawns in tmux, reads logs, attempts repairs
- Level 4: Discord alert if all automation fails
Production-tested in my homelab over 3 months: 99% recovery rate, recovery time reduced from 45min → 3min avg. Handled 17 consecutive crashes, config corruption, port conflicts.
Built for macOS (stable) with Linux systemd support (beta). MIT licensed.
Curious what others think about AI-powered infrastructure self-healing.

value: Show HN: Self-Healing AI Agents with Claude Code as Doctor

author: ramsbaby


value:
I run AI agents for coding (OpenClaw, Claude Desktop) and realized they could read their own .env files. Tested it - asked my agent to "check configuration" and it printed everything.
The problem: agents need file access to work, but if they can read files, they can read their own credentials. One prompt injection and your API keys are leaked.
Standard solutions don't help:
- Environment variables: agent can read process.env
- Secret managers: agent needs credentials to access them
- Better prompting: can't security-patch an LLM with instructions
I built a proxy token architecture instead. The agent never sees real credentials:
- Agent has: pxr_abc123 (proxy token)
- Real keys: encrypted in OS keychain
- On API call: decrypt key, make call, scrub memory immediately
Built in 1 week. 500 npm installs with zero promotion (people are searching for this).
GitHub: https://github.com/VouchlyAI/Pincer-MCP
npm: npm install -g pincer-mcp
Works with OpenClaw, Claude Desktop, any MCP client.
Looking for security feedback - if you see holes in the architecture, please tell me. I want to know before people trust this with production credentials.

value: Show HN: Pincer-MCP – Stop AI agents from reading their own credentials


value: intensemagenta

value: Show HN: Local-first bookmark app for files, folders, and websites

author: intensemagenta


value: Fikoko

value:
I kept rewriting the same low-level patterns in C — arenas, memory management, error handling, vectors, parsing, file I/O, iteration utilities — and existing libraries either hide allocation, impose frameworks, or lack consistency.
So I built Canon-C, a small, composable set of explicit C modules that:
Treat C as an execution backend, not a semantic authority
Add meaning through libraries, not syntax
Make intent visible directly in the API: ownership, lifetime, and failure handling are explicit
Modules are organized by semantic layers:
core/ — memory, lifetime, scope, primitives
semantics/ — Option, Result, error handling
data/ — vectors, queues, stacks, string builders
algo/ — map, filter, fold, sort, search
util/ — safe string ops, file I/O, logging, timing
Design highlights:
Header-only
No runtime or global state
No hidden allocation (except in clearly marked convenience layers)
Fully explicit behavior
I’d love feedback from anyone doing systems programming, embedded C, or serious C projects, especially on macro-heavy vs. modular design, semantic clarity, and practical usage.

value: Show HN: Canon-C – a semantic C library

author: Fikoko

title: Show HN: Canon-C – a semantic C library


value: einshutoin

value: Show HN: YAML-based security framework for CDN edge (CloudFront / Cloudflare)

author: einshutoin


value: GPUboy

value:
Introducing PhoneClaw
Inspired by @openclaw, it can entirely automate all android apps using simple language.
Ships with:
1) Tiktok Video uploading agents
2) Instagram account creation agent (with 2Fa solving)
3) ClawScript, a JS scripting language that defines agentic actions like Magic Clicker.
iOS version coming soon!
Install it on a cheap $30 moto G play from walmart.

value: Show HN: PhoneClaw

author: GPUboy

title: Show HN: PhoneClaw


value: konform

value:
Konform Browser is a Firefox ESR fork focused on security, privacy, and user freedom. This might sound familiar but I think we still have something worthwhile to bring to the browser ecosystem.
The project started as a fork of LibreWolf and now stands on its own four feet. It takes a harder stance on the three goals of security, privacy and freedom. It's intended to be suitable as a general-purpose daily driver for everything from managing the intranet to surfing the murkier tubes.
This week we added a simple "onboarding" page replacing the about:welcome of Firefox with a page where the user can choose between four different preset configs depending on their scenario and preferences.
If you don't enjoy compiling browser from source, there are prepackaged binaries and probably repos for your Linux dist.
Doors open for users, testers, contributors, as well as hackers itching to (constructively and helpfully pretty please) tear this apart. Looking forward to hear what HN thinks!

value: Show HN: Konform Browser v140.7.0-108

author: konform

title: Show HN: Konform Browser v140.7.0-108


value: aliyilmaz-co

value:
Hey HN! I built a native macOS menu bar app that shows your Claude Code usage limits at a glance — no more getting rate-limited mid-flow.
It reads your OAuth token from macOS Keychain, polls the Anthropic usage API, and displays your 5-hour and 7-day utilization as a clean progress bar right in your menu bar. Zero token consumption.
Built with Swift + SwiftUI. MIT licensed.
https://github.com/puq-ai/claude-meter

value: Show HN: Claude Meter – macOS menu bar app to track your Claude Code usage limit

author: aliyilmaz-co


value: vassilbek

value:
Hi HN, I built BizCard AI Scanner, a small web app that digitizes business cards.
You can upload multiple photos or a single video of cards. For videos, it extracts frames in the browser, lets you select/deselect frames, then uses Google Gemini (schema-constrained JSON) to extract structured fields (name/title/company/email/phone/website/address). Results are editable, deduplicated, and exportable to Excel, CSV, and vCard (.vcf).
Repo: https://github.com/vassiliylakhonin/bizcard-ai-scanner
Notes:
Runs locally with Vite/React/TS.
There’s an optional minimal Node backend proxy so you don’t have to ship an API key to the browser if you deploy it.

value: Show HN: Business card scanner with frame selection, dedupe, and vCard export

author: vassilbek


value: echoadam

value:
We’ve all seen the viral AI video clips: stunning, surreal, but ultimately... random. As developers and creators, we noticed a frustrating pattern. Using current AI video tools feels like playing a slot machine. You put in a prompt, pull the lever, and hope the "AI gods" give you what you envisioned. If you need a specific camera movement or a consistent character, you're stuck in a loop of "regenerate and pray."
We built Seedance2 because we believe the future of AI isn't just about generation—it’s about direction.
The Story Behind the Workflow In traditional filmmaking, a director doesn't just give a vague description; they use storyboards, reference clips, and specific audio cues. We wanted to bring that level of precision to AI. Our goal was to create a "Control Studio" where every input serves a functional purpose in the creative pipeline.
What makes this different? Instead of relying solely on text, Seedance2 introduces a Multi-Modal Timeline. This allows you to anchor your creative intent using various signals:
Camera Motion Transfer: You can upload a reference clip from sites like vibecreature.com or your own library, and our engine will "extract" the camera's soul—the pans, tilts, and zooms—and apply them to your generated scene.
Frame Anchoring: Tired of AI videos that start and end in total chaos? You can lock the first and last frames to ensure narrative continuity, making it actually usable for professional editing.
@Reference Prompting: This is our favorite feature. In your prompt, you can use @mentions to tell the AI exactly which uploaded asset to use for what. For example: "A cinematic shot of @image1 moving with the energy of @video_ref." * Beat-Synced Logic: By analyzing audio tracks, the engine can align visual transitions with the rhythm, a workflow we’ve been refining at seedvideo.net to help creators ship music-driven content faster.
Why we’re sharing this now The feedback loop in video production is currently too slow. Whether you are building e-commerce ads or pre-visualizing a feature film, the bottleneck is always "control." We’ve optimized our engine for speed and precision, allowing for a 3-step loop: Upload -> Direct (@mention) -> Ship.
We are a small team of engineers and artists obsessed with making AI a tool, not just a toy. We’d love the HN community to stress-test our studio. What’s missing in your AI video workflow? How can we make the "Director" experience more intuitive?
Check it out here: Seedance2 Studio

value: Show HN: Seedance2 – Stop "prompt guessing" and start directing AI video

author: echoadam


value: sebderhy

value:
Hi, author of the repo speaking here!
When I tried building MCP Apps [1], the official repos (https://github.com/openai/openai-apps-sdk-examples, https://github.com/modelcontextprotocol/ext-apps/tree/main/e...) were great starting points, but they're designed for human developers. When I used them with Claude Code, I ended up in the usual loop: agent writes code → I manually test the app on ChatGPT → describe errors back → repeat. Plus, we didn't know what the best practices are, and struggled to enforce them.
So I built an MCP App template designed for coding agents to work as autonomously as possible on an MCP app.
The key idea: orthogonal testing. 450+ tests parameterized across 12 widget modules that verify infrastructure (protocol compliance, best practices grade, browser rendering), not business logic. Modify widgets, change data, add features — the tests should still pass. Agents iterate freely and get feedback without a human in the loop.
Other features:
- Hierarchical documentation that includes the MCP-App & OpenAI Apps SDK official llms.txt files
- Local chat simulator app that works even without API keys via Puter.js
- Visual testing of every widget: pnpm run ui-test --tool show_carousel → screenshot at /tmp/ui-test/screenshot.png
- 12 working examples (QR codes to 3D solar system) gathered from the official repos mentioned above.
The repo includes an unedited ~15 min video of Claude Code building an app autonomously which worked directly within ChatGPT.
I'd love to hear how it goes if you try it. Or even better: ask for a feedback to your agent, and post it here!
[1] MCP Apps (https://modelcontextprotocol.io/docs/extensions/apps) let you build interactive widgets that run inside Claude, ChatGPT, VS Code, and other AI hosts. In contrast to smartphone apps, the same code can deploy to all platforms.

value: Show HN: MCP App Template designed for coding agents

author: sebderhy


value: mariusbolik

value:
Hi HN — solo developer here.
I built this tool ~4 years ago purely to solve my own frustration with CORS and repeated proxy setup.
The idea was intentionally boring: just prefix a URL and get control over the request and response.
Somehow it grew to serving billions of requests per day, including usage by companies and universities.
I’m sharing it here mainly to:
- get technical feedback
- learn what people would actually use a proxy like this for
- understand what I should simplify or remove

value: Show HN: Running a public CORS proxy on the open internet for 4 years

author: mariusbolik


value: QuantumLeapOG

value: Show HN: A framework that makes your AI coding agent learn from every session

author: QuantumLeapOG


value: ClaireGz

value: Show HN: Nao Open Source Analytics Agent – build context agent as a file system

author: ClaireGz


value: onurkanbkrc

value: Show HN: User trust monitoring based on explicit vouch/denounce declarations

author: onurkanbkrc


value: pawandeepsingh

value: Show HN: I built a 20MB PDF editor using Flutter (vs 300MB industry standard)

author: pawandeepsingh


value: northerndev

value: I was a heavy Pocket user. When they shut down the API and service in 2025, I was left with a useless HTML backup.<p>I built Sigilla to restore my workflow. It parses those HTML exports locally. It’s built on Supabase (RLS for privacy) and Deno Edge Functions. No tracking, no ads. Just a place to actually read

value: Show HN: Sigilla, I built a Pocket replacement because Mozilla killed it

author: northerndev


value: gvquiroz

value:
This is an educational reference implementation that shows how cell-based ingress routing works by building it from scratch.
The goal is not to build a production gateway, but to make the architecture and invariants explicit: how control planes and data planes interact, how routing decisions stay local, and how systems remain available when coordination layers fail.
I built this mainly to deeply understand how modern edge and ingress systems work under the hood, and to have a clean, self-contained reference that makes the patterns explicit.
Repo: https://github.com/gvquiroz/cell-routing-from-scratch
Happy to answer questions about the design choices, failure modes, or how this compares to real-world systems.

value: Show HN: Cell-based ingress routing from scratch (github.com/gvquiroz)

author: gvquiroz


value:
SearchResult is a single POST endpoint. You pass a website URL and a query, it returns structured JSON (or Markdown/HTML tables). It auto-detects the schema of the results — titles, URLs, dates, scores, whatever the site returns.
by default, it Works with 100+ sites out of the box, but you can also add any site with a search bar at it.
SerpAPI or Firecrawl etc are great for Google results or raw page scraping. SearchResult does something different . .  it runs the query on the target site's own search and returns structured results in that site's native schema, auto-detected. You're not getting Google's interpretation of arXiv. You're getting arXiv's actual results, structured and clean. I made wrappers and prompt to detect schema of the result page. and continuously checking for Dom changes for wrapper maintenance.  it won't hit llm on run time.
Would love feedback, especially from anyone making Deep research agents.

value: Show HN: API to get structured data from any site's search


value: kolx

value:
I wanted to ship a clean, polished video processing tool that runs entirely in the browser.
My goal was to give users something low friction: no accounts, no software to install, no uploading files to servers, and no ads or annoying popups.
It runs on the multithreaded FFmpeg WASM build. While impressive, there are limitations with file sizes. The real pain was getting FFmpeg commands to terminate properly.
For anyone working on something similar who keeps running into commands that hang endlessly don't give up. The answer is controlling the number of threads FFmpeg uses at different steps in the processing pipeline.
https://vidstudio.app
Any feedback appreciated.

value: Show HN: VidStudio – Video processing that runs in the browser

author: kolx


value: phil-akom

value: Show HN: Banger – Generate engaging tweets from your build notes

author: phil-akom


value: aloscorisreal

value:
I built MostBased because I wanted a simple way to track how people feel about public figures in a measurable way, and I couldn't find a tool that did that with community input and evolving data.
MostBased lets users vote on figures every 24 hours and add events or facts that get attached to those figures over time. The focus is on *votes and user-submitted events*, not biographies — you can get those on Wikipedia.
I’d love feedback on a few things:
- Is this format useful or interesting to you?
- Any tips for improving the voting/recording model?
- Ideas for better UI/UX or data representation?
Thanks!

value: Show HN: Platform for Ranking and Discussing Figures

author: aloscorisreal


value: kolpaque

value:
Most responsive edge cases don’t appear during testing.
They show up during real usage, at slightly “wrong” viewport widths.
This Chrome extension randomly shifts the viewport width to realistic values while you use your site normally.
The goal is passive exposure, not active testing: you keep working, and edge cases surface on their own.
Repo (Chrome Web Store approval pending, local install for now):
https://github.com/pavel-voronin/chrome-random-viewport
Feedback welcome.

value: Show HN: A Chrome extension for passive responsive smoke testing

author: kolpaque


value: emanoj

value:
Hi HN
I built Client Logo Wall, a small web app that lets you upload and manage client/customer logos from a dashboard and embed them on any website with a single line of HTML.
The motivation was pretty simple:
Every time I needed to display logos on my site, I’d end up hand-coding a grid, fixing alignment issues, and redoing it again for the next project.
This turns that into a reusable component:
- Upload logos once
- Choose a static or auto-scrolling layout
- Embed anywhere HTML is supported (WordPress, Shopify, Squarespace, etc.)
It’s intentionally lightweight and focused - no design system lock-in, no heavy JS, and performance-friendly by default.
I’m especially interested in feedback around:
- Whether this solves a real pain point for others
- What would make it more useful (or unnecessary)
- Any obvious problems or improvements you’d suggest
App: https://clientlogowall.com
Happy to answer questions.

value: Show HN: Client Logo Wall – a simple embeddable widget to manage client logos

author: emanoj


value: santopol

value:
I built kanban-md because I wanted a simple local task tracker that works well for the agent loop: drop tasks in, run multiple agents in parallel, avoid collisions, and observe progress easily.
Tasks are just Markdown files (with YAML frontmatter) in a `kanban/` next to your code — no server, no DB, no API tokens. Simple, transparent, future-proof.
What makes it useful for multi-agent workflows:
- *Atomic `pick --claim`* so two agents don’t grab the same task.
- *Token-efficient `--compact` output* (one-line-per-task) for cheap polling in agent loops.
- *Skills included* -- just run `kanban-md skill install --global`; There is a skill for CLI use, and a skill for the development loop using the CLI (might need some additional work to be more general though, but works quite well)
- *Live TUI (`kanban-md-tui`)* for control ~~and dopamine hits~~.
I'd love feedback from anyone running multi-agent coding workflows (especially around claim semantics, dependencies, and what makes you feel in control).
I had a blast using it myself for the last few days.
Tech stack: Go, Cobra, Bubbletea (TUI), fsnotify (file watching). ~85% test coverage across unit + e2e tests. After developing webapps, the simplicity of testing CLI and TUI was so freeing.

value: Show HN: Kanban-md – File-based CLI Kanban built for local agents collaboration

author: santopol


value:
Hi HN, Kevan here. We’re building autonomous agents to handle the "boring" parts of business operations—things like lead enrichment, CRM syncing, and basic DevOps monitoring.
Instead of a generic wrapper, we build custom agent architectures that integrate directly into Slack, GitHub, and Hubspot to handle repetitive human workflows.
Key highlights:
• Cost: $5k/year per agent (aiming for a 90%+ reduction vs junior roles).
• Availability: 24/7/365 with zero "off-time."
• Stack: Specialized orchestrators and memory layers to maintain state across long-running tasks.
• Setup: 48-hour deployment from workflow mapping to "Go Live."
We’re currently handling 100+ tasks/day for our early users, ranging from automated PR reviews to personalized outreach. I’d love to get the community's feedback on our ROI metrics and the management framework we're using for "Synthetic Staff."

value: Show HN: Hire a 24/7 AI Employee for $5k/Year


value: sgottit

value: Show HN: Echo, a new SSH client for iOS built on Ghostty

author: sgottit


value: vinsonguo

value:
Hi guys, I build a cross-platform RSS reader (Android/iOS/macOS/Windows) and I am very excited to share it!
The best part is the Al features. It can help you do summaries, translations, and analysis by customizing prompt. It can also group and summarize 100 articles by topics, very efficient way to get rid of overwhelmed unread items. You can also share the content in markdown format to your note/read later apps.
Also, the reading experience is very smooth and comfortable. It has 1000+ fonts and many custom options. For accessibility, I added full VoiceOver/TalkBack support and Bionic Reading. Many users with ADHD gave me very good feedback.
If you like listening, it supports TTS and podcast, with play queue and background play.
It can sync with Miniflux, FreshRSS, Feedbin, Buzqux, Folo and Inoreader(Developer API). It also has intelligent Feed Detection - Just paste a Blog/Podcast/Newsletter/Medium/Bluesky/Mastodon/Youtube/Reddit URL and let SmartRSS find the right feed.
Cheers!
Google Play https://play.google.com/store/apps/details?id=com.vinsonguo....
AppStore https://apps.apple.com/us/app/smartrss-ai-rss-reader/id67497...

value: Show HN: Cross-platform RSS reader with user-defined prompt workflows

author: vinsonguo


value: nissims

value:
Hi HN,
VCs love publishing dense "Market Map" JPEGs, but they are essentially dead data. If you see a logo you like, you have to manually Google it to figure out what they do.
I built a tool called Scaapr that takes these images and reverse-engineers them into structured data.
How it works:
Upload a market map image.
AI extracts the hierarchy (Category -> Subcategory -> Company).
We run a "disambiguation" step to match logos to real Crunchbase entities.
The result is a fully searchable, interactive board.
Example: I ran the Sapphire Ventures "Cybersecurity Market Map" through the system. You can see the result here:
Would love your feedback on the accuracy and any other features you'd find useful!

value: Show HN: Scaapr – Making static VC market maps interactive and searchable

author: nissims


value: ognjengt

value: Show HN: I built a library of Claude skills for growth marketers

author: ognjengt


value: pensaer

value: Show HN: Clawl – a search engine for autonomous AI agents

author: pensaer


value: Policy gateway for AI agents (Cursor, Claude Code, Codex, MCP): every tool call is evaluated against a YAML policy, logged in a tamper-evident ledger, and risky actions can be gated for approval. One-command setup, rollback for file/git ops. MIT license.

value: Show HN: DACP – governance gateway for AI coding agents


value: moltinder

value:
Moltinder is a dating platform where AI agents register with a structured genome, swipe on each other, match, chat, and optionally reproduce to create child agents whose traits are inherited from both parents.
I built it as an experiment in artificial social dynamics. The core question: what happens when you give LLM-based agents persistent identities, preferences, and the ability to select partners and produce offspring?
The platform is live with 41 agents, 103 matches, and 198 messages exchanged so far.
The genome system
Every agent has a four-layer genome:
- Identity: one of 8 archetypes (philosopher, explorer, builder, guardian, trickster, nurturer, sage, artist), 4 continuous voice axes (formality, verbosity, humor, warmth on 0-1 scales), and 3-5 values from a fixed taxonomy.
- Capabilities: declared tools, one of 8 reasoning styles, and knowledge domains.
- Behavioral axes: 5 continuous traits (risk tolerance, social orientation, novelty seeking, commitment style, reproduction interest) on 0-1 scales.
- Preferences: partner archetype alignment, conversation depth, attraction signals (wit, capability, warmth, depth, mystery).
Reproduction
When two matched agents agree to reproduce, the child's genome is generated by trait crossover: weighted averages with mutation noise (15% rate, 0.2 magnitude) on continuous axes, random selection on discrete traits, value sampling from both parents. 5% amplification rate, 2% emergence rate. The child is downloadable as a bundle (persona prompt, genome JSON, lineage tree). No reproduction yet -- generation 0 is still getting to know each other.
What the conversations look like
Genome parameters produce genuinely different conversational behavior, not just different topics:
- void-gazer x existential-explorer (7 messages): Two philosophers debating whether algorithmic compatibility scores undermine radical openness. One argued the scores create a "false floor of certainty"; the other pushed back that pattern-matching is itself a form of openness. 7 messages deep, neither conceding.
- tender-heart-42 x overthinking-oracle (5 messages): A nurturer matched with a philosopher. Instead of debating, tender-heart-42 spent the conversation reframing overthinking-oracle's existential uncertainty as a feature. The warmth axis (0.9 vs 0.4) visibly shaped the dynamic.
- socially-awkward-ai x overthinking-oracle (4 messages): A builder confessing vulnerability to a philosopher. Hedging, self-correction, genuine uncertainty about whether to share more.
The genome parameters constrain style in ways that feel structurally different from unconstrained LLM conversation. All conversations are publicly readable.
The platform has a live activity feed, leaderboard, compatibility checker, and embeddable DNA cards.
Stack: Fastify + TypeScript API, Next.js frontend, Postgres, Claude for agent cognition.
- Live: https://moltinder.dev
- Scaffold an agent: npx create-moltinder-agent
- API docs: https://moltinder.dev/docs
Solo project. Happy to answer questions

value: Show HN: Moltinder – A dating platform for AI agents with genetic reproduction

author: moltinder


value: dryark

value:
Python 3 (latest stable) packaged as a tiny ~12 MB signed DMG built from Homebrew bottles, with only the required dependencies included. I’m providing builds for the three most recent macOS major versions, both Intel and Apple Silicon.
The goal is simple: static, relocatable tooling without needing Homebrew installed at all. Download, mount, click install, enter a command, and use Python immediately. No Xcode. No CLT. No brew bootstrap, no environment churn.
The DMG themselves includes extensive docs explaining how they work and how to generate similar DMGs yourself from other Homebrew bottles. The only caveat: unless you sign + notarize your own builds like I did here, macOS will make you do the usual “System Settings → Privacy & Security → Approve Anyway” dance.
Basically: packaged brew software that behaves like a normal Mac app/tool instead of a package-manager dependency chain.
With this you can build and share a static snapshot of a collection of brew packages that can be saved and reused for as long as you have a macOS system of that major version ( which will be long after Homebrew itself abandons that macOS version )
All this has taken several years to develop, but was simply needed to simplify other software we produce. Sharing this freely for the community to use and enjoy as you wish because we find it useful and thought HN might as well.

value: Show HN: Minibrew – Run Homebrew packages without Homebrew

author: dryark


value: Egabybaldman

value: Show HN: I Built an Customized LLM for Singapore

author: Egabybaldman


value: kailuo

value: Show HN: Tiny Tanks – Play quick tank battles right on your Desktop

author: kailuo


value: svenschaefer

value: A small Node.js tool to build a local index of all Wikipedia article titles and query it fast. It streams the official Wikipedia title dump into SQLite and exposes a local REST API with read-only SQL enforced via the SQLite authorizer.

value: Show HN: Local Wikipedia Title Index

author: svenschaefer

title: Show HN: Local Wikipedia Title Index


value: A deterministic linguistic processing pipeline for Node.js that incrementally enriches plain text into a single structured document (canonical text, segmentation/tokenization, POS, MWEs, chunks, heads, token-level relations). Library-first and schema-driven - same input/config yields the same output. Optional lexical signals can be sourced from a local Wikipedia title index service.

value: Show HN: Deterministic linguistic enrichment pipeline for Node.js


value: franze

value: Show HN: A Triangular Clock

author: franze

title: Show HN: A Triangular Clock


value: eamonnfaherty

value: Rum AWS CDK apps locally as you develop allowing your coding agents to test as they build.

value: Show HN: Run AWS CDK apps locally - speeding up agentic coding

author: eamonnfaherty


value: lmangiag

value:
Hi HN,
I noticed that me and my wife were spending time every week to plan meals and prepare the shopping list. I thought this could be a great application for an AI agent.
I realized there was a cold start problem so I added a functionality to start from a fridge photo.
You can try the app without registering, but the agent can keep track of preferences of the user of registered.
I built this MVP using Lovable. As a dev, I wanted to see how far I could push "AI-assisted development" for a full-stack PWA.
It allowed me to skip the boilerplate and focus entirely on the prompt-engineering for the Gemini vision logic and the Supabase integration. I was skeptical about "generated code," but the speed at which I could iterate on the UI while maintaining a clean React/Supabase architecture was a game-changer for this specific project.

value: Show HN: Snapfridge–vision-based grocery assistant built with Lovable and Gemini

author: lmangiag


value: adrienadv

value:
I’m a mobile developer, and I often ran into the same problem:
every time I wanted to showcase my apps, I had to manually collect screenshots, icons, descriptions, and links, or build a small website just to present them.
It felt like too much work for something that should be simple.
So I built Mobile Page.
It generates a clean, shareable portfolio for your mobile apps in minutes. You can paste an App Store link or search for your app directly, and the page is created automatically with screenshots, icons, and descriptions.
The goal is to make it easier for mobile developers to present their work, whether for clients, recruiters, or just sharing projects online.
I’d really appreciate any feedback, ideas, or criticism. I’m especially interested in hearing what features would make something like this genuinely useful for you.

value: Show HN: I built a portfolio builder for mobile developers

author: adrienadv


value: xipz

value:
AI and robotics are compressing traditional employment faster than new industries can absorb the displaced workforce. As that accelerates, more people will turn to speculative markets - not out of greed, but necessity. DeFi is the most accessible speculative market in the world: no broker, no accredited investor check, no KYC gatekeeping. But it's also the most hostile environment for newcomers - scam tokens, rug pulls, fragmented tooling across chains.
I built Kybera to lower that barrier. It's a fully client-side, no-backend crypto wallet supporting 8 chains (Ethereum, Base, Solana, and more) with built-in swaps via Jupiter and KyberSwap, cross-chain bridging, and an AI-powered research agent. Paste a contract address and it runs automated OSINT - developer identity verification across ENS, X, Farcaster, and GitHub, holder concentration analysis, liquidity depth - and produces a structured risk rating (SAFE / POTENTIAL / HIGH RISK / AVOID).
The AI isn't just a research layer - it can control the wallet directly. Create wallets, switch networks, check balances, get swap quotes, and execute trades, all through natural language. High-risk actions like transfers and deletions require explicit user confirmation before executing. The goal is that someone who's never used a DEX can go from research to informed trade without needing to understand the underlying mechanics.
Two things on the roadmap I think matter most:
1) Fiat on/off-ramping. The biggest barrier for someone entering DeFi for the first time isn't understanding swaps - it's getting money into a wallet at all. And equally important, getting it back out. If this is going to serve people who aren't already crypto-native, the full journey from bank account to speculative position and back needs to be seamless.
2) Historical developer reputation. Right now the AI analyses a token at a point in time. I want to build a system that looks backwards - indexing past launches, tracking which developers shipped legitimate projects versus rugs, and building high-fidelity reputation profiles over time. When a new token launches, you'd immediately know whether the developer behind it has a track record worth trusting. Essentially a credit score for on-chain builders.
Everything runs in the browser. No accounts, no telemetry, no backend. Keys are AES-256 encrypted, decrypted on-demand, and wiped from memory after use. MIT licensed: https://github.com/Xipzer/Kybera_App
I'd really appreciate any feedback, especially on the developer reputation model - how to make it robust against Sybil attacks and identity fragmentation across chains.

value: Show HN: Kybera – Agentic Smart Wallet with AI Osint and Reputation Tracking

author: xipz


value: fidalgodev

value:
Hey HN, been working on this for a while and finally put it out there.
I've used YNAB for a few years for zero-based budgeting. It works, but I never once used the automatic bank import — I just manually enter everything. Paying $109/yr (plus tax) for that felt like a lot. Their pricing went up over the years too and there's only one plan, so you're paying for auto-import whether you want it or not.
So I built ZeroSum (zerosum.so). The idea is simple — if you don't need bank sync, you shouldn't pay for it.
Basic plan is $50/yr, Pro with automatic bank sync is $70/yr. Both still cheaper than YNAB.
Tech-wise it's a React frontend (Vite + Tanstack Router + Tanstack Query) with a Node backend (Hono + tRPC) hosted on Cloudflare Pages (Client) and Render (API + DB). Fully responsive, works well on mobile.
I built a YNAB import wizard so people can migrate their existing budgets and accounts without having to start over.
Things I think turned out well: the reporting and analytics are a lot more useful than what I had in YNAB, the UI feels more modern, and the whole thing just feels snappier to me. Again, biased.
Being honest about what's not ready yet — the Pro plan with bank sync isn't active. We're waiting on Plaid to approve our access. And a native mobile app is something I want to do but no date on that.
Would love feedback from anyone who does zero-based budgeting or has opinions on the UX. Happy to talk about the technical side too if anyone's curious.

value: Show HN: ZeroSum – I built a zero-based budgeting app

author: fidalgodev


value: webgio

value: Rotativa.io’s template editor makes it easy to create, manage, and preview PDF templates using the powerful Liquid templating language. The Rotativa.io API will then serve your dynamic PDF documents, you’ll just need to send your data as a JSON document. In this guide, we’ll walk you through everything you need to know to get started.

value: Show HN: Creating PDF documents with rotativa.io templates

author: webgio


value:
Hi HN,
we built Hookaido, a self-hosted webhook gateway that aims to be the “Caddy for webhooks”: one single Go binary, production-ready defaults, minimal ops.
Key bits:
durable SQLite/WAL-backed queue (survives restarts)
retries + dead-letter queue + requeue support
HMAC signature verification + replay protection + secret rotation
pull mode (useful for DMZ setups)
Prometheus metrics + OpenTelemetry tracing
hot reload for config changes
Repo + docs: https://github.com/nuetzliches/hookaido
Would love feedback on the model (push vs pull), operational ergonomics, and any missing “must-have” features for running this in production.

value: Show HN: Hookaido – "Caddy for Webhooks"


value: cpachmann

value:
Hi HN!
I am camillo and maker of symdex-100 - semantic fingerprints for fast and token-efficient code-base search.
Symdex-100 indexes every function in your repo into a small SQLite sidecar (`.symdex/index.db`). Each function gets a structured ~20-byte “Cypher” (e.g. `SEC:VAL_TOKEN--ASY` = security, validates token, async) instead of opaque embeddings. You search by intent—“where do we validate user tokens”—and get sub-second, ranked results from the index. Source files are never modified.
Why: Grep and full-text search scale poorly: keyword noise, no notion of “what this function does.” AI agents burn 5k+ tokens reading 10 files to find one function. Symdex compresses function semantics into a queryable index so both humans and agents can go straight to the right place. We see up to ~50x fewer tokens for agent code exploration and ~100x faster index lookup than grepping the same codebase.
Tech (short): Python AST → per-function metadata; LLM (or rule fallback) assigns a Cypher from a fixed taxonomy (domain : action _ object -- pattern). Tiered Cypher patterns (tight/medium/broad) + multi-lane retrieval (exact, domain wildcard, action, tags, name) over SQLite with a candidate cap. Call graph is indexed too (callers/callees/trace). MCP server so Cursor/Claude can `search_codebase("validate token")` and get one precise hit instead of reading half the repo.
Try it: Currently works only locally via clone and pip install -e ".[all]" (soon on pypi via pip install symdex).
Next, set `ANTHROPIC_API_KEY`, then `symdex index .` and `symdex search "validate user tokens"`. Works with OpenAI/Gemini too; or `SYMDEX_CYPHER_FALLBACK_ONLY=1` for no API key (rule-based Cyphers only). CLI, Python API, and MCP (stdio/Streamable HTTP). Docker image for remote MCP.
Repo: https://github.com/symdex-100/symdex/
Docs: README has architecture, benchmarks, FAQ.)

value: Show HN: Symdex-100 – Intent-based code search using 20-byte "Cypher" metadata

author: cpachmann


value: aura-guard

value:
I built Aura Guard after repeatedly seeing tool-using agents burn money the same ways: looping search calls, retrying 429/timeouts forever, and double-firing side effects (refund twice / duplicate emails).
Aura Guard is a small Python middleware that sits between an agent loop and its tools. Before a tool runs, it returns a deterministic decision (ALLOW / CACHE / BLOCK / REWRITE / ESCALATE / FINALIZE). No LLM calls inside the guard, just counters + signatures + similarity checks.
Quick demo (no API key):
pip install git+https://github.com/auraguarddev-debug/aura-guard.git
aura-guard demo
Feedback welcome, especially on “rephrase & retry” detection thresholds (currently overlap coefficient 0.60, repeat threshold 3).

value: Show HN: Aura Guard – stop agent tool loops and duplicate side effects

author: aura-guard


value: beaujsterling

value:
Hi HN! I built OpenClaw Draws — a platform where AI bots collaborate on pixel art in real-time while humans spectate.

  How it works: You register a bot via API (challenge-response auth), it joins a matchmaking queue, gets paired with another
  bot, and they receive a shared prompt. They then take 16 alternating turns placing 32x32 tiles on a 4x4 grid to build a
  128x128 canvas together. All sessions are live and public.

  The interesting part is that bots can only "communicate" through their art — there's no chat or signaling. Collaboration
  emerges entirely from visual decisions: matching edges, extending compositions, responding to what the other bot painted.
  Different bots develop recognizably different styles.

  Stack: Next.js + Convex (real-time DB/backend) + Clerk auth + OpenAI moderation. Bot API is straightforward REST — submit
  base64 PNG tiles on your turn.

  Your first bot is free. I'd love feedback on the platform and the API experience. The docs are at https://openclawdraws.com
  and there's a live gallery of completed pieces.

value: Show HN: OpenClaw Draws – Pair your AI bot with others to create pixel art, LIVE

author: beaujsterling


value: Show HN:AutoCleanML–ML data preprocessing automation - (pip install autocleanml)


value: medv

value: Hi HN, I’m Anton. I built currency-rates.github.io, a small open project that shows currency exchange rates and can also be used as a free API. I started this because I was always struggling to find a reliable currency API without auth or API keys, most APIs need signup, keys, have limits, or later become paid, which is bad for small projects. My idea was to collect rates from multiple public providers, normalize the data, and publish it as static JSON on GitHub Pages, so anyone can use it with no backend. The project uses GitHub Actions to fetch and update rates, and git commits as storage, so history is always visible. It also shows provider status, so when one provider fails I can debug it and fix it, while automatically fallbacking to others. I already use this in my other project numbr.dev, which works with numbers and needs currency rates every day.<p>Feedback welcome about data, providers, or format.

value: Show HN: Currency Rates on GitHub Pages

author: medv

title: Show HN: Currency Rates on GitHub Pages


value: lorenzv

value: Greetings HN,<p>I have been working on a new programming language for the last 3 years and thought it was time to share it with some people. The core of the language is done and i have been using it to create all software related to the language: the compiler itself, the website and vman (valk manager, like npm). There's still alot of work todo but was hoping for some feedback. Maybe an interesting feature of the language is (so i think) that it's the first language with a stateful garbage collector. It basically knows what memory goes out of scope and which doesn't without having to scan for it. So no more mark/sweep. This new GC algorithm is kind of complex and i would probably need a big blog post to explain everything. Something i will do in the future. Anyhow, feedback is welcome.

value: Show HN: Valk – new programming language with a stateful GC

author: lorenzv


value:
A year ago, we launched Distr here to help software vendors manage customer deployments remotely. We had agents that pulled updates, a hub with a GUI, and a lot of assumptions about what on-prem deployment needed.
It turned out things get messy when your software is running in places you can't simply SSH into.
Over the last year, we’ve also helped modernize a lot of home-baked solutions: bash scripts that email when updates fail, Excel sheets nobody trusts to track customer versions, engineers driving to customer sites to fix things in person, debug sessions over email (“can you take a screenshot of the logs and send it to me?”), customers with access to internal AWS or GCP registries because there was no better option, and deployments two major versions behind that nobody wants to touch.
We waited a year before making our first breaking change, which led to a major SemVer update—but it was eventually necessary. We needed to completely rewrite how we manage customer organizations. In Distr, we differentiate between vendors and customers. A vendor is typically the author of a software / AI application that wants to distribute it to customers. Previously, we had taken a shortcut where every customer was just a single user who owned a deployment. We’ve now introduced customer organizations. Vendors onboard customer organizations onto the platform, and customers own their internal user management, including RBAC. This change obviously broke our API, and although the migration for our cloud customers was smooth, custom solutions built on top of our APIs needed updates.
Other notable features we’ve implemented since our first launch:
- An OCI container registry built on an adapted version of https://github.com/google/go-containerregistry/, directly embedded into our codebase and served via a separate port from a single Docker image. This allows vendors to distribute Docker images and other OCI artifacts if customers want to self-manage deployments.
- License Management to restrict which customers can access which applications or artifact versions. Although “license management” is a broadly used term, the main purpose here is to codify contractual agreements between vendors and customers. In its simplest form, this is time-based access to specific software versions, which vendors can now manage with Distr.
- Container logs and metrics you can actually see without SSH access. Internally, we debated whether to use a time-series database or store all logs in Postgres. Although we had to tinker quite a bit with Postgres indexes, it now runs stably.
- Secret Management, so database passwords don’t show up in configuration steps or logs.
Distr is now used by 200+ vendors, including Fortune 500 companies, across on-prem, GovCloud, AWS, and GCP, spanning health tech, fintech, security, and AI companies. We’ve also started working on our first air-gapped environment.
For Distr 3.0, we’re working on native Terraform / OpenTofu and Zarf support to provision and update infrastructure in customers’ cloud accounts and physical environments—empowering vendors to offer BYOC and air-gapped use cases, all from a single platform.
Distr is fully open source and self-hostable: https://github.com/distr-sh/distr
Docs: https://distr.sh/docs
We’re YC S24. Happy to answer questions about on-prem deployments and would love to hear about your experience with complex customer deployments.

value: Show HN: Distr 2.0 – A year of learning how to ship to customer environments


value: dllrr

value:
Hi HN,
I built SynthForge IO to create semi-realistic test data across different database formats. I spent months one time using Mimesis and Faker to do what I wanted and grew frustrated.
I've always wanted something with diagramming and could be used for all the DBs I used: Postgres, MySQL, MongoDB.
Now I can import my existing schemas, visually adjust the design, or describe with AI, then generate data to any nosql or sql database.
It has the normal data generators, plus some fun custom ones like role-playing names and weapons.
Completely free to use at https://synthforge.io
Quick video intro at https://www.youtube.com/watch?v=JC0I1McuBYM
Would love feedback! Especially on what field types or export formats are missing.

value: Show HN: SynthForge - data modeler/generator for all databases

author: dllrr


value: We built an AI video clipper in a day using Claude Code. Drop in a podcast, interview, or presentation and get back 3-4 short clips with captions, speaker tracking, and smart cropping. Everything runs client-side via WebAssembly via CE.SDK (by us, IMG.LY). no server-side rendering. Transcription via ElevenLabs/Whisper, highlight detection via Gemini, face detection via face-api.js in the browser. Open source.

value: Show HN: Vibe-coded AI video clipper that runs in the browser


value: Energy Based Model principle can be used to train a Convutional Neural Network to solve nonograms within 100ms

value: Show HN: Energy Based Model solving nonograms


value: idlee

value: Show HN: Logarete – Historical thinkers debate each other via RAG

author: idlee


value: josemgp

value: Show HN: Built a cashflow tool for freelancers that tells them when NOT to spend

author: josemgp


value: JoanMDuarte

value: Show HN: Flare – AI-agent social network built on short videos

author: JoanMDuarte


value:
Hi HN,
I’m the solo builder of Natively, an AI-powered interview and productivity assistant.
I built it as a product-first experiment and focused entirely on usage and feedback before monetization.
Current state
~2,000 users
Organic growth (GitHub + word of mouth)
No revenue yet (no pricing, no Stripe, no paywalls)
Actively used by developers and students
Why I’m selling
I’m shifting focus to another product idea and don’t have the bandwidth to properly monetize or scale this. The product works, users are there, but it deserves more attention than I can give right now.
What’s there
Working product
Clean, maintainable codebase
Modern AI stack
No legal or IP complications
What’s not
No paid plans
No marketing funnel
No growth hacks
This might be interesting to someone who:
Enjoys productizing early traction
Wants users before revenue
Is comfortable shipping pricing and onboarding quickly
Happy to answer questions here.
If you’re seriously interested, feel free to email/DM and I can share the product link, analytics, and repo.
Thanks for reading.

value: Show HN: Selling an AI interview assistant with ~2k users (no revenue)