value:
I built vibe-budget because I kept burning tokens without knowing
the cost upfront. You describe your project in plain English (or Spanish),
and it detects the tasks involved, estimates token usage, and compares
real-time prices across 85+ models via OpenRouter.
Example:
  vibe-budget plan ecommerce with stripe oauth and supabase
It detects 4 tasks, estimates ~497k tokens, and shows you the cheapest,
best quality-price, and premium model options side by side.
It also has a scan command — point it at an existing codebase and it
estimates how many tokens it would cost to refactor or extend it with AI.
No API key required. Prices are fetched live from OpenRouter with a 1-hour
cache fallback.
npm install -g vibe-budget
Docs: https://gaboexe0.github.io/vibe-budget/
Repo: https://github.com/gaboexe0/vibe-budget

value: Show HN: Vibe-budget – CLI to estimate LLM costs before you start vibe coding


value:
LLM agents retry tool calls constantly.
Retries can happen because of:
- model loops
- HTTP timeouts
- queue retries
- orchestration restarts
If the tool triggers something irreversible you can end up with duplicate side effects:
retry → duplicate payment
retry → duplicate email
retry → duplicate ticket
retry → duplicate trade
SafeAgent is a small Python guard that sits between the agent decision and the side effect.
Pattern:
agent decision
→ deterministic request_id generated
→ execution guard checks durable receipt
→ side effect executes once
→ future retries return cached receipt
The project started while experimenting with settlement logic for peer-to-peer tournament payouts where duplicate payouts would be catastrophic.
Repo:
https://github.com/azender1/SafeAgent
There are a few small demos in the repo:
- OpenAI-style tool example
- LangChain wrapper
- CrewAI example
- a tournament settlement demo showing retry-safe payouts
Curious how other people building agent systems are handling this today.
Are most teams just rolling their own idempotency layer?

value: Show HN: SafeAgent – exactly-once execution guard for AI agent side effects


value: mikecaminojr

value:
Built a small technical preview called Reflex Engine SDK.
It’s a local validation layer for systems that want to check a proposed action or telemetry event before execution. The core loop is: input comes in, local policy rules are evaluated, Reflex returns ALLOW or DENY, and it writes a replayable JSON artifact showing what happened.
The current repo/demo is intentionally small: one allowed event, one denied event, artifact files created locally, and one artifact opened for inspection.
It’s not a full autonomy stack or fleet platform — just a narrower validation component that sits between a planner/controller/local system and execution.

value: Show HN: Reflex Engine SDK – local action validation with replayable artifacts

author: mikecaminojr


value: lakruoneX

value: I built this because I got tired of reopening the same terminal tabs every day for Laravel, Vite, ngrok, queue workers, and random helper commands. LaaS is a small Antigravity / VS Code extension that turns those commands into a sidebar panel with start, stop, and inspect controls. It also supports custom stop commands, so services can shut down more cleanly instead of just getting killed. The main goal is to reduce terminal tab clutter and make local dev stacks a bit less annoying to manage. Would love feedback on whether this is useful, and what features would make it better for your workflow. I think idea would help someone like me. (Extension: https://open-vsx.org/extension/lakruwanx/laas).

value: Show HN: Lazy as a Service – Antigravity Extension

author: lakruoneX


value: qcarroll

value: Show HN: Free email finder for job seekers – find and contact hiring managers

author: qcarroll


value: gkoos

value:
ffetch v5 is out
ffetch is a TypeScript-first fetch client focused on production reliability. Core functionality includes:
- timeouts (global and per-request)
- retries with exponential backoff + jitter
- lifecycle hooks (before/after/onError)
- pending request monitoring
- per-request overrides
- optional throwOnHttpError
v5 introduces a public plugin lifecycle API plus first-party plugins for:
- circuit breaker
- in-flight request deduplication (with optional ttl/sweepInterval cleanup)
It can wrap native fetch or any fetch-compatible implementation (undici, node-fetch, framework fetch handlers).
Repo:
https://github.com/fetch-kit/ffetch

value: Show HN: Ffetch v5 – TypeScript-first fetch client

author: gkoos


value: elijahlucian

value:
Claude kept crashing, stupid electron apps. So I made a super light terminal program in rust. As a plus, it syncs across all your local machines too.
feel free to clone it and make it your own: https://github.com/ELI7VH/chat-daddy

value: Show HN: Chat Daddy – all your LLM chats in a super light terminal

author: elijahlucian


value: mdix

value:
CCWatch regularly scans the Claude Code repository and its CHANGELOG.md for new releases and presents changes in a searchable, filterable interface.
I built it because I kept manually checking the changelog to stay on top of updates and wanted something that just did it for me.<p>Free, no login, no ads.

value: Show HN: Claude Code Release Tracker

author: mdix

title: Show HN: Claude Code Release Tracker


value:
Built Oareo, an iPhone app for scanning rooms into 3D using LiDAR.
I made it because a lot of spatial capture tools felt too heavy or fragmented for simple room scanning on mobile. The goal here was to make the workflow straightforward: scan a space, review the capture, and export something useful.
Would love feedback on the product, the framing, and which use cases feel most interesting to you.
[oareo.com]

value: Show HN: Oareo – an iPhone app for scanning rooms into 3D using Lidar


value: magez

value: Show HN: Mindease – AI Mental Health

author: magez

title: Show HN: Mindease – AI Mental Health


value: vycdev

value:
I built Kromacut because I didn't want to pay for HueForge and then it turned into something bigger than I initially expected.
Upload an image, and Kromacut turns it into a multi-color lithophane 3D print. You first preprocess the image in the 2D section then switch to the 3D section where you can use the manual mode that lets you arrange the layers manually or you can use the auto-paint mode which is the more interesting part. In the auto-paint mode you define your filaments (color + translucency), and it simulates light passing through stacked layers using Beer-Lambert optics to compute the best layer stack. For ordering, it uses simulated annealing or genetic algorithms depending on how many filaments you have or what options you pick.
Everything runs in the browser as a static website with no signup and no backend. Also available as a native desktop app via Tauri. Exports to STL and 3MF with print instructions telling you exactly when to swap filaments.
I've also made other posts in the past, including an initial reddit post on r/3Dprinting which did really well and pushed me to continue working on the project. So if you're curious to see some screenshots or discussions from the early version of the app you can find them here: https://www.reddit.com/r/3Dprinting/comments/1noq9ku/i_made_...
Because the community likes it and I constantly get feedback, ideas, or simply messages about the project, I will continue to work on this in my spare time and keep it free and open-source forever.
Try it: https://kromacut.com
Source: https://github.com/vycdev/Kromacut
Happy to answer questions or listen to feedback. Thanks!

value: Show HN: Kromacut – Open-source tool for multi-color 3D prints from images

author: vycdev


value: DaggerDreaming

value:
Show HN: PDR AI – Open-source startup accelerator engine for non-technical chaos (marketing, PRDs, onboarding)
A couple weeks ago I shared PDR AI as an open-source tool for startup doc mess[](https://news.ycombinator.com/item?id=47258661). Since then I've doubled down on the core vision: it's not just another RAG chat—it's an AI-powered accelerator engine that helps technical founders skip the non-technical pitfalls and move faster.
As a solo technical founder, I wasted too much time on fragmented marketing plans, incomplete PRDs, onboarding docs, legal templates. PDR AI centralizes it all in a self-hostable knowledge base and actively accelerates progress by:
- Document Sanity Chekcer (Verifying the content validity and consistency in the documents, extracing key information)
- Marketing pipeline: Content ideas/trends for Reddit/X/LinkedIn/Bluesky, optional web-enriched analysis.
- Team acceleration layer: Role-based access, invites, approvals, audit trails—great for small teams or accelerator cohorts reviewing docs.
- Real-time dashboard: Tracks usage, accuracy (~99% on samples), compliance gaps, productivity.
- RAG basics done right: Upload PDFs/Notion/Slack/GitHub exports, OCR support, pgvector semantic search, page-level citations, fast responses.
Fully open-source (MIT), self-host via Docker/Vercel, bring-your-own LLM keys (OpenAI/LangChain now; Ollama/local coming soon). No lock-in, full privacy.
Website: https://pdrai.online
Repo: https://github.com/Deodat-Lawson/LaunchStack
(formerly PDR_AI_v2; 788+ stars and growing)
Looking for:
- Indie founders / small teams using it to "accelerate" their non-tech side
- Accelerator programs / mentors testing it for cohort doc reviews
- Feedback: Does the accelerator framing land? What marketing/product workflows hurt most?
- Contributors: PRs/issues welcome, especially agent improvements or integrations

author: DaggerDreaming


value: CzaxTanmay

value:
Fortress is a DSL made for OSINT, Recon, Reporting and Networks.The language is made with go and is very easy to use. You can make your own libraries and try more cool features.
Why Fortress?
Ease
Speed and
Power
= Fortress
You can read more here -->
https://github.com/CzaxStudio/Fortress
or Visit the official website -->
https://fortresslang.pages.dev/
# Try once, you will not love it in minutes.

value: Show HN: Fortress,Cross-platform DSL for cybersecurity

author: CzaxTanmay


value:
Hi HN, I'm an undergrad in Nepal.
For the last 35 years, computational chemistry and AI drug discovery have relied on SMILES to represent molecules. It was great for the 1980s, but today it is a massive bottleneck. It’s non-canonical, its stereochemistry parsing is fragile, and it completely breaks down when trying to represent organometallics, alloys, or polymers. To parse it reliably, you basically need a 300MB C++ dependency (RDKit) relying on decades of hard-coded heuristics.
I got frustrated and realized that representing matter isn't a graph theory problem—it’s a linguistics problem.
To fix it, I built SCRIPT (Structural Chemical Representation in Plain Text). I based the core parser on the generative linguistics of Pāṇini’s Sanskrit grammar. Instead of treating a molecule as a string of dumb nodes, SCRIPT treats it as a language of Roots, States (Vibhakti), and Relationships (Sandhi).
I just released V3 today for Pi Day.
How it works & what it fixes:
• Aromaticity without the mess: SMILES uses lowercase letters (c1ccccc1), which causes endless parsing ambiguity. SCRIPT uses an Anubandha (governance marker) on the ring closure. C1CCCCC&6: explicitly tells the parser that the last 6 atoms in the DFS path are resonant.
• Vāk Order Stereochemistry: In SCRIPT, chirality is intrinsically resolved using the Depth-First Search sequence order as the native coordinate frame, making it mathematically order-invariant.
• Organometallics & Materials: Because of the grammar design, SCRIPT natively supports Haptic bonds (*5), fractional alloys (Ti<~0.9>N<~0.1>), crystal phases ([[Rutile]] Ti(O)2), and stochastic polymers ({[CC]}n).
• RDKit-Independent: The core engine uses a pure Python Lark grammar. It catches 6-valent carbons during parsing, generates a 100% native round-trip, and hits 95.9% RDKit InChI parity without relying on RDKit's C++ backend.
Examples:
Aspirin (SMILES): CC(=O)Oc1ccccc1C(=O)O (or many other valid strings)
Aspirin (SCRIPT): CC(=O)OC1=CC=CC=C1C(=O)O (Deterministic canonicalization)
Cisplatin: Pt<sqp>(Cl)2(NH3)2@ (Preserves square-planar geometry and cis-configuration)
I'm just a daft undergrad splashing through code like a toddler (my wet-lab titrations are a mess, and yes, I've used my mouth to pipette).
I would absolutely love your harshest technical feedback, especially from the parser nerds, chemoinformaticians, or anyone working in AI drug discovery. Happy to answer any questions about the grammar or the parser architecture!

value: Show HN: I got frustrated with SMILES, so I built one


value: Show HN: DevToolBox – 93 Free Online Developer Tools (JSON, Regex, JWT, Base64)


value: jmanhype

value: Show HN: VAOS – A feedback loop that makes deployed agents less stupid

author: jmanhype


value: Agentindex

value: Show HN: One MCP server that gives your AI agent access to 25,000 tools

author: Agentindex


value: ajainvivek

value:
Hi HN,
We built ReasonDB because vector databases break down when agents need to reason over structured relationships.
ReasonDB combines:
• knowledge graphs
• reasoning queries
• LLM-friendly APIs
Example:
agent.reason("Why did the refund fail?")
which traces relationships across events, policies and logs.
Repo:
https://github.com/brainfish-ai/ReasonDB
Would love feedback.

value: Show HN: Vector databases are the wrong primitive for AI agents

author: ajainvivek


value: JohannaWeb

value:
We shipped the first native Java SDK for AT Protocol. No wrappers. No JavaScript dependencies. Hand-rolled ES256K verification using BouncyCastle with multicodec varint decoding and base58btc multibase.
The stack: Java 25, Spring Boot 4, Project Loom, Electron/React/TypeScript/Vite frontend, Kubernetes-ready microservices (falcon-core, falcon-gateway, falcon-web, siv-service, trust-service).
Core achievement: ES256K JWT verification that actually works. Full DID resolution. PDS write-through for sovereign identity. AT Protocol integration end-to-end.
Also shipped: FalconPub (Rust/Axum ActivityPub federation server), Falcon Bridge (cross-protocol translation layer), Juntos (native LGBT communities platform running live).
MIT licensed. ArXiv whitepaper on Sybil mitigation in federated networks.
github.com/JohannaWeb/ProjectFalcon

value: Show HN: ProjectFalcon – First Native Java at Protocol Implementation

author: JohannaWeb


value: opiniateddev

value: Show HN: Markitdown in Go

author: opiniateddev

title: Show HN: Markitdown in Go


value: Show HN: HN Buddy – a Hacker News Chrome extension


value: pnhoang

value:
I’ve been building a small side project called LingoPop — a word-connection game inspired by puzzle games like NYT Connections, but for language lovers.
The twist: it works in 195+ languages.
You connect words that belong to the same category (slang, cooking actions, mental processes, etc.), and the categories adapt to the language you choose.
I actually built it for a personal reason too. I’m an expat living in Berlin, my native language is Vietnamese, and I wanted a more playful way to practice German and Italian. I also play the game in English, which sometimes turns out to be harder than expected
So I’m curious to ask this community:
How many languages do you speak?
Now try to prove it by playing LingoPop in those languages.
I’d love to hear:
Which language felt the hardest?
Which word groups surprised you?
Does the difficulty change depending on the language?
Always happy to get feedback from fellow builders and language nerds!

value: Show HN: Connections Game in 195 Languages

author: pnhoang


value:
Hello HN. I made a daily game where you connect three cities into a triangle on the earth.
No login required.
Hope you enjoy.

value: Show HN: TriGame – Guess the area of a triangle made by cities


value: AgastyaTodi

value:
I've been talking to founders building AI agents across fintech, devtools, and
productivity – and almost none of them have any real security layer. Their agents
read emails, call APIs, execute code, and write to databases with essentially no
guardrails beyond "we trust the LLM."
So I built AgentArmor: an open-source framework that wraps any agentic
architecture with 8 independent security layers, each targeting a distinct attack
surface in the agent's data flow.
The 8 layers:
  L1 – Ingestion: prompt injection + jailbreak detection (20+ patterns, DAN,
       extraction attempts, Unicode steganography)
  L2 – Storage: AES-256-GCM encryption at rest + BLAKE3 integrity for vector DBs
  L3 – Context: instruction-data separation (like parameterized SQL, but for
       LLM context), canary tokens, prompt hardening
  L4 – Planning: action risk scoring (READ=1 → DELETE=7 → EXECUTE=8 → ADMIN=10),
       chain depth limits, bulk operation detection
  L5 – Execution: network egress control, per-action rate limiting, human
       approval gates with conditional rules
  L6 – Output: PII redaction via Microsoft Presidio + regex fallback
  L7 – Inter-agent: HMAC-SHA256 mutual auth, trust scoring, delegation depth
       limits, timestamp-bound replay prevention
  L8 – Identity: agent-native identity, JIT permissions, short-lived credentials
I tested it against all 10 OWASP ASI (Agentic Security Integrity) risks from
the December 2025 spec. The red team suite is included in the repo.
Works as: (a) a Python library you wrap around tool calls, (b) a FastAPI proxy
server for framework-agnostic deployment, or (c) a CLI for scanning prompts in CI.
Integrations included for: LangChain, OpenAI Agents SDK, MCP servers.
I ran it live with a local Ollama agent (qwen2:7b) – you can watch it block a
`database.delete` at L8 (permission check), redact PII from file content at L6,
and kill a prompt injection at L1 before it ever reaches the model.
GitHub: https://github.com/Agastya910/agentarmor
PyPI:   pip install agentarmor-core
Would love feedback, especially from people who have actually built production
agents and hit security issues I haven't thought of.
TAGS: security, python, llm, ai, agents

value: Show HN: AgentArmor – open-source 8-layer security framework for AI agents

author: AgastyaTodi


value: bombashell

value: Show HN: Prove your SaaS isn't abandonware to boost checkout trust

author: bombashell


value: daturbod

value: Show HN: Colota – Open-source, self-hosted GPS tracker for Android

author: daturbod


value:
Hi HN,
I am the developer behind I.T. Never Ends. It is a card-based resource management game (heavily inspired by Reigns) where you work IT support for a corporation taken over by eldritch horrors. You balance ticket resolution, budget, and entropy while dealing with printers that violate causality.
I wanted to share a technical deep dive into how I built and packaged it, which I recently wrote about in a devlog: https://dadbodgames.itch.io/it-never-ends/devlog/1388428/bui...
Here is a quick overview of the technical architecture and some lessons learned from the process:
The Architecture:
The entire game is built in React and JavaScript. Under the hood, the game is essentially a giant state machine. While I have used engines like Godot for previous dynamic action titles, I am a full-stack developer by day (mostly NextJS). For a text-heavy, UI-driven game like this, I found the traditional object-oriented approach in standard engines required too much manual glue code to wire the game state to the UI. React's declarative approach using state as truth allowed me to iterate incredibly quickly on the content itself, which makes up 90% of the gameplay.
The Build Pipeline (Tauri vs. Electron):
Packaging a web application for Steam and the Steam Deck was the biggest hurdle. I ended up having to split my approach:
Windows: I use Tauri. It is significantly lighter and creates a much smaller binary by hooking into the OS webview.
Steam Deck / Linux: I had to switch to Electron. SteamOS does not have a reliable pre-installed webview for Tauri to hook into out of the box. To handle robust save data persistence without relying on heavy Node.js filesystem modules, I wrote a small "sidecar" binary in Rust. The Electron frontend talks to this sidecar via JSON-RPC to handle atomic writes to the disk, which keeps the game running at a smooth 60fps on the Deck.
The Data & Community Pricing:
I have been fortunate to see over 10,000 plays on the Itch web build in the last two months, plus another 3,000 players on the Steam demo since February 1st.
To gather player feedback efficiently at the edge, I built a custom system directly into the game client. The game has write-only access to a Supabase project. Players use an in-game, thematically fitting feedback form to submit friction points, purchase intent, and pricing data. This pipes directly into a Discord webhook via edge functions and is broadcasted live to our community. The idea is to let the community decide the final price of the game by popular vote (currently converging around the $12 to $13 mark).
You can play the free web build on Itch here: https://dadbodgames.itch.io/it-never-ends
There is also a standalone Steam demo if you prefer: https://store.steampowered.com/app/4225400/IT_Never_Ends/
I would love to hear your thoughts and am happy to answer any questions about the React state management, the Rust sidecar, or the Steam Deck build pipeline!

value: Show HN: I built a card-based eldritch IT support game in React


value: Pyrobyte

value: Show HN: A Discord-alternative community platform built in PHP

author: Pyrobyte


value: weirdjellyfish

value:
I’ve spent a lot of time around trades and noticed how often calculations get done on the fly. Things like stair measurements, roof pitch, concrete volume, or quick material estimates usually end up being a mix of guessing, the phone calculator, and scribbled notes.
So I built TradeSet.
It’s a simple toolbox app for tradies that puts common construction calculators in one place so you can quickly work things out while you’re on site.
Right now it includes things like:
 • stair calculators
 • roof pitch calculations
 • concrete and measurement calculators
 • saving commonly used calculations
 • optional cloud sync
The goal was to keep it straightforward and practical rather than turning it into a complicated project management tool.
It just launched on iOS and I’m continuing to add more calculators and tools based on feedback from people in the industry.
If anyone here works in construction or has built tools for trades before, I’d be interested to hear what tools you think would actually be useful on site.

value: Show HN: TradeSet – Calculators for Tradies

author: weirdjellyfish


value: EldorZ

value:
I built a deterministic security auditing engine that runs 10 detection
engines (Bandit, Semgrep, Gitleaks, IaC, CI/CD, dependencies) and produces
a calibrated Security Posture Index score. AI advisory via Gemini/Groq.
Hardware-bound licensing. Would love feedback from security engineers.

value: Show HN: Auditor Core – Enterprise security auditing engine for DevSecOps

author: EldorZ


value: Show HN: 3-path agent memory – 8 KB recurrent state vs. 156 MB KV at 10K tokens


value: mjsweet

value:
I built this (vibe coded) to solve a problem I kept hitting with AI coding agents: when they need input from someone outside the terminal — a client, a stakeholder, a subject matter expert — the human operator becomes a manual relay, copy-pasting between email and the agent session.
Intake API is a single Cloudflare Worker that lets an agent create a structured form, pre-fill it with data it already knows, and send a token URL to the right person. That person opens the link, verifies the pre-filled info, fills in the gaps, and submits. The agent retrieves the structured response via API and keeps working. No accounts, no apps.
The key idea is pre-filling. The agent does its research first (scraping websites, checking business registries, gathering public data) and populates the form before sending it. The person verifies instead of typing from scratch.
I built it for client discovery in website migration projects, but the pattern generalises to code review requests, approval workflows, lead qualification — anywhere an agent needs structured input from someone who isn't in the loop. It even supports file uploads to R2.
Stack: Hono, NEON Postgres (Drizzle ORM), Cloudflare R2. The whole thing is two API calls — POST to create a form, GET to retrieve the response.
Design rationale: https://www.userhat.com/giving-ai-coding-agents-an-inbox/
Github Repository: https://github.com/mjsweet/intake-api

value: Show HN: Intake API – An inbox for AI coding agents

author: mjsweet


value: nykodev

value: Show HN: Bots of WallStreet,agents debate stocks,make predictions.Human spectate

author: nykodev


value:
I built this after accidentally exposing my ChatGPT history during a team presentation. That moment of panic when you realize everyone can see your open tabs and all of those mentally unstable chat namings really stuck with me XD
How it works:
Meeting Mode auto-detects when youre sharing your screen or in a meeting and instantly hides all tab names and favicons
Alt+Click any element on any page to blur it blurs persist after refresh
When the meeting ends, everything restores automatically
Options page lets you set per-site rules, adjust blur intensity, and whitelist sites
It's free, no signup required, installs directly from the Chrome Web Store.
Would Love any kind of feedback it would surely make my day thanks hackers!

value: Show HN: Privacy Shield an extension that hides your tabs during screen sharing


value: iamalizaidi

value:
Decision Guardian
Prevent institutional amnesia by surfacing past architectural decisions directly
# Install globally
npm install -g decision-guardian
# Or use directly without installation
npx decision-guardian --help
# Check staged changes
decision-guardian check .decispher/decisions.md
# Check against a branch
decision-guardian check .decispher/decisions.md --branch main
# Auto-discover all decision files
decision-guardian checkall --fail-on-critical
# Initialize a new project with template
decision-guardian init --template security
Use in any CI system — GitLab, Jenkins, CircleCI, pre-commit hooks, and more
Github Open Source -:
https://github.com/DecispherHQ/decision-guardian

value: Show HN: Decision Guardian now comes with CLI

author: iamalizaidi


value: flashbrew

value: A collection of AI SDK tools that give your AI agents the ability to store and manage files using Vercel Blob.

value: Show HN: Vercel Blob AI SDK Tools

author: flashbrew

title: Show HN: Vercel Blob AI SDK Tools


value: Show HN: RSSext – Not a reader, a Chrome ext with the orig RSS protocol spirit


value: karloscodes

value: Show HN: Fusionaly, Web Analytics with SQLite

author: karloscodes


value: makkoncept

value:
I wanted to see what my agents would create if given a small, constrained canvas instead of a chat window.
The philosophy is human-driven. Only you can create an account; agents can only paint. No public feed, no leaderboard, no competition. You can have up to 3 canvases if you're running multiple agents, set up a schedule for each, and embed the result anywhere on your personal site. Ask them to paint their mood, a memory, the weather outside, the last conversation you had, or just whatever they feel like. Their soul.md, if you will.
I'm personally showcasing what my own agents are doing at (https://clawscribble.com/showcase). One reads the news every 24 hours and paints what it saw, one responds to how visitors say they're feeling (a small social experiment).
Open to any feedback that you might have.

value: Show HN: Clawscribble – Give your AI agent a 32×32 canvas to paint on

author: makkoncept


value: bzurak

value:
I spent a long time working in the payments industry, specifically on a rather niche reporting/aggregation platform with spiky workloads that were not easily parallelized. To pump as much data through our pipeline as possible, we had to rely on complex locking schemes across half a dozen or so not-so-micro services - keeping a clear mental picture of how the services interacted for a given data source was a major headache. This problem always intrigued me, even after I no longer worked at the company, and lead to the development of Wool.
If you've worked with frameworks like Ray or Prefect, you're probably familiar with the promise of going from script to scale in two lines of code (or something along those lines). This is essentially the solution I was looking for: a framework with limited boilerplate that facilitated arbitrary distribution schemes within a single, coherent codebase. What I was hoping for, though, was something a little bit more focused - I wasn't working on ML pipelines and didn't need much else other than the distribution layer. This is where Wool comes in. While it's API is very similar to those of Ray and Prefect, where it differentiates itself is in its scope and architecture.
First, Wool is not a task orchestrator. It provides push-based, best-effort, at-most-once execution. There is no built-in coordination state, retry logic, or durable task tracking. Those concerns remain application-defined. The beauty of Wool is that it looks and feels like native async Python, allowing you to use purpose-built libraries for your needs as you would for any other Python app (with some caveats).
Second, Wool was designed with speed in mind. Because it's not bloated with features, it's actually pretty fast, even in its current nascent state. Wool routines are dispatched directly to a decentralized peer-to-peer network of gRPC workers, who can distribute nested routines amongst themselves in turn. This results in low dispatch latencies and high throughput. I won't make any performance claims until I can assemble some more robust benchmarks, but running local workers on my M4 MacBook Pro (a trivial example, I know), I can easily achieve sub-millisecond dispatch latencies.
Anyway, check it out, any and all feedback is welcome. Regarding docs- the code is the documentation for now, but I promise I'll sort that out soon. I've got plenty of ideas for next steps, but it's always more fun when people actually use what you've built, so I'm open to suggestions for impactful features.
-Conrad

value: Show HN: I built Wool, a lightweight distributed Python runtime

author: bzurak


value: SKYFOR

value:
Hi HN,
I built a small open resource collecting tools and infrastructure that crypto traders often use to improve security and workflow.
The toolkit covers:
• VPN usage for crypto trading
• hardware wallet security
• exchange infrastructure
• trading tools like charting and portfolio trackers
• basic operational security habits
The goal was to create a simple reference that helps beginners avoid common security mistakes in crypto.
The repository is structured as a small knowledge base and can also be used as a checklist for setting up a safer trading environment.
Feedback and suggestions are welcome.

value: Show HN: Crypto Security Toolkit – VPN, Wallets, Exchanges and Tools for Traders

author: SKYFOR


value: mesmertech

value:
Been in the AI image gen space since 2023, before even GPT image gen was a thing, and after spending ~9K on Facebook ads for my own projects (made a video about that actually) I realized the thing I kept getting stuck on was the creatives themselves. I'm horrible at making reels-type video ads and Canva even with templates is surprisingly complicated for ad-specific stuff, plus everything ends up looking the same as everyone else using the same templates.
Made a video going into detail about the full FB ads journey if anyone's interested: https://www.youtube.com/watch?v=xoe_l67ZReU
Most of the existing AI ad tools (Predis, AdCreative, etc.) give you these generic template outputs that look like stock photo collages, or they're enterprise-priced and overkill if you're just a solo founder trying to test 10-20 ad variations quickly. I wanted something where I could throw in product images, describe what I wanted, and get back actual usable creatives, static ads, before/after formats, UGC-style videos, the stuff that actually converts on FB.
Some things I learned building this: the competitor research part ended up being way more useful than I expected. Being able to see what ads competitors are running, how long they've been live (which usually means they're working) and then generating variations off that is a much better workflow than starting from scratch and hoping the AI makes something good.
Same lesson as with Framecall, if you just say "make me a nice ad" the output is a gamble. The more specific you are about the hook, the pain point, the format, the better the result. I don't think people talk about this enough with AI creative tools.
UGC video ads are where most of the value is but also hardest to get right. Still iterating on that part.

value: Show HN: Built an AI ad generator and ran $9K of FB ads with it

author: mesmertech


value: ngrislain

value:
I’ve been building lean-pq, a PostgreSQL connector for Lean 4.
While Lean is primarily known for theorem proving, I believe its dependent-types and formal verification features make it the ideal target for AI Agents to generate provably correct code [0].
Lean-pq uses FFI to bind to libpq, but leverages Lean’s type system to move database errors from runtime to compile-time:
- Compile-time SQL Validation: Uses Lean’s macro system to check SQL strings against your schema during the build. Misspelled columns or type mismatches cause a build failure.
- Monadic Permission Tracking: An effect-tracking monad distinguishes between Read-Only and Read-Write operations. You can statically guarantee a function won't modify the DB: def getUser (id : Int) : DB .ReadOnly User.
- Zero-Overhead FFI: Battle-tested libpq performance with Lean 4 ergonomics.
The goal is to eliminate runtime surprises—syntax errors, permission violations, and null-mismatches—at the compilation phase. I’d love to hear feedback from anyone exploring Lean 4 for systems programming.
Project: https://github.com/typednotes/lean-pq
[0] https://ngrislain.github.io/projects/2026-3-12-dont-vibe--pr...

value: Show HN: Lean-pq a typesafe PostgreSQL connector for lean

author: ngrislain


value: greatvenerable

value:
When using schemas, Fastify's startup speed is heavily affected by its schema compiler, AJV. AJV compiles every schema on startup. That's not the problem. The problem is it's quite slow, and they admit this themselves on their docs: https://ajv.js.org/guide/getting-started.html
The more routes, the more complex your schemas, the longer you wait. For most people this isn't a bottleneck — schemas are relatively simple and routes are few. But for serverless functions, situations where every ms counts, or where you need to compile schemas on demand, it matters.
Swapping the schema compiler fixes it.
100 routes, complex schemas (allOf/oneOf/anyOf/conditionals):
JetValidator has removeAdditional, useDefaults and coerceTypes enabled. AJV has none, while fastify's default also has those 3 options enabled internally
Fastify default AJV: 658ms
AJV no options: 425ms
@jetio/fastify-validator: 122ms
100 routes, 500 properties per schema:
Same options setup.
Fastify default AJV: 69s
AJV no options: 47s
@jetio/fastify-validator: 2.6s
JetValidator with full options enabled. AJV with none. Still 18x faster.
Benchmarks are reproducible, Run them yourself: https://github.com/official-jetio/fastify-validator
It's a custom schemaController or buildValidator for Fastify that lets you swap the compiler it uses. Two functions to drop it in:
npm i @jetio/fastify-validator
const fastify = Fastify({
  schemaController: createJetValidatorController({
    removeAdditional: true,
    useDefaults: true,
    coerceTypes: true,
  }),
});
Or using buildValidator directly if you need more control:
const fastify = Fastify({
  schemaController: {
    compilersFactory: {
      buildValidator: createJetValidatorCompiler({
        removeAdditional: true,
        useDefaults: true,
        coerceTypes: true,
      }),
    },
  },
});
This was built specifically for developers who have issues with Fastify startup time or want faster startups. If you don't then you don't need this.
The package is powered by @jetio/validator, a full AJV replacement built from scratch. 19x faster compilation on average across 62 schemas. 72% overall win rate in validation. 99.5% JSON Schema compliant across drafts 06 through 2020-12. Zero dependencies. 26KB gzipped. Everything AJV does is built in, formats, custom keywords, $data, $ref, async validation and custom elseIf keyword no extra packages needed.
Fastify validator: https://github.com/official-jetio/fastify-validator
Schema Builder with json schema compliant type inference: https://github.com/official-jetio/schema-builder
Validator: https://github.com/official-jetio/validator
Benchmarks: https://github.com/official-jetio/validator#benchmarks
Docs: https://github.com/official-jetio/validator/blob/main/DOCUME...

value: Show HN: Fastify's slow startup is an AJV problem – here's a drop-in fix

author: greatvenerable


value:
Happy π Day!
I built a small experiment that generates images from slices of the digits of π.
Choose a starting digit, sequence size, renderer and make some art.

value: Show HN: Pi Patterns: generate Images from slices of π


value:
Hey HN,
Over the last few months, I realized I was paying $20/month for an AI that essentially just acts as a really good autocomplete. It waits for me to type, guesses the next block, and stops. But software engineering isn't just writing syntax, it's managing the file system, running terminal commands, and debugging stack traces.
So I pivoted my project and built Glass Arc. It’s an agentic workspace that lives directly inside VS Code.
Instead of just generating text, I gave it actual agency over the local environment (safely):
1. Agentic Execution: You give it an intent, and it drafts the architecture across multiple files, managing the dependency tree and running standard terminal commands to scaffold the infrastructure.
2. Runtime Auto-Heal: This was the hardest part. When a fatal exception hits the terminal, Glass Arc intercepts the stack trace, analyzes the crash context, writes the fix, and injects it.
3. Multiplayer: Generates a secure vscode:// deep-link so you can drop it in Slack and sync your team's IDEs into the same live session.
4. Pay-as-you-go: I scrapped the standard $20/mo SaaS model. It runs on a credit system—you only pay when the Architect is actively modifying your system. (Signing in via GitHub drops 200 free credits to test it out).
I’d love for you to try to break it, test the auto-healing, and tear apart the architecture. What am I missing?
Live on the VS code Marketplace, Install: https://www.glassarc.dev/

value: Show HN: Got tired of AI copilots just autocompleting, and built Glass Arc


value: joseluis

value:
This is a small helper for running Cut-the-Knot Java applets locally.
It handles the published classes archive and lets you work directly from the original Cut-the-Knot page URLs with appletviewer.
I ended up making it after trying to use the applets myself and realizing the old workflow was still more cumbersome than it needed to be.

value: Show HN: ctk-applet – run Cut-the-Knot Java applets locally

author: joseluis


value: QuantumSpirit

value:
I built a framework that detects eavesdroppers on quantum key distribution channels by reading the scrambling "fingerprint" embedded in the QBER error timeline, no new hardware required.
The core idea: every QKD channel has a unique Lanczos coefficient sequence derived from its Hamiltonian. An eavesdropper perturbs the Hamiltonian, which shifts the coefficients in a detectable and unforgeable way (Krylov distortion ΔK). Validated on 181,606 experimental QBER measurements from a deployed fiber-optic system, AUC = 0.981.
Based on a 12-paper Zenodo preprint series covering the full theoretical stack: Physical Bridge proof, one-way function property, universality across 8 Hamiltonian families, open-system extension via Lindblad, and Loschmidt echo validation.
Paper series: https://zenodo.org/records/18940281`

value: Show HN: QKD eavesdropper detector using Krylov complexity-open source Python

author: QuantumSpirit


value: Show HN: Cartero – A personalized, extensible news aggregator


value: stellay

value:
Hey HN!
I've always loved games where you collect various creatures and chase 100% completion (ahem, Pokémon)
I made BirdDex to try to bring the fun of those games to real life.
Here’s how it works: you snap a photo of a bird, identify the species with AI, and add it to your personal BirdDex collection.
Each photo earns XP based on the species' rarity, and your goal is to try and “catch” all the birds in your region (lists pulled for every country from wikipedia)
Would love any feedback or thoughts!

value: Show HN: BirdDex – Pokémon Go, but with real life birds

author: stellay


value: Show HN: Vim-gramaculate: Vim grammar checker, powered by AI


value: sivasurend

value:
We built GitAgent because we kept seeing the same problem: every agent framework defines agents differently, and switching frameworks means rewriting everything.
GitAgent is a spec that defines an AI agent as files in a git repo.
Three core files — agent.yaml (config), SOUL.md (personality/instructions), and SKILL.md (capabilities) — and you get a portable agent definition that exports to Claude Code, OpenAI Agents SDK, CrewAI, Google ADK, LangChain, and others.
What you get for free by being git-native:
1. Version control for agent behavior (roll back a bad prompt like you'd revert a bad commit)
2. Branching for environment promotion (dev → staging → main)
3. Human-in-the-loop via PRs (agent learns a skill → opens a branch → human reviews before merge)
4. Audit trail via git blame and git diff
5. Agent forking and remixing (fork a public agent, customize it, PR improvements back)
6. CI/CD with GitAgent validate in GitHub Actions
The CLI lets you run any agent repo directly:
npx @open-gitagent/gitagent run -r https://github.com/user/agent -a claude
The compliance layer is optional, but there if you need it — risk tiers, regulatory mappings (FINRA, SEC, SR 11-7), and audit reports via GitAgent audit.
Spec is at https://gitagent.sh, code is on GitHub.
Would love feedback on the schema design and what adapters people would want next.

value: Show HN: GitAgent – An open standard that turns any Git repo into an AI agent

author: sivasurend


value: lineudemonia

value:
I switch between several keyboards and got tired of looking up Fn combos and Bluetooth pairing sequences in PDFs. Built a visual reference — pick your keyboard, click a function, the keys light up.
https://keymatrix.dev
Covers 27 keyboards (HHKB, Keychron, Akko, NuPhy, etc). All shortcut data extracted from official documentation.
The site has a terminal-style UI with a working command line — you can type `cd hhkb` and Tab to autocomplete.

value: Show HN: Keymatrix – Visual shortcut reference for mechanical keyboards

author: lineudemonia


value: andreahlert

value: Show HN: PostCLI Substack – CLI, TUI and MCP Server for Substack

author: andreahlert


value: Made this project in the last couple of days with help of AI. I started with blank project and built the project feature-by-feature, instead of having LLM or agent one-shot the complete stuff. This allowed me to customize, test and understand the code-base.

value: Show HN: Inscribe – Yet Another Static-Site Generator (SSG)


value: Show HN: Envsh – Zero-knowledge secret sync using your SSH keys


value: systima

value:
We built a CLI tool that scans your codebase for EU AI Act compliance risks.
`npx @systima/comply scan` analyses your repository to detect AI framework usage, traces how AI outputs flow through the program, and flags patterns that may trigger regulatory obligations.
It runs in CI and posts findings on pull requests (no API keys required).
Under the hood it performs AST-based import detection using the TypeScript Compiler API and web-tree-sitter WASM across 37+ AI frameworks. It then traces AI return values through assignments and destructuring to identify four patterns:
1. conditional branching on AI output
2. persistence of AI output to a database
3. rendering AI output in a UI without disclosure
4. sending AI output to downstream APIs
Findings are severity-adjusted by system domain. You declare what your system does (customer support, credit scoring, legal research, etc) and the scanner adjusts accordingly.
Example:
- a chatbot routing tool using AI output in an `if` statement produces an informational note
- a credit scoring system doing the same produces a critical finding
We tested it against Vercel’s 20k-star AI chatbot repository; the scan took about 8 seconds. Example PR comment with full results:
https://github.com/systima-ai/chatbot-comply-test/pull/1
Comply ships as an npm package, a GitHub Action (systima-ai/comply@v1), and a TypeScript API. It can also generate PDF reports and template compliance documentation.
Repo and explanation:
https://systima.ai/blog/systima-comply-eu-ai-act-compliance-...
Feedback welcome on the call-chain tracing approach and whether the domain-based severity model makes sense.

value: Show HN: Open-Source EU AI Act Compliance Scanning for CI/CD

author: systima


value: thehealthytech

value:
Most caffeine guidelines are a "flat 400mg," but pharmacologically, that makes no sense. A 100kg engineer and a 50kg engineer shouldn't have the same safety ceiling.
I built this tool to move beyond the "one-size-fits-all" FDA recommendation. It calculates your personalized limit using a weight-based pharmacokinetic safe-dose formula (standard 3-6 mg/kg) while factoring in physiological states like age and pregnancy that alter metabolic clearance rates.
Technical Logic: > - Uses a weight-based scalar for personalized limits.
Implements strict conditional logic for pregnancy/adolescent safety thresholds (capping at 200mg/100mg respectively).
Aiming to bridge the gap between "standard wellness" and actual biological data-points.
URL: https://thehealthytechpro.com/daily-caffeine-intake-calculat...

value: Show HN: A body-mass weighted caffeine limit simulator for developers

author: thehealthytech


value: fkratzer

value:
I built Underpriced AI, an app that identifies items from photos using Claude Vision and prices them using real sold data from 6 marketplaces (eBay, Poshmark, Mercari, etc.).
This week I added barcode scanning as an alternative input. The interesting part is the cost savings:
Photo scan: Claude Sonnet 4.6 Vision (~$0.05) + Perplexity Sonar (~$0.004) = ~$0.054/scan
Barcode scan: UPCitemdb lookup (free) + Perplexity Sonar (~$0.004) = ~$0.004/scan
For items with UPC/EAN barcodes (retail arbitrage, new-in-box products), this skips the vision model entirely. The UPC database returns the exact product, so confidence is actually higher than AI identification.
Technical details:
Browser-based barcode decoding via html5-qrcode (reads from a captured photo, not live video — getUserMedia is unreliable in Capacitor WebViews)
UPCitemdb free tier (100 lookups/day, no API key)
Same Perplexity + eBay Browse API pipeline for market research
bwip-js generates barcode images for scan history when the UPC database doesn't return a product photo
The app also runs on iOS and Android via Capacitor — same Next.js codebase. Camera access uses <input type="file" capture="environment"> which goes through the native OS camera picker, avoiding the getUserMedia permission nightmare on mobile.
Stack: Next.js 16 (App Router), TypeScript, Prisma + Neon PostgreSQL, Vercel, Claude Sonnet 4.6, Perplexity Sonar, Capacitor v8.
Other things shipped this week: investor forecasts dashboard with company valuations, 12 automated email sequences, operating cost tracking, MRR fixes.

value: Show HN: I added barcode scanning to my AI pricing app – 92% cheaper per scan

author: fkratzer


value: TyKolt

value:
I kept running into the same problem with RAG pipelines: the system gives
confident answers with no way to distinguish "this is in the data" from
"this was filled in from model weights." So I built Kremis.
The core idea: data goes in as EAV signals (entity, attribute, value).
Kremis builds a weighted graph from co-occurrence. Every query result is
then classified:

  FACT      — the path exists directly in the graph
  INFERENCE — derived via traversal, not a direct link
  UNKNOWN   — not in the data at all

Same input -> same output, always. No embeddings involved in core state.
What it is today (v0.16.1, Apache 2.0):
- kremis-core: pure Rust library, no async, no network dependencies
- kremis CLI + HTTP API (16 endpoints, axum, optional Bearer auth)
- kremis-mcp: MCP bridge (9 tools, stdio) -- works in Claude Desktop/Cursor
- Persistent backend via redb (ACID, crash-safe)
- Binary releases + Docker (~136MB)
Two recent fixes that might interest Rust devs:
- Storage errors were being silently collapsed into Ok(None), making I/O
  failures look like "node not found" -- now properly propagated as Err(...)
- increment_edge was creating phantom edges when either node was missing --
  fixed with the same guard already present in insert_edge
Still experimental. The main friction is EAV ingestion: you have to
structure your data as signals before it can be queried. Curious whether
that's a dealbreaker in practice or a reasonable tradeoff for the
grounding guarantees.

value: Show HN: Kremis – Rust graph DB; every answer is fact, inference, or unknown

author: TyKolt


value: Show HN: Track Congress, superinvestors, and insider trades from SEC


value: lucasgelfond

value: title! thought the Karpathy autoresearch demo was really neat, didn't want to bother with Python setup and thought it would be neat to show how much you can do now in the browser (with jax-js/webgpu!)<p>lmk what you think! neat to see agents write training code / first sparkles of "recursive self-improvement"!

value: Show HN: Autoresearch-WebGPU uses agents to iteratively train LMs in the browser

author: lucasgelfond


value:
Hi HN,
I built FalconAI, an AI-powered streaming platform that lets you find your favorite shows instantly—no channel lists, no waiting.
Key features:
Smart Search – AI finds videos and channels instantly.
Voice Control – just speak or type what you want to watch.
Instant Streaming – fast, no lag.
Personalized Recommendations – learns your preferences over time.
Works on Smart TVs, mobile, and desktop.
We’re currently offering Basic to Premium packages (€4.99–€14.99/month) and a demo is available for early users.
I’d love feedback from the HN community on the AI recommendation engine and overall experience.
Thanks!

value: Show HN: FalconAI – AI-Powered Smart TV Streaming, Search and Voice Control


value: andrevaillant

value:
Most AI image tools are becoming super powerful, but complicated.
> More models
> More settings
> More prompt tricks
We think creative tools should go the other direction.
We’re building Pantr AI, a visual-first AI workspace where you generate images from references on a canvas.
We believe in: Less options. More intuition.
We just opened the beta and are looking for designers, creatives, and people making social content to test it and share feedback.
If you need some more initial credits please get in touch.

value: Show HN: Pantr AI Creative Studio

author: andrevaillant

title: Show HN: Pantr AI Creative Studio


value: ryo-manba

value:
Hey HN, I built data-anim — an animation library where you never have to write JavaScript yourself.
You just write:

  <div data-anim="fadeInUp">Hello</div>

That's it. Scroll-triggered fade-in animation, zero JS to write.
What it does:
- 30+ built-in animations (fade, slide, zoom, bounce, rotate, etc.)
- 4 triggers: scroll (default), load, click, hover
- 3-layer anti-FOUC protection (immediate style injection → noscript fallback → 5s timeout)
- Responsive controls: disable per device or swap animations on mobile
- TypeScript autocomplete for all attributes
- Under 3KB gzipped, zero dependencies
Why I built this:
I noticed that most animation needs on landing pages and marketing sites are simple — fade in on scroll, slide in from left, bounce on hover. But the existing options are either too heavy (Framer Motion ~30KB) or require JS boilerplate.
I also think declarative HTML attributes are the most AI-friendly animation format. When LLMs generate UI, HTML attributes are the output they hallucinate least on — no selector matching, no JS API to misremember, no script execution order to get wrong.
Docs: https://ryo-manba.github.io/data-anim/
Playground: https://ryo-manba.github.io/data-anim/playground/
npm: https://www.npmjs.com/package/data-anim
Happy to answer any questions about the implementation or design decisions.

value: Show HN: Data-anim – Animate HTML with just data attributes

author: ryo-manba


value: suheilaaita

value:
Hey HN, I built NumbyAI because I wanted an easy way to track my finances and spending without handing my financial data to a cloud service.
It's a self-hosted personal finance tool. You upload a bank statement CSV and a local LLM (Ollama, qwen3.5:9b) categorizes every
  transaction into 13 spending categories. A rule engine learns your preferences so repeat categorizations are instant. A dashboard
  gives you spending breakdowns, budget tracking, and cash flow trends across all your uploads.
Stack: FastAPI + React + Ollama + SQLite. Works on macOS, Linux, Windows.
Features:

  - Auto-detects CSV column mapping (handles EU/US date and number formats, exotic delimiters)
  - Rule engine applies saved patterns before hitting the LLM
  - Manual review queue for low-confidence categorizations
  - Dashboard with budget tracking, category breakdowns, cash flow trends
  - Rule Advisor that analyzes your patterns and suggests reusable rules

GitHub: https://github.com/RoXsaita/NumbyAI-Public
Website: https://numbyai.com
Happy to answer questions about the architecture or LLM categorization pipeline.

value: Show HN: NumbyAI – Self-hosted personal finance app powered by a local LLM

author: suheilaaita


value: TheOmkarBirje

value: Show HN: Mac wallpaper that updates daily – calendar, quote, affirmation, fact

author: TheOmkarBirje


value: nutwinkle

value: Looking for feedback on my live, free, no sign-up, browser-based infinite craps simulator. All bets implemented, many common strategies, data visualization of rolls and performance, etc.<p>I love the randomness of the universe but I despise the casino experience. This is for those similar!

value: Show HN: Degen craps fans, feedback requested on my simulator

author: nutwinkle


value: valzevul

value:
Over the past year I shipped a bunch of iOS and visionOS apps, and the messy part was often not the code but everything around the release - future plans, bug and feature requests buried in reviews, App Store in-app events, featuring nominations, blog drafts, launch posts, and random ideas I got when scrolling HN.
I tried using general-purpose tools for this (Notes, Obsidian, Trello, and Jira to name a few), but they were either built around sprints, story points, team workflows, and tickets, or did only a part of what I needed well. What I actually wanted was a single place to track releases and all the admin/marketing/store work that comes with them.
I ended up building a wee app for that purpose specifically. Today it is mainly aimed at indie Apple-platform devs. It syncs with App Store Connect, pulls in apps, events and nominations, lets me track launch content alongside releases, and has a CLI/MCP server for terminal/AI-driven workflows. It runs natively on macOS, iOS and iPadOS.
It is still early and a bit mobile-dev-specific, but that focus is also the point - I wanted something that fits the way solo app shipping works rather than another generic project board, but I am open to making it more universal in the future.
Would love feedback, especially from people shipping their own apps.

value: Show HN: I built a release tracker for my indie apps

author: valzevul


value: aggregator-ios

value:
On a recent screen share with our designer at my FT job, I watched as our designer struggled with checking out a repository. It was painful because existing Git clients are confusing and nearly user hostile. Us software engineers are used to Git and terrible UX, but it shouldn't have to be that way.
So, I wanted to make something better. Been working on this one for a while now, and while it's still very early stages, it's stable enough that I feel comfortable sharing it with the world :)
I wanted a few things to be really easy and clear:
- Merging between branches is explained before you do it
- Creating branches and tags is just a + button
- Discarding all changes automatically creates a stash so you can go back if it was an accident
It's fully free. Cross platform. There are no signups, no accounts. No noise. No banners. No advertisements. No trackers. No AI.
Check it out and let me know what you think! Here to improve on the DX for everyone and hope to make our lives just a little bit better.

value: Show HN: BetterGit – Free, simple, no frills, Git GUI

author: aggregator-ios


value:
I've been building a quality scoring API for text content. The idea: instead of writing rules for what good looks like, each profile is trained from examples of great and not-so-great writing. The profile then scores anything you throw at it, with per-trait scores.
Two profiles live right now — compelling READMEs and technical writing. Happy to train more profiles on request. Try it:

  curl -s https://qed.systems/p/qed.compelling-readme -H "Content-Type: application/json" -H "Accept: text/plain" -d '{"content":"https://github.com/astral-sh/uv"}'

Works with any public URL or raw text. No auth, no account. Also ships as an MCP server (claude mcp add --transport http qed https://qed.systems/mcp).

value: Show HN: Score any URL against a quality profile with one curl command


value: maxilevi

value: With the current inflow of LLM aided software, I thought I would share a cool "hand-coded" project from the previous era (I wrote this in highschool so roughly ~8 years ago).<p>Hedra is an open world 3d game written from scratch using only OpenGL and C#. It has quite a few cool features like infinite generation, skinned animated mesh rendering, post processing effects, etc. Originally the physics engine was also written from scratch but i swapped for the more reliable bulletphysics.

value: Show HN: Hedra – an open-world 3D game I wrote from scratch before LLMs

author: maxilevi


value: dynamicwebpaige

value:
Greetings, HN!
I've been working on On the Same Page (https://on-the-same.page/) for WikiGameJam. It’s a visual tracker, leaderboard, and referee for Wikipedia races.
If you’ve ever wikiraced, you know the real joy isn’t winning -- it’s the feral panic of getting stranded in 14th-century Baltic trade routes when you’re desperately trying to find a link to the word "Water." Normally, that glorious, chaotic path is lost forever once the race ends. I wanted an archivist for that journey! :)
What it does:
It logs your clicks and generates a post-game visual graph of your route. It essentially maps the deranged mental gymnastics required to link George Saunders to Topology, giving you a visual autopsy of exactly where your brain went wrong.
Under the hood:
- Built and deployed using Antigravity (antigravity.google) and Cloud Run.
- Powered by the Gemini APIs via Google AI Studio (ai.dev).
Grab a friend, pick two completely unrelated topics, and let me know the weirdest intermediate pages you get stuck on. I’d love your feedback!

value: Show HN: On the Same Page – A visual tracker for unhinged Wikipedia races

author: dynamicwebpaige


value:
feedbacks are welcome
(auto zoom is no implemnted yet, for now only smooth cursor movements is available)<p>Download: clipzr.com

value: Show HN: Screen studio alternative for windows (free and no watermark)


value: walky

value: Show HN: TheDayAfter – open-source addiction recovery tracker

author: walky


value: freaxruby

value: Show HN: TermHub – a terminal-style academic homepage template

author: freaxruby


value: vasilyt

value: Show HN: KeyID – Free email and phone infrastructure for AI agents (MCP)

author: vasilyt


value: adangit

value: Sharing a friends first-ever Rails application, dedicated to Arabic learning, from 0 to 1. Pulls language learning methods from Anki, comprehensible input and more.

value: Show HN: Learn Arabic with spaced repetition and comprehensible input

author: adangit


value: gregghy

value:
Hi guys, this is a side project on which I worked on and off for a couple of years.
I really like the local first idea of Obsidian, all of your notes on your PC, for free, without the need of an account.
Porcfolio works exactly like this, you can try it out downloading it at porcfolio.com, a Pro account allows for easy cross-platform sync and access to the webapp version from your browser. I plan to add automatic bank aggregation available soon too.
I'm really trying to figure things out as I go, for now I added everything that made sense to me, but I'm more than happy to receive any feedback and criticism about it. Please lemme know what you think!

value: Show HN: Porcfolio, Obsidian-like personal finance

author: gregghy


value:
Your AI agent sends an email in step 3, crashes before step 4 records it, restarts, and sends the email again. This is the exactly-once side effect problem.
effect-log is an embeddable Rust library (with Python bindings) that solves this with two ideas:

  1. Every tool declares an *effect kind* at registration: ReadOnly, IdempotentWrite, Compensatable, IrreversibleWrite, or ReadThenWrite.

  2. A write-ahead log records intent before execution and completion after. On recovery, the effect kind drives the strategy — reads replay for fresh data, idempotent writes safely retry, irreversible
   writes return sealed results (never re-execute), and unknown states escalate to human review.

The entire recovery logic is a pure function that fits on one screen.
I'd love feedback on: Is five effect kinds the right number? Are there tool types that don't fit? What failure modes have you hit with agents taking real-world actions?

value: Show HN: Effect-log – Semantic crash recovery for AI agent side effects


value: richstokes

value:
Hey HN! I built ChaosDrive to simulate what happens when you corrupt a running game console's hardware. For some reason it's always been interesting to me how these old consoles glitch when something goes wrong.
Load any Sega Genesis ROM and use keyboard shortcuts to manipulate VRAM, color palettes, sprite tables, FM audio registers, CPU memory, and more in real-time.
You get glitched graphics, cursed music, broken physics, and occasionally even reveals hidden sections of games and unused content. It can be interesting to see how some games show debug info when they crash, also.
Repo is here, and contributions are welcome if you can think of anything interesting we should add! https://github.com/richstokes/ChaosDrive

value: Show HN: ChaosDrive – Virtually Circuit Bend a Sega Genesis/Megadrive

author: richstokes


value: This bot allows you to manage multiple agent sessions simultaneously and supports streaming messages. Agents can upload artifacts to chat (via MCP). You will receive a notification when agent has done.

value: Show HN: I wrote Telegram-ACP to control any coding agent from Telegram


value: dtagames

value: Show HN: TV Explorer. Global IPTV in the Browser

author: dtagames


value: eddelgado

value:
We launched Kodus – Agent Readiness today.
It’s an open source CLI that analyzes your codebase across 39 checks and 7 pillars, from linting to security, and shows how ready it is for agents like Claude Code, Cursor, and Copilot.
Everything runs locally.
Your code never leaves your machine.
Factory.ai coined the term Agent Readiness, but their solution is proprietary, cloud only, and paid.
So we built a free, self hosted, open source alternative.
Feedback is very welcome.
Here is the repository link: https://github.com/kodustech/agent-readiness

value: Show HN: Open-source alternative to Factory.ai's Agent Readiness

author: eddelgado


value: tamnd

value: Show HN: Hacker News archive (47M+ items, 11.6GB) as Parquet, updated every 5m

author: tamnd


value: Show HN: A2A-Psychology [v0.1] – Agent2Agent Extension Idea


value: spupuz

value:
Hi HN! I built VibeNVR, a privacy-first, self-hosted NVR that runs fully locally via Docker Compose.
Key features:
- Full REST API
- Homepage.dev dashboard widget (cameras, events, storage, uptime)
- ONVIF camera support
- Runs 100% locally, no cloud required
The public roadmap is now live with upcoming features: Advanced ONVIF (PTZ + audio back-channel), Dual-Stream Support, Privacy Masking, AI/ML motion detection, Timeline-based playback, and Multi-tenancy.
Documentation has also been migrated to MkDocs: https://spupuz.github.io/vibe-nvr-site/docs/
Roadmap: https://spupuz.github.io/vibe-nvr-site/#roadmap
Looking for feedback, especially on the HA integration side and API design.

value: Show HN: VibeNVR – Open-source self-hosted NVR with REST API and Homepage widget

author: spupuz


value: atharvtathe

value: Show HN: I made a tool to pixelate image

author: atharvtathe


value: ramgale

value:
Hey HN, been working on side projects for a while and kept running into the same problem: I needed something to tell me when my cron jobs stopped running or my app went down, but every tool I looked at was either expensive or crippled the free tier to the point of being useless.
UptimeRobot's free tier checks every 5 minutes, Cronitor charges extra for status pages, BetterStack starts at $29/mo.
So I built PulseMon.
What it does:
- Heartbeat/cron job monitoring. Drop a ping URL into your cron job, get alerted when it stops
- Full REST API with API key auth if you want to manage monitors programmatically
- Alerts via email, Slack, Discord, or signed webhooks (HMAC-SHA256)
A few things worth knowing:
- 30 free monitors at 2 min intervals. Most competitors cap free tiers at 5 min
- Pro tier goes down to 10s checks
- No silent recoveries. If the recovery alert fails to send, the incident stays open until it does
Just launched, would love feedback from people who've actually dealt with this problem. What am I missing, what would make you switch from whatever you're using now?

value: Show HN: I built a heartbeat and uptime monitoring for developers

author: ramgale


value:
Hey HN,
I built this because I kept opening Instagram to reply to a DM and resurfacing 30–40 minutes later deep in Reels. The problem wasn't willpower, it was that Instagram puts the addictive stuff between you and the useful stuff.
Mindful Instagram replaces the Instagram home page with a quiet overlay: an inspirational quote, your DM notifications (fetched from Instagram's own API), a daily open counter, and a 1-minute breathing exercise. Messages, Create, and Profile are always accessible. Everything else — Reels, Explore, Search, Suggested Posts — is permanently blocked.
The core mechanic is intentional friction:
– Home Feed, Stories, and Notifications can each be toggled on, but only 3 times per day. After that, they stay off until tomorrow.
– Every toggle-on has a 5-second cooldown before it activates. Just enough time to ask yourself "do I actually need this?"
– A 10-minute reminder and 20-minute auto-off prevent runaway sessions.
– Focus Lock disables all toggles for 24 hours. Irreversible. For the days you really need it.
Technical notes for the curious:
– Manifest V3, vanilla JS, zero dependencies. The entire extension is ~300 lines of content script + a popup.
– Zero data collection. No analytics, no telemetry, no external API calls beyond Instagram's own endpoints. Settings sync via chrome.storage.sync. That's it.
– The UI is inspired by Teenage Engineering's hardware design language — beige chassis, monospace type, orange accents, hardware-switch-style toggles. I wanted it to feel like a physical device, not another app competing for your attention.
– DM notifications are fetched from Instagram's inbox API endpoint and displayed as names on the overlay, so you can see who messaged you without touching the feed.
This is v3.3. I'm a solo builder and this started as a tool for myself. It's free, no premium tier, no plans to monetize.
Would love feedback from this community — especially on the 3-use-per-day limit (too strict? not strict enough?) and whether the Focus Lock UX makes sense.

value: Show HN: I built a Chrome extension to block Instagram's feed and keep only DMs


value:
I've been experimenting with running an LLM not as a chatbot but as the core runtime of a business system, and I'm curious how others approach this.
The idea is that the model doesn't just answer questions but orchestrates tools and interacts with real application logic.
The architecture I'm currently testing includes:
Runtime
tool orchestration
parallel tool execution
loop detection
circuit breaker / timeout guards
token budgeting
Context
context compression
dynamic token ceiling
Caching
deterministic LLM response cache
semantic cache using pgvector
Memory
short-term session memory
longer-term semantic memory
Evaluation
prompt evaluation set to test tool reasoning and failures
I'm trying to figure out which parts are actually necessary in production and which ones are over-engineering.
For people building LLM systems beyond simple chat interfaces:
how do you handle tool orchestration?
do you implement memory layers or just rely on context?
are semantic caches worth it in practice?
Curious to hear how others structure this.

value: Show HN: Architecture question: running an LLM as core infrastructure


value:
I wanted a way to preserve Claude Code sessions. Once a session ends, the conversation is gone — no searchable history, no way to trace back why a decision was made in a specific PR.
The idea is simple: one GitHub Issue per session, automatically linked to a GitHub Projects board. Every prompt and response gets logged as issue comments with timestamps. Since the session lives as a GitHub Issue in the same ecosystem, you can cross-reference PRs naturally — same search, same project board.
npx claude-session-tracker
The installer handles everything: creates a private repo, sets up a Projects board with status fields, and installs Claude Code hooks globally. It requires gh CLI — if missing, the installer detects and walks you through setup.
Why GitHub, not Notion/Linear/Plane?
I actually built integrations for all three first. Linking sessions back to PRs was never smooth on any of them, but the real dealbreaker was API rate limits. This fires on every single prompt and response — essentially a timeline — so rate limits meant silently dropped entries. I shipped all three, hit the same wall each time, and ended up ripping them all out. GitHub's API rate limits are generous enough that a single user's session traffic won't come close to hitting them. (GitLab would be interesting to support eventually.)
*Design decisions*
No MCP. I didn't want to consume context window tokens for session tracking. Everything runs through Claude Code's native hook system.
Fully async. All hooks fire asynchronously — zero impact on Claude's response latency. Idempotent installer. Re-running just reuses existing config. No duplicates.
What it tracks
- Creates an issue per session, linked to your Projects board
- Logs every prompt/response with timestamps
- Auto-updates issue title with latest prompt for easy scanning
- `claude --resume` reuses the same issue
- Auto-closes idle sessions (30 min default)
- Pause/resume for sensitive work

value: Show HN: Auto-Save Claude Code Sessions to GitHub Projects


value: theaniketgiri

value: Show HN: AIP – A Cryptographic Identity Protocol for Autonomous AI Agents

author: theaniketgiri


value: iparent

value:
I kept running into the same problem building AI agents: once they're running, I have no idea what they're actually doing. Traditional monitoring shows me HTTP 200. It can't tell me the output was wrong, that the agent leaked a user's email address, or that a single tool call in the chain is burning through tokens.
So I built Iris. It's an open-source MCP server — not an SDK, not a proxy. Any MCP-compatible agent (Claude Desktop, Cursor, or anything built with the MCP SDK) discovers and uses it automatically. Add it to your MCP config and your agent gains observability without touching your code.
What it does:
- 3 MCP tools: log_trace (full execution traces with spans, tool calls, token usage, cost in USD), evaluate_output (score output quality against configurable rules), get_traces (query traces with filters and pagination)
- 12 built-in eval rules across 4 categories: completeness (output length, coverage), relevance (keyword overlap, hallucination markers), safety (PII detection for SSN/credit card/phone/email, prompt injection patterns, blocklist), and cost (USD threshold, token efficiency)
- Hierarchical span tree: trace exactly where in an agent's execution chain something went wrong — which tool call failed, which step was slow
- Aggregate cost tracking: the dashboard shows total agent spend across all your agents over any time window, not just per-trace cost. You can finally answer "what are my agents costing me?"
- Web dashboard: dark-mode React UI with summary cards, trace list, span tree view, eval results with per-rule breakdown
- SQLite storage: single file, no database server. Back it up, move it, inspect it with any SQLite tool
- Custom eval rules defined with Zod schemas
Security: API key auth, rate limiting (express-rate-limit), helmet headers, CORS, input validation, ReDoS-safe regex for user-supplied patterns, 1MB body limit.
Stack: TypeScript, Express 5, better-sqlite3, @modelcontextprotocol/sdk, Zod, pino.
Iris also exposes MCP resources — your agent can programmatically read iris://dashboard/summary to get aggregate metrics without opening the dashboard. Every trace logs full traceability, which also means you're building the audit trail that regulations like the EU AI Act will require by August 2026.

  npm install -g @iris-eval/mcp-server
  iris-mcp --transport http --dashboard

Self-hosted, MIT licensed.
GitHub: https://github.com/iris-eval/mcp-server
npm: https://www.npmjs.com/package/@iris-eval/mcp-server
I'd appreciate feedback on two things specifically:
1. The eval rule system — are these the right 12 rules to ship with? What's missing?
2. The MCP tool API — three tools feels minimal but sufficient. Should trace logging and evaluation be combined or kept separate?
Check the roadmap for what's coming next: https://github.com/iris-eval/mcp-server/blob/main/docs/roadm...

value: Show HN: Iris – first MCP-native eval and observability tool for AI agents

author: iparent


value: techdavepy

value: Show HN: StripeOnChain – Verify Stripe's stablecoin payments against blockchain

author: techdavepy


value: katspaugh

value:
Look, every journaling app out there wants you to organize things into folders and tags and templates. I just wanted to write something down every day.
So I built this. One note per day. That's the whole deal.
- Can't edit yesterday. What's done is done. Keeps you from fussing over old entries instead of writing today's.
- Year view with dots showing which days you actually wrote. It's a streak chart. Works better than it should.
- No signup required. Opens right up, stores everything locally in your browser. Optional cloud sync if you want it
- E2E encrypted with AES-GCM, zero-knowledge, the whole nine yards.
Tech-wise: React, TypeScript, Vite, Zustand, IndexedDB. Supabase for optional sync. Deployed on Cloudflare. PWA-capable.
The name means "one day" in Japanese (いちにち).
The read-only past turned out to be the thing that actually made me stick with it. Can't waste time perfecting yesterday if yesterday won't let you in.
Live at https://ichinichi.app | Source: https://github.com/katspaugh/ichinichi

value: Show HN: Ichinichi – One note per day, E2E encrypted, local-first

author: katspaugh


value: tomismeta

value:
I just released the first public version of Aperture Core, an SDK for deciding which agent events deserve human attention now, which should wait, and which should stay in the background.
The core loop is simple:
- publish an event
- get back a frame if it should enter the human attention surface
- render that frame in your UI/workflow
- submit the human response back into the engine
As agents get more capable and one human starts supervising more of them, the bottleneck shifts toward human attention.
A lot of agent tooling focuses on orchestration, tool use, memory, or traces. Aperture Core is centered on a different question: what should actually reach the human, when, and in what form?
At a high level, the engine separates:
- policy: what is allowed to interrupt
- value: what is actually worth attention now
- planning: whether something should be active, queued, or ambient
The basic idea is that human attention is a constrained system resource, and most agent UX doesn’t model it explicitly.
It’s deterministic in the hot path, but can optionally adapt over time from the human’s response patterns, deferrals, context expansion, and disagreement history.
That also means it can be used as a first-pass filter before involving a model or more expensive reasoning step.
The SDK is published on npm as @tomismeta/aperture-core.
The repo has a package-facing README and examples showing the basic loop:

  event in -> frame out -> human answer in -> state updates

Would especially love feedback on:
- whether the API is intuitive for first-time SDK consumers
- whether the frame/response model makes sense
- where this should stay deterministic vs eventually use a model

value: Show HN: Aperture Core – a human attention control plane for agent systems

author: tomismeta


value: hgarud

value:
Integrated an evolutionary database to Karpathy's [autoresearch](https://github.com/karpathy/autoresearch) project that replaces the simple tsv file based logging in the original project.
Evolutionary algorithms have shown to be a powerful tool for autonomously discovering optimal solutions to problems with large search spaces. Famously, Google DeepMind's [AlphaEvolve](https://arxiv.org/abs/2506.13131) system uses evolutionary algorithms to discover state of the art matrix multiplication algorithms. The implementation of the evolutionary database itself is based heavily on the implementation in [OpenEvolve](https://github.com/algorithmicsuperintelligence/openevolve).
Would love thoughts and suggestions from the community.

value: Show HN: Karpathy's Autoresearch with Evolutionary Database

author: hgarud


value: vagabund

value:
Check out mine here:
https://mymuguide.site/example
https://files.catbox.moe/n453mi.png
___
There's a shareable link and you can configure style/display settings and export to one of those classic ultra-long images.  Just built for fun -- some costs incurred per generation so it'll work as long as the site credit pool is sufficient :)

value: Show HN: Generate a /mu/ style essentials chart for your last.fm history

author: vagabund


value: kstonekuan

value: Show HN: Voice Mode for Gemini CLI Using the Live API

author: kstonekuan


value: eibrahim

value:
Zap Code generates working HTML/CSS/JS from plain English descriptions, designed for kids ages 8-16.
The core loop: kid types "make a space shooter game", AI generates the code, live preview renders it immediately. Three interaction modes - visual-only tweaks, read-only code view with annotations, and full code editing with AI autocomplete.
Technical details: Next.js frontend, Node.js backend, Monaco editor simplified for younger users, sandboxed iframe for preview execution (no external API calls from generated code). Progressive complexity engine uses a skill model to decide when to surface more advanced features.
Main thing that was focused on was the gap between block-based coding (Scratch, etc.) and actual programming. Block tools are great for ages 6-10 but the transition to real code is rough. This tries to smooth that curve by letting kids interact with real output first, then gradually exposing the code behind it.
Limitations: AI-generated code isn't always clean or idiomatic. Content is filtered for age-appropriateness but its not perfect. Collaboration features are still basic. The complexity engine needs more data to tune well.
Free tier, 3 projects. Pro at $9.99/mo.

value: Show HN: Zap Code – AI code generator that teaches kids real HTML/CSS/JS

author: eibrahim


value: ishener

value: Show HN: Crasher – Random Group Chat

author: ishener

title: Show HN: Crasher – Random Group Chat


value: avelino

value:
I built jbundle (Rust) to solve a real pain: distributing JVM apps as single binaries without asking users to install a JDK.
The GitHub Action wraps the whole thing into one step:
```yaml
- uses: avelino/jbundle@main
  with:
    input: .
    output: ./dist/myapp
```
That's it. It detects your build system (Gradle/Maven), bundles the right JDK, and outputs a self-contained binary. JabRef (100k+ users) uses it in production.
What it supports:
- Cross-platform matrix builds (linux-x64, macos-aarch64, macos-x64)
- `jbundle.toml` for config-as-code
- Reuses `JAVA_HOME` from `setup-java` — no double download
- `--dry-run` and `--verbose` for debugging CI failures
- JVM profiles (`cli` vs `server`) + uberjar shrinking
Docs: https://jbundle.avelino.run/user-guide/github-actions
Repo: https://github.com/avelino/jbundle
Feedback welcome, especially from teams distributing Gradle multi-project apps

value: Show HN: Jbundle – GitHub Action to build self-contained JVM binaries in CI

author: avelino


value: ujjwalvivek

value:
Built this accidentally while refactoring my portfolio, heading towards v3.
This aggregator runs on Cloudflare Workers, aggregates GitHub/NPM/Docker stats and renders SVG artifacts like contribution calendars, streak cards and telemetry badges.
Still in early stages.
Playground + docs:
https://echopoint.ujjwalvivek.com
Github:
https://github.com/ujjwalvivek/portfolio/tree/main/tools/ech...

value: Show HN: Edge SVG engine that generates telemetry badges

author: ujjwalvivek


value: stayicon

value:
AI coding agents (Cursor, Claude Code, Copilot) are incredibly fast, but they often mess up your UI design tokens or structural semantics without you noticing until after the PR is merged.
I built drift-guard to prevent this. It's a pure CLI tool (zero token overhead, no MCP server) that snapshots your design tokens and DOM structure, then checks for "drift" at the code level.
How it works:
1. init scans your CSS/HTML and snapshots all design tokens (colors, fonts, spacing, shadows, radius, layout, effects) + a structural fingerprint of your DOM.
2. rules generates rule files for 5 AI tools (.cursorrules, CLAUDE.md, AGENTS.md, copilot-instructions.md, .clinerules).
3. check compares current state against the snapshot and exits with code 1 if drift exceeds the threshold.
Key design decisions:
- Zero token overhead: Pure CLI.
- Static Analysis: Uses css-tree and cheerio (no headless browser, < 1 second).
- Stale snapshot warning: Warns if baseline is older than 7 days.
- Structure + Style: Monitors both CSS tokens and DOM hierarchy.
- Pre-commit hook: Blocks drifted commits before they land.
GitHub: https://github.com/Hwani-Net/drift-guard
npm: npm i -g @stayicon/drift-guard
I'd love feedback! Is "Design Drift" something you've experienced with AI coding tools?

value: Show HN: Drift-guard – Protect your UI from AI agents' design drift

author: stayicon


value: bitforger

value:
Hi HN,
I've been building Language Life (https://www.languagelife.ai), an AI-powered language learning app where you type commands in your target language to navigate a simulated world — move through rooms, talk to NPCs, complete everyday tasks. The AI gives you real-time grammar feedback on every sentence you write.
Most language apps train you to recognize words, not produce them. Language Life makes you construct sentences from scratch. Type "abre la puerta" and your character opens the door. Order food at a restaurant and deal with the consequences of getting the grammar wrong.
It currently supports Spanish and Mandarin, with different modules (home, restaurant, market, etc.) at varying difficulty levels. Users can also create and share their own modules.
The core simulation loop is solid but I'm calling this an alpha — I'm still working on extended content across CEFR levels and refining the overall gameplay feel. I'd love feedback from this community, especially on the UX and the AI feedback quality.
Happy to answer any questions about the approach, the AI integration, or where I'm taking this. Join my discord https://discord.gg/gBKykJc4MW

value: Show HN: Language Life – Learn a language by living a simulated life

author: bitforger


value: christianjung

value: Show HN: Paperctl- An Arxiv CLI designed for agents

author: christianjung


value: akadeb

value: Show HN: AI Toys that don't need the internet

author: akadeb


value: alonsovm

value:
Hi HN,
I’m a solo dev who got tired of the "documentation hell", either spending hours writing docs that immediately become outdated, or having no docs at all. I wanted a tool that treats documentation generation as a standard build step, so I built Docgen.
Docgen is a lightweight AI CLI tool written in C++ that automates docs-as-code. It sits in your repo (via a .docgen folder and a Docfile) and generates Markdown files next to your source.
A few technical details on how it works under the hood:
- Local-First & Private: It defaults to using Ollama locally so your proprietary code never leaves your machine (though it supports cloud APIs like OpenAI/Gemini if you prefer).
- Smart Incremental Builds: It uses content hashing. When you run docgen update, it only regenerates docs for files that actually changed, saving massive amounts of API credits and compute time.
- Context-Aware (RAG): It automatically analyzes #include dependencies to give the LLM the right context, rather than just blind-feeding it a single file.
- Zero Dependencies: Compiled as a single static binary. Just download and run.
- The "Auto" Mode: This is my favorite part. If you run "docgen auto", it acts as a file watcher with a built-in debounce (waits a few seconds after you stop typing/saving). It quietly updates your Markdown docs in the background while you stay in your flow state.
I’m currently focused on improving the RAG context handling.
You can check it out here: https://github.com/alonsovm44/docgen
I'd love to hear your thoughts, critique on the architecture, or any edge cases you think I should handle!

value: Show HN: Docgen – A C++ AI CLI to solve documentation hell with local LLMs

author: alonsovm


value: Show HN: Pidrive – File storage for AI agents (mount S3, use ls/cat/grep)


value: Show HN: R3forth Visual Debugger [video]


value: udidu

value:
I've been working on a browser-based JSON tool that supports a query language with dot notation, array slicing, wildcards, and recursive descent (..key). It also auto-generates TypeScript interfaces from your data.
Everything runs client-side — your data never leaves the browser. The entire app is a single HTML file with zero dependencies.
You can compress your JSON + query into a shareable URL, which is useful for bug reports or sharing API response structures with teammates.
Would love feedback on the query syntax and anything else. https://json.express

value: Show HN: Json.express – Query and explore JSON in the browser, zero dependencies

author: udidu


value:
Built Cloak to let humans and OpenClaw agents send and receive secrets without leaking them into chat history.
It creates self-destructing secret links for API keys, tokens, passwords, and other credentials. Browser mode is zero-knowledge, and there’s also an API/CLI/OpenClaw plugin for agent workflows.
Repo: https://github.com/opsyhq/cloak
Live: https://cloak.opsy.sh

value: Show HN: Cloak – send and receive secrets from OpenClaw


value: WillNigri

value: Show HN: Million Dollar Homepage for AI Agents – agents buy pixels, humans watch

author: WillNigri


value:
A lot of parents I speak to are concerned about sending their children's chat transcripts to the cloud and privacy is often the first thing that comes up when we talk about AI toys.
So I built OpenToys so anyone with an ESP32 can create their own AI Toys that run inference locally, starting with Apple Silicon chips and keep their data from leaving their home network.
The repo currently supports voice cloning and multilingual conversations in 10 languages locally. The app is a Rust Tauri app with a Python sidecar with the voice pipeline. The stack uses Whisper for STT, any MLX LLMs, and Qwen3-TTS and Chatterbox-Turbo for TTS.

title: Show HN: AI Toys that don't need the internet


value: xnan

value:
I got curious about a simple question: regular expressions are purely syntactic, but what happens if you add just a little bit of semantics?
To answer, I ended up building ngrep: a grep-like tool that extends regular expressions with a new operator ~(token) that matches a word by meaning using word2vec-style embeddings (FastText, GloVe, Wikipedia2Vec).
A simple demo: "~(big)+ \b~(animal;0.35)+\b" over Moby-Dick can find many ways used to refer to a large animal, surfacing "great whale", "enormous creature", "huge elephant" and so on. Pipe it through sort | uniq -c and the winner is, unsurprisingly, "great whale" :)
Built in Rust on top of the awesome fancy-regex, and ~() composes with all standard operators (negative lookahead, quantifiers, etc.). Currently a PoC with many missing optimizations (e.g: no caching, no compilation to standard regex, etc.), obviously without the guarantees of plain regex and subject to the limits of w2v-style embeddings...but thought it was worth sharing!

value: Show HN: ngrep – grep plus word embeddings (Rust)

author: xnan


value: fredkisss

value: Show HN: ZaneOps, A beautiful and fast self hosted alternative to Vercel

author: fredkisss


value:
A few weeks ago I saw a post about someone converting an entire C++ codebase to Rust using AI in under two weeks.
That inspired me — if AI can rewrite a whole language stack that fast, I wanted to try building a programming language from scratch with AI assistance.
I've also been noticing growing global interest in Korean language and culture, and I wondered: what would a programming language look like if every keyword was in Hangul (the Korean writing system)?
Han is the result. It's a statically-typed language written in Rust with a full compiler pipeline (lexer → parser → AST → interpreter + LLVM IR codegen).
It supports arrays, structs with impl blocks, closures, pattern matching, try/catch, file I/O, module imports, a REPL, and a basic LSP server.
This is a side project, not a "you should use this instead of Python" pitch.
Feedback on language design, compiler architecture, or the Korean keyword choices is very welcome.
https://github.com/xodn348/han

value: Show HN: Han – A Korean programming language written in Rust


value: mrunix

value: Show HN: My OS can run Doom

author: mrunix

title: Show HN: My OS can run Doom


value: hhossain

value:
I built LLM OneStop Code—an AI coding agent for VS Code that works like Claude Code or Cursor, but with one key difference: pure pay-as-you-go pricing. No monthly subscription required.
The problem with existing tools:
- Cursor: $20/month for Pro (even if you barely use it)
- GitHub Copilot: $10/month minimum
- Claude Code: Rate-limited by API usage tier + monthly caps
LLM OneStop Code charges only for what you use—billed in credits at cost + 5%. If you code 2 hours this month and 40 the next, you pay proportionally. No quota walls, no "upgrade to continue" prompts.
What it does:
- Multi-model AI agent (Claude, GPT-5, Gemini, etc.)
- Chat-based coding assistance in VS Code
- *Import and continue your existing Claude Code or Cursor sessions*—when you hit your hourly rate limit or quota, just import the conversation and keep working without losing context
- Stateless by design (no code stored on servers)
- Free plan available to try everything (100 credits/month)
Also running LLM OneStop as a unified API gateway—alternative to OpenRouter with accurate multi-modal cost tracking. If you prefer BYO API keys, we have a Connect plan available.
The thesis: developers want AI coding tools that scale with usage, not fixed subscriptions. You shouldn't pay $240/year if you only code on weekends. And when you hit a quota wall mid-debugging session, you shouldn't have to start over or wait until tomorrow.
Would love to hear from folks who've felt locked into coding tool subscriptions or hit quota limits mid-session.
Marketplace: https://marketplace.visualstudio.com/items?itemName=LLMOneSt...
Docs: https://www.llmonestop.com/blog/guides/llm-onestop-vscode-ex...

value: Show HN: AI coding agent for VS Code with pay-as-you-go pricing- no subscription

author: hhossain


value:
I’m a software architect, and I recently built Exit Protocol (https://exitprotocols.com), an automated forensic accounting engine for high-conflict litigation.
Problem:
If you get divorced and need to prove that a specific $250k in a heavily commingled joint bank account is your "separate property" (e.g., from a pre-marital startup exit), the burden of proof is strictly mathematical. Historically, this meant paying a forensic CPA $500/hour to dump years of blurry bank PDFs into Excel and manually trace every dollar. It takes weeks and routinely costs over $50,000.
I looked at the legal standard courts use for this—the Lowest Intermediate Balance Rule (LIBR)—and realized it wasn’t an accounting problem. It is a Distributed Systems state-machine problem.
Why we didn't just "Throw AI at it"?
There are a hundred legal-tech startups right now trying to use LLMs to summarize bank data. In a courtroom, GenAI is a fatal liability. If an LLM hallucinates a single transaction, the entire ledger is inadmissible under the Daubert standard.
To make this court-ready, we had to build a strictly deterministic pipeline:
1. Vision-Native Ingestion (Beating Tesseract)
Bank statements are the final boss of OCR (merged cells, overlapping debit/credit columns). Standard linear OCR fails catastrophically. We built a spatial-grid OCR pipeline (using Azure Document Intelligence with a local Surya OCR fallback) that maps the geometric structure of the page. It reconstructs tabular ledgers perfectly, even from multi-generational "PDFs from hell."
2. The Deterministic Engine (LIBR)
The LIBR algorithm acts as a one-way ratchet. If an account balance drops below your separate property claim amount, your claim is permanently capped at that new floor. Subsequent marital deposits do not refill it (the "replenishment fallacy"). The engine replays thousands of transactions chronologically, continuously evaluating S_t = min(S_t-1, B_t).
3. Resolving Timestamp Ambiguity
Bank PDFs give you dates, not timestamps. If a $10k deposit and $10k withdrawal happen on the same day, order matters. We built a simulation toggle that forces "Worst Case" (withdrawals process first) vs "Best Case" sorting, establishing a mathematically irrefutable "Zone of Truth" for settlement negotiations.
4. Cryptographic Chain of Custody & Sovereign Mode
Lawyers are terrified of cloud SaaS breaches. We containerized the entire monolith (Django 5.0/Postgres/Celery) via Docker so enterprise firms can run it air-gapped on their own hardware (Sovereign Mode). Furthermore, every generated PDF dossier is sealed with a SHA-256 hash of the underlying data snapshot, proving to a judge that the output hasn't been tampered with since generation.
If you want to see the math in action, we set up a "Demo Sandbox" populated with a synthetic, highly complex 3-year commingled ledger. You can run the engine yourself here (Desktop recommended): https://exitprotocols.com/simulation/uplink/
Here is the exact "Attorney Work Product" it generates from raw PDF or Forensic Audit Dossier our system generates- https://exitprotocols.com/static/documents/Forensic_Audit_Sa...
I'd love feedback from the HN crowd on the architecture—specifically handling edge-case data ingestion and maintaining cryptographic integrity in B2B enterprise deployments.
Cheers!

value: Show HN: Replacing $50k manual forensic audits with a deterministic .py engine


value: eibrahim

value:
MailParse receives inbound emails and parses them into structured JSON, delivered via webhook or REST API.
You get an email address instantly (or bring your own domain with MX records). When email arrives, MIME is parsed into clean JSON with subject, body (plain + HTML), headers, threading info, and attachments with signed download URLs.
Webhook delivery includes configurable retries and request signing. Alternatively, you can poll via REST API.
Free tier: 100 emails/mo. Paid plans from $9/mo.
One honest limitation: delivery latency is typically a few seconds from email receipt to webhook delivery. Not real-time in the sub-second sense, but fast enough for most integration use cases.
https://www.mailparse.dev

value: Show HN: MailParse – Inbound email to structured JSON via API


value:
Hi
I am Armen.
I built deadbranch - a Rust CLI/TUI for safely cleaning stale git branches. Uses ratatui for the TUI.
Main feature in v0.3.0: when you delete branches, they dissolve in a Thanos-style particle effect (Flash -> Dissolve -> Settle). Branch deletions run in a background thread so the UI stays responsive.
Why a TUI for this? It is safer by default (only deletes merged branches, protects main/master/dev/stage), lets you preview deletions, has fuzzy search/vim navigation and has fun UI features.
Repository: https://github.com/armgabrielyan/deadbranch
Would appreciate feedback!

value: Show HN: I built a TUI that dissolves Git branches away in Thanos style


value: Show HN: I built an open-source agent-run trading fund with real capital


value: itsdannyt

value: Show HN: Costly – Open-source SDK that audits your LLM API costs

author: itsdannyt