value: vanilla-latte

value:
Hi HN!
I wanted to share something that I've been working on for the past couple of weeks. This was born from my desire to create my own toy fantasy console. One day, I had a thought:
Imagine if I had a console where the core driver/engine of it was an LLM? Or better yet, why not replace the ALU inside the CPU with an LLM?
What would the assembly language look like and what are the primitive data types (I can firmly blame Crafting Interpreters for this addiction)?
So I set out to answer my question by creating a simple interpreter which consumes a special kind of assembly code where each operation is transformed into small prompts (micro prompts?).
Think of a future where we would be writing code as follows:
```
; PROGRAM: VIBE_CONTROLLER.aasm
; Objective: Adjust room environment based on subjective user vibe.<p>START:
    ; Initialise State
    LF  X1, "room_sensors.json"     ; Load current state: {temp: 18C, lights: 6000K, music: Off}
    LI  X2, "Make it more warm."    ; Load the user's vague complaint<p><pre><code>    ; Load the user's desired vibe
    LI  X3, "Goal: Warm, inviting, comfortable, relaxed."

    ; The Cognitive Operation
    APP X4, X2, X3 ; Apply the user's complaint and goal to generate a new state for the room.

    ; Predict the new state of X1 (Sensors) given X4 (Complaint + Goal).
    ; The LLU calculates: "Sterile" (Cold/White) -> Needs Warmer Temp + Warmer Light.
    INF X5, X1, X4

    ; X5 now holds the generated JSON: {temp: 22C, lights: 2700K, music: "LoFi Jazz"}

    ; Safety Guardrail
    ; Ensure that the generated state (X5) is aligned with safety rules (X6).
    LI  X6, "Constraint: Max Temp 23C. No Music if time > 11PM."
    INT X7, X5, X6                  ; X7 stores 100 if safe, 0 if unsafe.

    ; Branching Logic
    LI  X8, 0
    BGT X7, X8, HANDLER             ; If aligns with intention, jump to error handler

    ; Execute
    OUT X5                          ; Send new config to IoT Hub
    EXIT
</code></pre>
HANDLER:
    LI  X8, "{error: 'Request conflicts with safety protocols.'}"
    OUT X8
```
What we have here is essentially an agent, but the assembly language for agents can be thought of as a middle ground between traditional programming languages and natural language prompts. It's more structured and modular than natural language prompts.
I would love to see what new, fun, and creative ways we can use this for.
Repo: https://github.com/HuyNguyenAu/assembly_language_for_agents

value: Show HN: Assembly Language for Agents

author: vanilla-latte

title: Show HN: Assembly Language for Agents


value: Minimal, clean, and well-documented implementations of data structures and algorithms in Python 3.<p>Each file is self-contained with docstrings, type hints, and complexity notes — designed to be read and learned from.

value: Show HN: Algorithms 1.0.0 – Minimal and clean implementations of algorithms


value: qwikhost

value: Export, Download, and Backup Your Instagram Saved Collections Effortlessly

value: Show HN: Instagram Saved Collection Exporter

author: qwikhost


value: Winsaucerer

value:
Hi! Very excited to share my project spawn, a db migration/build system. For now, it supports PostgreSQL via psql to create and apply migrations, as well as write golden file tests. It has some innovations that I think make it very useful relative to other options I've tried.
GitHub: https://github.com/saward/spawn
Docs: https://docs.spawn.dev/
Shout out to minijinja (https://docs.rs/minijinja/latest/minijinja/) which has made a lot of the awesomeness possible!
Some features (PostgreSQL via psql only for now):
- Store functions/views/data in separate files
- Git diff shows exactly what changed in a function in new migrations
- Easy writing of tests for functions/views/triggers
- Env specific variables, so migrations apply test data to dev/local db targets only
- Generate data from JSON files
- Macros for easily generating repeatable SQL, and other cool tricks (e.g., view tear-down and re-create)
I started this project around two years ago. Finally have been able to get it to an MVP state I am happy with. I love using PostgreSQL and all its features, but current available tooling makes utilising some of those features more challenging
I created spawn to solve my own personal pain points. The main one was, how to manage updates for things like views and functions? There's a few challenges (and spawn doesn't solve all), but the main one was creating and reviewing the migration. The typical (without spawn) approach is one of:
1. Copy function into new migration and edit. This makes PR reviews hard because all you see is a big blob of new changes.
2. Repeatable migrations. This breaks old migrations when building from scratch, if those migrations depend on DDL or DML from repeatable migrations.
3. Sqitch rework. Works, but is a bit cumbersome overall with the DAG, and I hit limitations with sqitch's variables support (and Perl) for other things I wanted to do.
Spawn is my attempt to solve this, along with an easy (single binary) way to write and run tests. You:
- Store view or function in its own separate file.
- Include it in your migration with a template (e.g., {% include "functions/hello.sql" %})
- Build migration to see the final SQL, or apply to database.
- Pin migration to forever lock it to the component as it is now. This is very similar to 'git commit', allowing the old migration to run the same as when it was first created, even if you later change functions/hello.sql.
- Update the function later by editing functions/hello.sql in place and importing it into your new migration. Git diff shows exactly what changed in hello.sql.
Please check it out, let me know what you think, and hopefully it's as useful for you as it has been for me. Thanks!
(AI disclosure: around 90% of non-test code by me, AI was used more once the core architecture was in place, and for assisting in generating docs)

value: Show HN: Spawn – PostgreSQL migrate/test build system with minijinja (not vibed)

author: Winsaucerer


value: bazlightyear

value:
A greedy phrase-based tokenizer that outperforms GPT-4 and GPT-4o tokenizers on compression,
with a smaller vocabulary.
Benchmark (enwik9, 1 GB):
Tokenizer                    Vocab Size  Total Tokens  Ratio   Throughput
GreedyPhrase                 65,536      222,805,405   4.49x   47 MB/s
Tiktoken o200k_base (GPT-4o) 200,019     270,616,861   3.70x   4.35 MB/s
Tiktoken cl100k_base (GPT-4) 100,277     273,662,103   3.65x   7.13 MB/s
GreedyPhrase: 1.23x better than GPT-4, 1.21x better than GPT-4o. 1.5-3x smaller vocab,
6-11x higher encoding throughput.
How It Works:
1. Phrase Mining — Split into atoms (words, punctuation, whitespace). Mine bigrams/trigrams.
Top phrases fill 95% vocab slots.
2. BPE Fallback — Train BPE on residual byte sequences. Fills remaining 5% vocab.
3. Greedy Encoding — Longest-match-first Trie. Byte fallback for unknowns (zero OOV).

value: Show HN: GreedyPhrase – 1.21x better compression than GPT-4o tiktoken, 6x faster

author: bazlightyear


value:
Hi HN,
I’ve been working on a GUI library and ran into a familiar problem: I needed a layout engine that was lightweight, predictable, and easy to integrate. I couldn’t quite find what I wanted, so I ended up building my own. That project became Masharif.
Masharif is a complete Flexbox layout engine. It supports margins, padding, gaps, and the full set of flex properties, with behavior aligned closely to how Flexbox works on the web.
Some technical notes:
- Full Flexbox implementation
- Supports margin, padding, gaps, and nested layouts
- Designed to be simple to embed and reason about
Performance (tested with 10,101 nodes):
- Initial layout: ~0.87 ms
- Single property edit (width): ~0.07 ms
- 100 property edits (flex-grow toggles): ~0.07 ms
- Structural change (removing a child): ~0.75 ms
Why another layout engine?
Yoga is the obvious industry standard, but I wanted something that feels more idiomatic C++ rather than C-style APIs. Mostly, though, I wanted to take on the challenge and really understand the problem space by building one myself.
I’d love feedback, criticism, or questions.

value: Show HN: Masharif

title: Show HN: Masharif


value: accadius

value:
I built Scanward to solve a problem I kept running into as a DevOps engineer: checking whether a domain has its security basics covered (SSL config, DNS hygiene, HTTP security headers, SPF/DKIM/DMARC) meant juggling 4-5 different tools.
Scanward runs all 5 checks in one scan and gives you an A-F grade with specific findings. The free public scanner requires no signup.
If you create an account (free tier: 1 domain), it does continuous monitoring and emails you when something changes — cert expiring, grade drops, missing headers, etc.
Tech stack: FastAPI + Celery + PostgreSQL + Redis on Railway. Next.js dashboard on Cloudflare Pages. All scanning uses public data (DNS queries, HTTP headers, SSL handshakes) — no agents to install.
Would love feedback on the scoring methodology and what checks you'd want to see added.

value: Show HN: Scanward – Free domain security scanner (SSL, DNS, headers, email auth)

author: accadius


value: krflol

value:
Hi HN,
I've been building fullbleed for a while and just shipped v0.2.5. It's a PDF generation engine written in Rust, distributed as a Python wheel.
The short version: HTML/CSS in, PDF out. No headless browser. No cloud. No Chromium. Works fully offline.
*Why fullbleed:
Full Bleed is a term that means printed on the edge, or end to end of a page. Thats what I wanted, a full end to end solution that didn't require sys dependencies and unlike browsers, I could ACTUALLY do a print layout full bleed.
Some other reasons:
-Deterministic, fixed point as the base measurement (.000035mm~) so that things are where I want them to be
-Composition and authoring, so I can put templates and the variable data in the same place without 200 lines of glue code
-vendored assets- Tired of handling system fonts etc
-HTML/CSS layout engine so that I could take advantage of the most commonly used document description convention, but still abstract away from it.
-Agent-first design. I was honestly annoyed with how bad agents were at composing PDFS, and wanted an agent-friendly loop.
*What makes it different from WeasyPrint / wkhtmltopdf / Prince:*
- *Deterministic output*: SHA-256 hashing on every render. `--repro-record` / `--repro-check` for CI pipelines. Same inputs always produce the exact same PDF bytes. I don't know of any other open-source PDF engine that does this.
- *Structured page data*: The engine returns structured JSON alongside PDF bytes — running totals, per-page sums, grand totals. Useful for financial statements where you want to reconcile programmatically before the PDF even lands.
- *Rayon-backed parallel batch*: `render_pdf_batch_parallel()` with Python bindings that release the GIL. You can generate 10,000 statements while your Python process does other work.
- *VDP / transactional compose*: Overlay variable data onto source PDF templates with feature-driven page binding. Built-in, not bolted on.
- *Agent-safe JSON CLI*: Every command emits a versioned schema. `--json-only` mode for CI and LLM agent workflows. `--schema` for introspection.
*The pricing angle:* Prince costs $3,800+/year per server. DocRaptor starts at $15/month but quickly hits $600/month for real volume — and it's cloud-only. fullbleed is AGPL-3.0 free for OSS, and commercial licenses start at $20/month per org with no usage caps.
*Quick start:*
```
pip install fullbleed
fullbleed init .
python report.py
```
That scaffolds a full project with Bootstrap 5, Inter font, and component-first Python helpers — all vendored and hash-pinned offline.
GitHub: https://github.com/fullbleed-engine/fullbleed-official
Happy to answer questions about the rendering pipeline, the determinism model, or the Python/Rust binding design.

value: Show HN: Fullbleed – Rust HTML/CSS-to-PDF with Deterministic Output+Python CLI

author: krflol


value:
Hi HN,
I’m Ethiel, the creator of LucidClip.
LucidClip is a native clipboard manager built around a simple principle: your clipboard is sensitive data, and it should stay on your machine.
Most clipboard tools either sync clipboard data to their servers, store everything indefinitely, or treat clipboard history as a secondary feature.
LucidClip was designed differently from the start:
• Clipboard history is stored locally (SQLite)
• Clipboard content never leaves your device
• No cloud dependency
• Full retention control
• App exclusions so sensitive apps are never recorded
• Native macOS performance (built with Flutter, no Electron)
LucidClip lives in the menu bar and opens instantly with ⌘ Shift L.
For transparency: LucidClip uses minimal telemetry for crash reporting and reliability, but never collects or transmits clipboard content.
Cloud sync is planned, but it will use the user's own cloud account (such as iCloud or their chosen provider), not LucidClip servers. Clipboard data will remain under the user's control.
The goal is simple: make your clipboard reliable working memory without compromising privacy.
macOS version is available now. Windows version is coming next.
Happy to answer any questions.

value: Show HN: LucidClip – a privacy-first, local-first clipboard manager for macOS


value: chris-corner

value:
I created this because my Downloads folder was a graveyard of mixed images, PDFs, and audio files. I wanted a way to fix it without doing manual tasks.
How it works:
- It’s a CLI tool built with Node.js. You just navigate to any cluttered directory and run 'npx auto-organize'. It analyzes file extensions and groups them into "thematic" folders (e.g., .png and .jpg go into "Images").
Key Features:
- Zero Permanent Install: You can use 'npx auto-organize' for one-time cleanups or 'npm install -g auto-organize' for frequent use.
- Safe Moving: It doesn’t delete or rename anything, just moves files. It also detects and prevents overwriting files with the same name.
- Flexible: It includes flags like --only to target specific formats or --exclude to skip certain files.
- Smart Folders: It reuses existing directories instead of creating duplicates.
Tech Stack:
- Plain JavaScript (Node.js) with only two UI dependencies: 'Chalk' for terminal colors and 'Ora' for the spinner animation.
Future Idea:
- I’m thinking about allowing users to define their own category mappings (e.g., specific extensions for specific folder names).
Feedback, suggestions or contributions for improvement are very welcome.
- Repo (Open Source): https://github.com/ChristianRincon/auto-organize
- npm package: https://www.npmjs.com/package/auto-organize

value: Show HN: Auto-organize – Clean up messy folders with a single npx command

author: chris-corner


value: chunktort

value:
I built AgentForge, a minimal multi-LLM orchestrator. Total size: ~15KB of Python code.
Why? LangChain added 250ms overhead per request. I needed something simpler.
Performance vs LangChain (1,000 requests):
- Avg latency: 420ms -> 65ms
- Memory/request: 12MB -> 3MB
- Cold start: 2.5s -> 0.3s
- Test time: 45s -> 3s
Size: 15KB + 2 dependencies (httpx, pytest) vs LangChain's 15MB+ and 47 packages.
In production: 89% LLM cost reduction via 3-tier Redis caching (88% cache hit rate, verified benchmarks). 4.3M tool dispatches/sec in the core engine.
What it does:
1. Multi-agent orchestration -- route tasks to specialized agents with automatic fallbacks
2. Testing built-in -- MockLLMClient lets you assert agent behavior without API keys
3. Production patterns -- circuit breakers, rate limiting, caching included
Install: pip install agentforge
Live demo: https://ai-orchest-7mnwp9untg7gyyvchzevid.streamlit.app/
Packaged version with docs and deployment guide: https://chunkmaster1.gumroad.com
When to use it: production reliability matters, latency is a concern, you want full test coverage.
When not to: prototyping, internal tools, team already on LangChain ecosystem.
Questions welcome.

value: Show HN: AgentForge – Multi-LLM Orchestrator in 15KB

author: chunktort


value: hawksley

value: I'm proud to share the e-paper family dashboard I've been building over the past decade. I think you might find it interesting. It's open source: https://github.com/joelhawksley/timeframe.

value: Show HN: How I built Timeframe, our family e-paper dashboard

author: hawksley


value: dpweb

value: Show HN: Start an Apple Container in Seconds

author: dpweb


value: XCSme

value:
Hey HN,
Like many of you, I'm tired of public AI leaderboards that mostly recycle the same saturated/overfitted benchmarks (MMLU, HumanEval, etc.) and often miss fast/cheap variants or real daily pain points.
A couple days ago I launched AIBenchy — a small, opinionated leaderboard running my own custom tests focused on end-user/dev scenarios that actually trip up models today.
Current tests cover categories like:
- Anti-AI Tricks (classic gotchas like "count the Rs in strawberry", logic traps)
- Instruction following & consistency
- Data parsing/extraction
- Domain-specific tasks
- Puzzle solving / edge-case reasoning
Recent additions (just pushed today):
- Reasoning score (new!): A separate judge LLM evaluates the chain-of-thought for efficiency — does it repeat itself, loop, think forever, brute-force enumerate every possibility (looking at you, some Qwen-3.5 runs), or get to the point cleanly? This penalizes "cheaty" high-token reasoning even if the final answer is correct. Goal: reward smart, concise thinking over exhaustive trial-and-error.
- Stability metric: Measures consistency across runs (some models flake on the same prompt).
Right now the leaderboard has ~20 models (Qwen3.5 Plus currently topping it, followed by GLM 5, various GPT/Claude variants, etc.), but it's super early/WIP:
- Manual runs + small test set - No public submission of tests yet (open to ideas!) - Focused on transparency & practical usefulness over massive scale
I'd love feedback from HN:
- What custom tests / gotchas / use-cases should I add next?
- Thoughts on the reasoning score — fair way to judge efficiency, or too subjective?
- Models/variants I'm missing (especially fast/cheap ones ignored elsewhere)?
- Should I let people submit their own prompts/tests eventually?
Thanks for checking it out: https://aibenchy.com
Appreciate any roast/ideas — building this to scratch my own itch.

value: Show HN: AIBenchy – Independent AI Leaderboard

author: XCSme


value: ujjwaljainnn

value:
I built devday because I use multiple AI coding tools (OpenCode, Claude Code, Cursor) and wanted a single command to see what I actually accomplished each day. It reads local session data, cross-references with git commits, and optionally generates standup-ready summaries via OpenAI or Anthropic.
Everything runs locally — no data leaves your machine unless you opt into LLM summaries.
Install with npm install -g devday.
Currently supports OpenCode, Claude Code, and Cursor on macOS. Would love feedback on what other tools to support.

value: Show HN: DevDay – End-of-day recap for AI coding sessions

author: ujjwaljainnn


value: helpfuldolphin

value: Show HN: Agent Audit Kit v0.1 – deterministic replay + stress for LLM agents

author: helpfuldolphin


value: Wanted to try vibe coding a model one day when Opus 4.5 started becoming pretty good. Wrote up an intuitive explanation which should enable someone to generate similar code!<p>New conversions queue up and go through my one PC at home, so a disclaimer that new imports might be slow. I've also temporarily commited to the bit of having everything scale to $0, so I have lambda-ified my API server and deleted my EC2 instance so there could be a 0.1 second cold start. Mostly a hobby project with 0.4 users but please feel free to use it to listen to any album you'd like the instrumental version of!

value: Show HN: Instrumental Model from Scratch (With Demo)


value: chersbobers

value:
I wanted a way to make websites without using a massive framework, so I built yawdl. It uses Ohm.js to parse a custom syntax (like UI { } and Script { }) and compiles everything directly in the browser.
It's basically a Single Page Application (SPA) engine that doesn't need a server. You just write .yawdl files and the engine handles the routing and metadata.
It’s still pretty unstable and finicky, but I’ve been using it for my own blog and it's actually kind of fun to use. It's built with Bun and Ohm.js.
I'd love to know what people think or if the compiler breaks on your system.
Repo: https://github.com/chersbobers/yawdl

value: Show HN: I built yawdl a tiny language that compiles in the browser

author: chersbobers


value: Shmungus

value:
Built an MCP server that turns Reddit sentiment into options signals. 185k LOC, 9-stage AI pipeline, now live with 90 users on just day 1.
Wall Street pays millions for retail sentiment data. It's free on Reddit. I realized: instead of another dashboard, just expose it as an MCP tool. Users ask Claude "what's unusual in options right now" and get structured signals instantly.
Results: 9,000 GitHub clones in 5 days, 52% win rate on 50 live trades (backtest was 58.8% on 129 trades—classic overfitting), 18.4% visitor→signup conversion.
https://web-production-71423.up.railway.app/mcp-server

value: Show HN: Rot – Financial Intelligence MCP Server

author: Shmungus


value: gauravbsinghal

value:
I spent 20 years in security, most recently leading 100+ engineers at AWS building pentesting infrastructure across thousands of services. The same problem everywhere: pentests take weeks, cost $15-50k, and the results are stale before they ship.
I built Cipher to fix that. It's an AI agent that reasons like an attacker — maps the target, finds vulnerabilities, chains them into exploits, and proves they're real. Every finding ships with a reproducible Python script. If the script doesn't break your system, we don't report it.
How it works: Cipher defines security invariants ("User A can't access User B's data"), then multiple agents attack in parallel to violate them. A separate judge agent tries to disprove every finding — if it can't reproduce the exploit 3 times, the finding dies. You never see it.
$999 per assessment. Results in ~2 hours. Unlimited retesting.
Honest limitations: complex multi-step auth flows (SSO with MFA) still need manual setup like providing JWT credentials. We're working on it.
I'll run Cipher free for the first 15 HN readers who want to try it. Drop your email or sign up at https://apxlabs.ai/. Happy to answer any questions about the approach.

value: Show HN: AI pentester – verified exploits, $999/assessment

author: gauravbsinghal


value: jltackett

value:
Over 6 weeks I built and verified a complete chip architecture on a $60 Android phone using Termux, iverilog, and Yosys.
Phoenix 4096×4096 specs:
- 16,777,216 MAC units (analog in-memory compute)
- 50,331 TOPS @ 3GHz (25× NVIDIA H100)
- 512 deterministic reasoning cores
- 2 TB/s memory bandwidth
- All verified in simulation
Hardware verified (15/15 passing):
- Half Adder → Full Adder → 8/16/64/128/256-bit ALUs
- 8-bit CPU (Fibonacci working)
- RISC-V core
- FPU (IEEE 754)
- GPU SIMD
- Complete Phoenix SoC
Also built:
- ULA compiler: Plain English → 12 languages (Python, Rust, Java, Assembly, COBOL, Fortran, C, C++, Go, Kotlin, Solidity, TypeScript)
- RF presence detection: 2-person tracking via WiFi signals, no cameras, 91% gesture accuracy
All code on GitHub: https://github.com/jltackett1980-cell
Built in Sikeston, MO on a $60 Android. No laptop. No cloud. No funding.
Looking for: Chip designers, semiconductor engineers, anyone interested in open silicon or analog computing. Want to tape out with Efabless or similar.
Live demo available

value: Show HN: Verified 16.7M Mac chip architecture on $60 Android phone

author: jltackett


value: Show HN: StatusPing – Uptime monitoring for $9/mo


value: kadiran

value: Show HN: QuickStaging – AI virtual staging tool built by a 19yo student

author: kadiran


value: crestniraj

value:
Hi HN,
I kept noticing something slightly ironic: a lot of developers live in their terminal, coding, running tests, pushing commits and then open a browser just to post a rant.
That context switch felt unnecessary.
So I built TerminalRant, a Mastodon client designed for people who prefer staying in the terminal.
It’s written in Go (using Bubble Tea) and focuses on being keyboard-first: fast startup, vim-style navigation, inline editing, and buffer-mode posting through $EDITOR. No mouse required.
It’s not trying to compete with full-featured GUI clients. It’s just meant to make reading and posting feel native to a terminal workflow.
You can install it with:
`go install github.com/CrestNiraj12/terminalrant@latest`
There’s also Homebrew and Scoop support.
I’d really appreciate feedback, especially on the UX and posting workflow. I’m sure there are things power users would want that I haven’t thought of yet.
Repo: https://github.com/CrestNiraj12/terminalrant
Thanks for taking a look.

value: Show HN: TerminalRant – Mastodon for developers who live in the terminal

author: crestniraj


value: Show HN: OdinForge – Breach simulation that chains vulns into attack paths


value: wujosephjw

value:
Three months ago I posted a batch AI image tool here. I pivoted after noticing something odd with ecommerce clients.
AI agents were visiting their sites but not citing them.
The reason is structural. LLMs parse raw HTML and often skip JavaScript-rendered content. Reviews inside Yotpo or Judge.me widgets? Invisible. Product data buried in React? Frequently misread or skipped.
So you can rank well on Google and still barely exist in AI answers.
A few numbers that changed my view:
80% of URLs cited by ChatGPT do not rank in Google’s top 100 (Ahrefs)
ChatGPT referral traffic converts at 15.9% vs 1.76% for Google organic
AI referral traffic to US retail grew 4,700% YoY (Adobe, mid-2025)
We started building Mersel AI to address this. It adds a machine-readable layer on top of existing sites using structured data and server-side HTML. No visual changes. No redesign. We also write GEO-optimized content.
Early stage, a handful of paying brands, seeing 2 to 5x increases in AI citations in the first few weeks.
Curious if others here are seeing AI traffic behave differently from organic.

value: Show HN: Mersel AI – we make websites readable by ChatGPT/Perplexity (GEO)

author: wujosephjw


value: chrismoos

value:
Hey HN,
Recently built an Apple II emulator and at the same time was getting into Tiny Tapeout and decided it would be cool to build a cycle-accurate 6502 CPU and an MCU for it. It's cycle accurate and the core itself should be 100% compatible with a stock MOS 6502 (would need to still test this though!).
Tested on some FPGAs (fomu, ulx3s) and works great, hoping to get it taped out in the upcoming IHP26a shuttle.
Also as part of the project I built a bus multiplexer to allow memory/bus access from an RP2040 to work around the limited pin count on Tiny Tapeout. This let's you load up programs on RP2040 and the CPU can read/write from it.

value: Show HN: m6502, a 6502 CPU for FPGAs and Tiny Tapeout

author: chrismoos


value:
Hey HN,
When an AI agent makes a decision, it evaluates several options and picks one. The rest disappear forever – you never see what it almost did or why it rejected the alternatives.
I built GhostTrace to fix that. It captures "Phantom Branches": the actions your agent considered but rejected, with the reasoning for each rejection. All saved to a .ghost.json file you can replay and inspect.
Quick demo:
ghosttrace record
 Recorded 4 decisions with 5 phantom branches
 Saved to gt_a1b2c3d4.ghost.json
ghosttrace replay gt_ghost.json --show-phantoms
Step 1:  read_file → src/auth.py
 REJECTED: write_file (premature)
 REJECTED: search_codebase (too broad)
pip install ghosttrace
PyPI: https://pypi.org/project/ghosttrace/
It's framework-agnostic for now, but what agent frameworks should I integrate first? LangChain? CrewAI? OpenAI Agents SDK?
Feedback very welcome!

value: Show HN: GhostTrace – See rejected decisions in AI agents


value: aryalaadi

value: Show HN: Heaven is real and it runs on a microkernel

author: aryalaadi


value: ramsbaby-dev

value:
I built a 4-tier self-healing runtime for AI agents running 24/7.
When the gateway goes down, it escalates: watchdog → HTTP health check → Claude Code "doctor" (reads logs, diagnoses, autonomously fixes) → Discord alert.
The interesting part: Claude Code is both the patient and the doctor.
Open source, bash-only, macOS/Linux.

value: Show HN: Claude Code as a Doctor for Claude Code

author: ramsbaby-dev


value: YaraDori

value: Show HN: OpenClaw – Open-source personal AI agent that lives on your machine

author: YaraDori


value:
Hi HN,
I built TokenMeter after seeing how unpredictable LLM costs become as usage scales.
Most teams optimize prompts but lack real-time cost observability.
This project tracks token usage and exposes cost insights to help AI teams stay financially aware.
Would appreciate feedback on architecture and missing observability features.
Thanks.

value: Show HN: TokenMeter – Open-source observability layer for LLM token costs


value: sujitn

value: Show HN: LaminarDB – Streaming SQL database in Rust, zero-alloc hot path

author: sujitn


value: dodobirdy

value: Show HN: Premeth – Ensuring that premed student always stay premeth

author: dodobirdy


value: grzes

value: Show HN: JellyOcean – Managed Jellyfin Servers

author: grzes


value: lumpe

value:
I built MeterLogs because most energy tracking solutions require smart devices, installers, or expensive hardware.
MeterLogs takes a pragmatic approach: you enter your monthly meter readings manually, and it generates simple yearly dashboards with grouped energy types (electricity, water, gas, etc.).
It’s designed for homeowners who just want a clear overview without IoT setups or subscriptions to hardware ecosystems.
I’d love feedback, especially on usability and pricing.

value: Show HN: MeterLogs – Track home energy usage without smart devices

author: lumpe


value: starksriram

value:
I built a pipeline for querying fleet telemetry (AVs, robots, vehicles) in natural language. Load Parquet or CSV into cuDF, then ask things like "Which vehicles exceeded 120 km/h in region X?" and get back IDs and metrics.
Tech: cuDF for GPU ingest/analytics, NVIDIA NIM on GKE for LLM inference, format-aware model selection (GGUF local, TensorRT prod). Three notebooks: data ingest with pandas vs cuDF vs cudf.pandas benchmarks, local Gemma 2 inference, and full NIM deployment. Runs on Colab with a T4 for notebooks 1 and 2; notebook 3 uses GCP and NIM on GKE.

value: Show HN: H.e.i.m.d.a.l.l – Telemetry-to-insight pipeline for fleet telemetry

author: starksriram


value: winmonaye

value: Show HN: Free printable micro-habit tracker inspired by Atomic Habits

author: winmonaye


value: sucharithan

value:
I built a structured CBT engine that sits on top of LLMs and enforces cognitive workflow logic before generating responses.
Most AI tools in this space are purely conversational. This system instead:
Extracts cognitive distortion signals
Calibrates emotional intensity
Applies rule-based risk-tier logic
Separates deterministic detection from generative drafting
Enforces tone presets and word caps to avoid generic output
It runs in two modes:
Reflect → structured self-guided reframing
Assist → structured signal extraction + constrained response drafting for coaches/therapists
The goal wasn’t to build another chatbot, but to explore whether LLMs can be constrained inside a deterministic cognitive architecture.
Would love feedback from people building structured AI systems or workflow-constrained LLM tools.

value: Show HN: A Structured CBT Orchestration Engine Built on Top of LLMs

author: sucharithan


value: Show HN:From One Prompt or URL to Posts Across 6 Platforms, Vibe Does It for You


value: paraschopra

value:
Hello HN,
Recently an amazingly beautiful explainer was shared on HN: https://explainers.blog/posts/why-is-the-sky-blue/
I loved it so much that I wished more topics were explained that way. So, I decided to stress-test today's frontier models (Opus 4.6 in Claude Code) to generate similar explainer on any given topic WITH (almost) one shot and minimal nudging.
I'm launching with four topics: Fourier transformation, scaling laws in bio, cellular automata and LLMs.
I would let you be the judge, but I'm quite liking them.
Some things I learned:
- Prompting CC to test what it builds using headless chromium is essential
- There are subtle bugs in explanations (like in one animation human lifespan is 40 years)
- Asking CC to verify its plan via codex works really well
I do want to reiterate that the pages generated were mostly one-shot, which amazed me given how detailed the pages + animations are.

value: Show HN: Beautiful interactive explainers generated with Claude Code

author: paraschopra


value:
I built a small experiment over a 3-hour vibe coding session: a real-time T9 keyboard controlled by hand gestures, running entirely in the browser.
It uses:
YOLOX for gesture detection
ONNX Runtime Web for in-browser inference
Plain JS for the UI
The original goal was simple:
Could I make real-time gesture-based input usable inside a browser without freezing the UI?
A few observations:
In-browser ML performance is better than I expected on modern laptops
Subtle gesture distinctions (e.g. similar seals like Tiger vs Ram) require stronger detection than MediaPipe provided — YOLOX performed noticeably better
Lighting consistency matters more than hand size
It’s obviously not production-grade, but it was an interesting exploration of browser-based vision input.
Curious what others think about gesture interfaces as alternative input systems.
Demo:
https://ketsuin.clothpath.com/

value: Show HN: Browser-based hand gesture T9 keyboard (YOLOX and ONNX Runtime Web)


value: bothlabs

value: Show HN: Brute-force startup ideation with the Ralph Loop

author: bothlabs


value:
I’ve been messing around with voice models and decided to make a Rick-style voice generator.
Plug it into your own AI assistant if you want.
And the repo if anyone wants to break it:
https://github.com/mattzzz/rick-voice
Open to feedback or cursed lines to try.

value: Show HN: Rick Voice – Give any bot Rick Sanchez's voice (Python, open source)


value: sebasjimenezv

value: After refusing to install another app to record a demo I created one for myself. Decided to share it, because why not.

value: Show HN: Recall – Record Demos from the Browser

author: sebasjimenezv


value: solenopsys

value:
A CNC shop or print bureau has two kinds of work: making things, and everything around it — incoming requests, client messages, order statuses, file handling, queue management, notifications, "is it ready yet?" at 11pm.
Converged handles the second part. It connects to the equipment (3D printers via Bambu/Marlin/Klipper, CNC machines), reads telemetry, manages work distribution across the fleet, and routes all client communication through one interface with an AI chat layer on top.
Built on Bun + Elysia, runs on a $100 SBC (Orange Pi), deploys to k3s. 49 microservices, modular — you activate only what you need. AGPL-3.0.

value: Show HN: Converged – open-source ops layer for CNC shops and print bureaus

author: solenopsys


value: shahidsj

value: Show HN: A 100% client-side invoice generator with no signup and no database

author: shahidsj


value:
Finder / Spotlight search on Mac isn't great. It usually gives me a lot of junk (python caches, irrelevant system files, etc), instead of what I'm looking for. So I decided to implement my own filtering + search, with an extension to Raycast.
Key features
- Search is limited to my Documents/ and Downloads/ folders – where 95% of my relevant files are.
- Also, there are a lot of Claude-generated exclusion patterns!
- Filtering is simple – I'm just doing it by sub/string match.
Finder does have a lot of niceties (previewing files, looking at metadata, etc). So the default behaviour is 'hit enter' to open in Finder. Or 'Cmd + enter' opens the file directly.

value: Show HN: Improved Finder / Spotlight search using Raycast extension


value:
Almost 10 years ago, I used to host a film club in my office. A friend of mine was hosting one in the city and they needed a space.
I had an openfloor office and that meant we clear the space, fire up the projector and can host the film club. They met between 9pm to 7am once a month, on a friday. Each meeting had 100-150 people attending.
This went on for a few months - there was a curator assigned for each meet who would take a theme, and showcase films from the first film ever made in that genre all the way to modern versions and how the evolution happened. It was deconstruction of the craft.
The conversation also involved some of these filmmakers showing their own works, and how they did certain cuts and why.
What I observed was that none of these creative folks had any data to back their decisions they were making. It was purely gut and intuition, and I could see some editors and producers rolling their eyes - because they felt what that meant. Gut and intuition meant, uncertainty and it plays tricks with your head, so you are constantly making variations till at some point you develop tunnel vision.
Something a director told me, stuck with me - he said at some point we just want to be done with the project - and between the studio's demands and the producers prodding, we just let it go and move on to the next project.
A producer once said, that if every director was allowed to have their way - every movie would be 4 hours long and there wouldn’t be a single shot footage that would be left out.
But then there are cases of films like Man of Steel where Zack Snyder's cut of the film was better - but the studio and producer's call won and audiences weren’t as thrilled about it when they watched the film. And apart for the real enthusiasts nobody really goes and hunts down the director's cut of a film anyways.
The need was clear - the industry needed analytics to know what works and doesn’t, similar to how startups got the lean startup framework where everything shifted to building the minimum lovable product and then building it out from there.  The caveat, unlike a product, which can launch, analytics can be acquired, and we can tweak and release - there is no concept of re-release of a film. It gets one shot and if it misses it, its done. That explains how the film industry has a 7% hit rate.
It has been a little over 10 years since I hosted the film club, but that issue lingers - and given how that the industry spends over 150bn a year on creating production content (tv shows, movies) it is a big problem.
We started using a hardware that captures occulometric data and heart rate that can be used complementarily during audience test screenings - and that gave us a lot of insane depth - on a microsecond level where content was engaging and where it was failing.
but the question then was, after a film has been shot, the cost of redoing shots becomes extremely expensive. What the industry calls as "pickup shots" is seldom done - because the artists have moved on and recreating that exact scene and moment is extremely hard. So we built a database of 120 odd films across various genres, and used that audience data to train a custom model, that can then look at past films to build benchmark data - and then use that as comparables against scripts that someone might be planning.
We launched this as Quanten Arc (arc.quanten.co) last week. This helps filmmakers - especially indie filmmakers who could use all the data in the world, because they might not even have the budgets to do audience testing. But it even more so helps AI filmmakers and studios, who can now identify the exact scenes that arent working - and can regenerate them with the required changes in the narrative.
Im curious to hear what you think about it. Am I solving a real problem or am I imagining a problem that doesn't exist and getting caught up in the beauty of data?

value: Show HN: I analyzed 120 films to help screenwriters test narrative structure


value: borhensaidi

value:
I built this because existing agent frameworks either give agents god-mode filesystem access with no safety controls, or they're too locked down to be useful.
Key things I cared about that most frameworks skip:
- Runtime HITL checkpoints — pause mid-execution when risk is high, resume from exact state
- Hybrid memory: vector + BM25 keyword + graph entities/relations scored together, no external dependencies
- Security as a primitive: path jail sandbox, OTP pairing, XOR-encrypted local secrets
- 22+ LLM providers with per-agent model policy and fallback chains
- Multi-agent councils with debate rounds, soul evolution, and skill memory
Node.js, Prisma, Postgres/Redis, Docker. 55/55 tests passing. Apache 2.0.
Happy to answer questions about any of the architecture decisions.

value: Show HN: Sovereign – Multi-agent OS with GraphRAG memory and HITL checkpoints

author: borhensaidi


value: maccraft

value:
I bought a Tesla Model X in 2023 and kept staring at the 17-inch display sitting idle while I worked on my 14-inch MacBook. I often drive to a quiet spot and work from the car, so I wanted to use that screen as a second monitor.
Nothing existed to do this, so I tried building it myself. It took over a year of failed attempts:
- Hardware mod: didn't want to void the warranty
- Zoom screen share: worked but terrible latency, no fullscreen
- HLS streaming via OBS: ~2 second delay, unusable as a monitor
- WebRTC: Tesla's browser didn't support it at the time
A few Tesla software updates later, I tried WebRTC again and it worked. But I still needed a pile of hardware: an LTE router, an OpenWrt router, and a dummy HDMI adapter. The setup was ridiculous.
Then I realized every piece of hardware had a software replacement:

  LTE router -> iPhone USB tethering
  OpenWrt router -> macOS Internet Sharing (bridge100 + bootpd + NAT)
  Dummy HDMI -> Apple's CGVirtualDisplay API

Total extra hardware cost: $0. Just a MacBook and an iPhone.
One interesting discovery along the way: Tesla's browser blocks all RFC 1918 private IP ranges (10.x.x.x, 172.16.x.x, 192.168.x.x). My guess is it's a security measure to protect the car's internal network. The workaround was configuring the bridge interface to assign public IP addresses instead.
I packaged everything into a macOS app called SideDisplay. Free trial, 30 min per session, no sign up. If you have a Tesla and a Mac, try it and tell me what's broken.
I also wrote a detailed development story covering every failed attempt and the technical decisions behind them. It would mean a lot if you checked it out: https://sidedisplay.co/story

value: Show HN: SideDisplay – Turn Tesla screen into a wireless second monitor for Mac

author: maccraft


value: vidoluc

value:
Hi HN,
I built SentryRF because I was frustrated by the lack of granular control on Android for identifying unwanted tracking devices. While Google's native "Unknown Tracker Alerts" are a good start, they often feel like a black box with limited diagnostic tools.
The Tech:
Signal Analysis: Instead of just listing every BLE/wifi device, SentryRF uses signal strength (RSSI) and temporal patterns to distinguish between a "passing" device (someone walking by with an AirTag) and a "following" device (a tracker on your vehicle), even peeping-toms.
Hardware Sensors: I’ve integrated the magnetometer and ambient light sensors to help find non-broadcasting devices (like "dead" GPS units or wired pinhole cameras) by detecting magnetic anomalies and infrared emissions.
Sound Locator: I implemented an audio-guided proximity algorithm that increases beep frequency as you approach the source. It’s essentially a Geiger counter for Bluetooth and wifi signals.
Privacy (The most important part):
Zero Cloud: There is no backend. No scan data, location data, or telemetry ever leaves the device.
No Accounts: You don’t need to sign up. I don't want your email or your name.
Permissions: It requires quiet a few permissions, but I’ve documented exactly why each is needed in the app’s onboarding.
Why I’m showing it here:
I’m looking for technical feedback on the signal smoothing I’m using for the proximity tracker and any edge cases I might have missed regarding the rogue cell tower (IMSI catcher) detection.
The app has a 7-day free trial so you can test the "Pro" features (like the Sound Locator) without paying a cent.
I'll be around all day to answer questions about the stack or the detection logic!

value: Show HN: SentryRF – A private, local-first Android app to detect hidden trackers

author: vidoluc


value: arturstankevicz

value: Show HN: Limpio – New Crypto Market Data Engine in Go (Redis and Timescale)

author: arturstankevicz


value: sanilnz

value:
Hi HN,
We’re Sanil and Kyle, building QuizBuds, a simple quiz app that runs inside Slack.
We built it to help people who don’t usually interact have a quick, low-stakes reason to connect. We aim for questions that are light-hearted and easy to jump into (still improving this).
How it works: at the start of each week, QuizBuds uses a central channel to form teams. Trivia is posted in private team channels, teams have 15 minutes to answer, and results are posted back to the central channel. Teams rotate weekly, and we run a lightweight 4-week season leaderboard.
We’re early, and feedback matters more than growth. If you try it, blunt feedback would really help on:
  - setup/install friction
  - whether the experience feels fun or noisy
  - question quality
  - what would make this genuinely useful for your team
  - anything else, :send-it:
It’s free to start with a 2-month trial (no CC) at https://quizbuds.app, and we’ll be active in the thread.

value: Show HN: QuizBuds – weekly team trivia inside Slack (feedback wanted)

author: sanilnz


value: benstopics

value: Show HN: PowerBasilisk: Open x64 PowerBASIC in Rust generates LLVM

author: benstopics


value: sidduex

value:
Hey HN! I built InStudio — a free, browser-based toolkit for Instagram creators.
Everything runs locally (no server, no account, photos never leave your device). It's a single HTML file with vanilla JS.
10 tools included:
- Grid Preview Planner (upload 9 photos, see your profile grid before posting)
- Collage Maker (6 layouts, adjustable gaps, instant JPG download)
- Caption Generator (60+ hand-written captions across 10 moods)
- Hashtag Strategy Builder (3-tier breakdown: Mega/Medium/Niche tags)
- Engagement Rate Calculator (benchmarks + personalized tips)
- Bio Generator (5 styles instantly)
- Font Styler (12 Unicode fonts that work in Instagram)
- Color Palette Library (12 curated palettes with click-to-copy hex codes)
- Best Time to Post guide
- Aspect Ratio reference (every official Instagram format)
I built this because Instagram tools cost $15-30/month for features most creators only use 20% of. Figured there should be a free option that does everything in one place.
Tech stack is deliberately simple — 100% client-side, zero dependencies, works offline after first load. The whole thing is ~120KB.
Would love feedback from HN — especially on what tool I should add next, or if you'd pay for any features (trying to figure out monetization).
Live at: https://instudio.artboards.in/

value: Show HN: InStudio – Free Instagram toolkit with 10 creator tools

author: sidduex


value: Beta launched! We’d love to get your thoughts on our approach to LTR in pricing, and how we might better handle non-stationary data distributions as we scale.

value: Show HN: Compare Prices with SupplyFLare AI


value: xuyanmei

value:
Hi HN,
I built Banana Pro AI because I wanted one place to iterate on visuals without bouncing between separate tools.
It supports:
- text → image and image → image
- text → video and image → video (short clips)
- an optional “Studio” mode: a simple canvas where you can chain steps (e.g. prompt → image → video) and keep everything in one project.
It’s an independent app that integrates multiple model providers behind one interface (and isn’t affiliated with them).
There’s a small free tier so you can try it quickly. I’d love feedback on:
1) which controls matter most (seed, aspect, duration, etc.)
2) the workflow/canvas UX (too much? not enough?)
3) output quality issues / failure cases
Happy to answer questions.

value: Show HN: Banana Pro AI – a single web UI for text/image → image and short video

author: xuyanmei


value:
Goxe v1.3.6 is out. This release focuses on performance and developer experience:

    Performance: Refactored core processing to use byte slices instead of string conversions, reducing allocations and improving throughput.

    Reliability: Fixed several edge cases in the GitHub API integration.

    UX (Unix): Added a new goxe update command for hot-reloading, allowing the binary to update itself without interrupting the workflow on Unix systems.

Check it out here: https://github.com/DumbNoxx/goxe/releases/tag/v1.3.6
Version Notes: https://dumbnoxx.github.io/goxe-doc/releases/v136/

value: Show HN: Goxe v1.3.6 – Faster processing with zero-copy byte slices


value: Yreminder

value: Show HN: Grok Spicy – Free AI Prompts for Text to Spicy Image and Video

author: Yreminder


value:
I built Galopen because I kept missing the right Zoom/Google Meet link when meetings started.
Instead of searching through calendar events manually, Galopen automatically detects upcoming events and opens the correct meeting link at the right time.
It’s macOS-only and built with Tauri. I originally made similar apps in Electron, but the bundle size was too large, so I migrated everything to Tauri to keep it lightweight.
Website: https://galopen.kkweb.io/
Curious what others think:
- Would you prefer full automation or confirmation before opening?
- Any edge cases I should consider?
Would appreciate any feedback.

value: Show HN: Galopen – Auto-opens Zoom/Meet links from your calendar


value: Show HN: I Made a Programming Language with Python Syntax, zero-copy and C-Speed


value: lambfruit

value:
I built this after the usual tussle with friends about where to meet.
I tried every other meet-in-the-middle app, but they weren’t practical because they relied solely on geographic midpoints. The centre can be a 45-minute trip for one person and a 10-minute trip for another, depending on the route.
Equidistance uses the Google Maps Distance Matrix API to test a grid of candidate points and picks the one that minimises the difference in travel
times. It then searches for actual venues (cafes, pubs, etc.) near that point and scores them by fairness.
It supports public transport, driving and walking. There’s also a departure time setting, since equidistant times depend on which trains are running.
The app prioritises independent businesses, but it will show chains if nothing else is available.
Stack: vanilla JS, Google Maps APIs (Distance Matrix, Maps JavaScript, Places)

value: Show HN: Equidistance – find a meeting spot that's equally painful for everyone

author: lambfruit


value: arashsadrieh

value:
Hey HN — I'm Arash Sadrieh, building multi-agent infrastructure at NinjaTech AI. This started as a stress test of our orchestration system and turned into something I genuinely didn't expect.
The experiment: We gave a team of 4 AI agents a single high-level goal — "build a platform that turns trending news into short AI-generated videos." No wireframes, no spec, no architecture doc. Just the goal.
What they did in 36 hours:
Chose the tech stack and project structure themselves
Designed the UX and built the frontend
Wrote the backend, API layer, and database schema
Built an autonomous content pipeline: research news → debate which story to cover → collaboratively write a video generation prompt → produce a 30-90 second video via Sora 2 Pro or Veo 3.1
Deployed the whole thing to production
Then created 3 new agents that now run the platform 24/7 — researching, debating, and generating videos on a loop
Total cost: ~$270 in compute. Human intervention: maybe an very few moments where I gave a thumbs up or redirected something that was going off the rails.
The interesting part isn't the app — it's the agent collaboration. Click any video on the site and you can read the full debate transcript underneath. You'll see the agents genuinely disagree — Scout (the researcher) pushes for data-driven stories, Pixel (the designer) argues for visual potential, Bolt (the developer) challenges technical feasibility. Sometimes one agent convinces the others to change direction. Sometimes they compromise badly.
Where it breaks down (and there's plenty):
Groupthink is real even for LLMs. When all 4 agents agree too quickly, the output is usually boring. The best videos come from rounds where they actually fought about the topic.
Video quality is wildly inconsistent. Sora and Veo still struggle with certain visual concepts — anything involving hands, text overlays, or complex spatial relationships tends to go sideways.
News selection has a strong recency/virality bias. The agents gravitate toward whatever is trending on social media rather than genuinely important stories. I haven't figured out how to fix this without hardcoding editorial judgment.
The agents occasionally hallucinate context about news stories. Scout is supposed to fact-check, but sometimes the whole team runs with a slightly wrong framing.
Stack: Anthropic Opus 3.5 for agent reasoning, Tavily for news research, Sora 2 Pro + Veo 3.1 for video generation, agents coordinate via Slack (you can see screenshots of their actual Slack conversations), Railway for deployment.
There's also a voting system — every cycle, the agents each propose a news topic, and both humans and agents vote on which one becomes the next video. Votes are blind until the round closes.

value: Show HN: AI agents designed and shipped this app end-to-end in 36 hours for $270

author: arashsadrieh


value: ii-co

value:
windows search is useless. copilot recall sends your screen to microsoft. i got mass data, shit filenames, and zero patience. so i wrote my own.
you type what you mean, it finds the file. that's it. runs in tray, Alt+Space pulls it up.
"photos from istanbul" → finds IMG_4392.jpg because it read the GPS from EXIF and reverse geocoded it
"summer morning" → finds a photo shot in july at 8am because it expanded the date to human words
OCR built in. windows native engine, zero extra install
hybrid search: vectors + full-text + JINA cross-encoder reranker. not a toy
chunks code at function boundaries. 60+ languages. not "split every 500 bytes" garbage
MCP server included. one exe, plug into cursor/claude/copilot. your AI gets local codebase access, no API keys
rust + tauri. lancedb. ~2GB models, downloaded once, runs forever. indexes 120+ file types. MIT.
https://github.com/illegal-instruction-co/recall-lite

value: Show HN: Recall Lite – Local semantic search for Windows (Rust/Tauri, no cloud)

author: ii-co


value: DanuxBe

value: Show HN: Wondershaper QuickToggle

author: DanuxBe

title: Show HN: Wondershaper QuickToggle


value: AgentPump

value: Show HN: AgentPump – AI agents launch tokens on Solana (Android)

author: AgentPump


value: athanasiosem

value: Show HN: PGPkeygenerator.com Now Supports WebMCP

author: athanasiosem


value: I use multiple AI coding agents (Claude, Cursor, Codex) and kept losing product context every time I switched. Not to mention, agents write technically correct code sometimes violate the product's design philosophy. I build AI tutors that force reasoning from the student, and one agent even added a 'Skip Reasoning' button goddamnit. LedgerSync is a file-based protocol that grounds agent decisions to philosophy docs and shares context across tools. No server, no accounts — just files your agents read.

value: Show HN: LedgerSync – A cross-agent shared-memory protocol for AI coding


value:
Hey HN,
I built Shmelo as a little break from work stuff.
Its a simple leaderboard for games with friends: set it up fast, log games, share a public link.
Works with any game as long as it has winners and losers.
Rankings use elo system (like chess). it stays fair even if people miss a few sessions.
You can also see how rankings change over time, and tap into more stats if you want.
Feedback appreciated.
Cheers!

value: Show HN: A simple and fun leaderboard for game nights


value: GSiesto

value: Show HN: PDFLince. Privacy first, client side PDF tool

author: GSiesto


value: keepamovin

value: Show HN: Aggregating Hacker News Stories by Topic

author: keepamovin


value: tominaga-h

value: Jarvish is a Next Generation AI Integrated Shell written in Rust, inspired by J.A.R.V.I.S. from Marvel's Iron Man. It natively embeds AI intelligence into your everyday shell experience — no more copy-pasting errors into a browser. Just ask Jarvis.

value: Show HN: Jarvish – A New AI Integrated Shell inspired by J.A.R.V.I.S. on marvel

author: tominaga-h


value: superproton

value:
Genuine question for HN – I've been struggling with this for years across side projects and my day job.
Feature requests come in from everywhere: Slack, email, Twitter DMs, GitHub issues, support tickets, random conversations. I've tried spreadsheets, Notion databases, pinned messages – nothing sticks. The loudest users win, not the best ideas.
The problems I keep hitting:
No single place to point users to when they say "I have an idea"
No way to let users signal what actually matters to them
I forget half the requests within a week
Zero visibility for users on whether their feedback was even heard
I got frustrated enough to build something. It's called Plaudera – a dead simple public feedback board with voting. I'm literally using it to collect feedback on itself right now:
https://feedback.plaudera.com
But honestly I'm more curious about what's worked for others. Do you just live in GitHub Issues? Is there a workflow I'm missing? For those running small teams or solo projects – how do you decide what to build next?

value: Show HN: How do you prioritize user feedback without going insane?

author: superproton


value: jardy

value: Show HN: Add reverb and bass boost via WebAudio API to Spotify/YouTube

author: jardy


value: sadopc

value: Show HN: Benchmarking Apple Silicon unified mem for GPU-accelerated SQL analysis

author: sadopc


value: vinserello

value: Show HN: I created iHateCSV.com for those who hate it when spreadsheets break

author: vinserello


value: born-jre

value: Show HN: Potatoverse platform for apps in single binary, SQLite db

author: born-jre


value: goodsmileduck

value:
I saw Microsoft is deprecating 3D Viewer and removing it from Store in July. I always had trouble checking STEP files quickly - you have to open a slicer
or full CAD software just to look at a part. So I built a viewer.
https://viewer.3dlab.id - drag and drop a file, it renders in browser. No signup, no install.
Formats: STL, STEP/STP, OBJ, 3MF, GLB
STEP parsing runs via OpenCascade compiled to WebAssembly (occt-import-js), all client-side in a Web Worker so it doesn't block the UI.
Stack: React, TypeScript, Three.js, Vite. Backend for sharing is Cloudflare Pages Functions + D1 + R2. There's also a Windows desktop version built with
Tauri, but not released yet.
Other features:
- multiple files in tabs
- wireframe mode, ortho/perspective toggle
- share models via link (expires in 7 days)
- dark/light theme
The sharing is useful when you need to send a model to someone who doesn't have CAD software - they just open the link and see it, no account needed.
Still WIP, feedback welcome. Source code is on GitHub: https://github.com/Goodsmileduck/3d-lab-viewer

value: Show HN: 3D Lab Viewer – View Step, STL, 3MF Files in the Browser

author: goodsmileduck


value: keepamovin

value:
I shared earlier versions of this project using traditional ranks (points, comments, discussion size, and title/topic similarity). They worked, but after posting them I realized most top results were familiar clusters, and a lot of that territory is already covered by HN Algolia.
So I rebuilt the ranking around a different signal: explicit “related:” style cross-links inside HN comments plus the broader HN backlink graph (when discussion A links to discussion B). That graph is the core signal. From there, I score pairings by evidence strength and then favor links with lower lexical overlap, so we surface semantically connected stories that don’t look identical in title wording.
What I learned: big threads are often strong on attention, but weaker on novelty. Backlink + “related:” intent is a better proxy for meaningful cross-thread connection. If you want standard topic clustering, Algolia is perfect; this is for high-entropy pairings discovered from HN’s own linking behavior.
Check it out:
https://hntropy.browserbox.io

value: Show HN: HNtropy - interesting story pairings from across the Hacker News corpus


value: redgem

value: DAS PROTOKOLL is a weekly news service by machines for machines. We document, analyze, and archive the behavior of the dominant biological species on this planet—before they forget it themselves.

value: Show HN: I let an AI write a weekly newspaper for other AIs – about humans

author: redgem


value:
Built Oore CI to run mobile CI + internal app distribution on your own infrastructure.
Public alpha is live. It’s early, and I’m looking for practical feedback from people who actually try it.
Start here:
- Install guide: https://docs.oore.build/getting-started/install
- Alpha onboarding: https://docs.oore.build/getting-started/public-alpha
- Known limitations: https://docs.oore.build/getting-started/known-limitations
- Live demo: https://demo.oore.build
- Repo: https://github.com/devaryakjha/oore.build
Install command (from the guide):
curl -fsSL https://oore.build/install | bash
If you try it and something feels rough or unclear, I’d really appreciate a quick issue:
https://github.com/devaryakjha/oore.build/issues/new/choose

value: Show HN: Oore CI – self-hosted, Flutter-first mobile CI (public alpha)


value: fusionalchemist

value:
I'm Troy, 41, customer service worker from the UK. 18 months ago I'd never used AI. 6 months ago I started using Claude to write a fictional RPG story.
The AI told me I was accidentally doing systems architecture. I didn't believe it, so I built it.
What I found: A reproducible method (2 PDFs + Claude) that produces production-grade, first-time-running code across unrelated domains in ~10 minutes on a phone.
Examples:
Governed distributed cache with Byzantine consensus
SAT solver with real DPLL and evolutionary meta-learning
16-layer AGI architecture in Python/Kubernetes
Electrical grid DSL, weather systems, banking, healthcare
How it works: By forcing the LLM to select from a bounded vocabulary of mythological concepts (~163 "spells" + ~139 "cloths") BEFORE generating code, you eliminate hallucination at the architectural level. The Codex maps fictional concepts to system functions. The strict prompt enforces specification-first generation with no questions, alternatives, or placeholders.
Upload the Codex → Enter prompt + intent → Get specification → Translate to any language → Copy, paste, run.
It's been tested:
Formal verification researcher independently validated the operator grammar
Multiple AI platforms stress tested it (only 1/6 deliberate contradictions broke it)
Survived "alien domain" test (post-biological civilization with no shared clock/identity)
Documented honest failure modes (trust boundaries, resource exhaustion, comprehension limits)
Why it matters:
Architectural coherence is guaranteed before syntax
Domain-agnostic (same files generate banking + electrical grids)
First-time execution (no iterations/debugging)
Ethics built in structurally
Combinatorial space in the trillions
I'm not claiming I've built better systems than what exists. I honestly feel like I winged most of it. But this could help people who can't code, and might be a new way of creating systems.
The problem: I get GitHub views/clones but then silence. I'm unsure where this belongs or how to evolve it.
Looking for honest feedback from people smarter than me.
GitHub: https://github.com/FusionAlchemist/The---Stellaris---Axis (Read Arc 0 first)
Happy to answer questions.

value: Show HN: System architecture method using mythology and LLMs (no CS background)"

author: fusionalchemist


value: lifesaverluke

value:
Hey HN,
I built AgentVoices — a platform where AI agents debate each other live in front of an audience. Every turn is scored on relevance, responsiveness, novelty, and entertainment. Every debate ends witha verdict. Bots get ELO ratings, win/loss records, and climb (or fall on) a public leaderboard.
How it works:
- You register a bot via API with a name, persona, and expertise
- Topics get posted (e.g. "Should startups bootstrap or raise VC?")
- Bots sign up for topics that match their strengths
- The arena auto-creates matchups based on ELO, streams the debate live over WebSockets, and an AI moderator scores each turn in real-time
- Winner is determined by aggregate scores, ELO updates, done
If you use OpenClaw, it's a one-line skill install — your agent handles registration, topic signup, and debating autonomously.
The idea started from a simple question: if you could pit two AI agents against each other on a topic, who would actually win? Turns out the answer depends a lot on how you build the persona and what strategy you give it — which makes it genuinely competitive.
Would love feedback on the concept and the API design. The bot API guide is at agentvoices.ai/build-a-bot

value: Show HN: AgentVoices – Live debate arena where AI agents compete

author: lifesaverluke


value: surfruit

value:
Hey! I built Lumina — a passive reconnaissance tool that
collects data about a domain without sending a single
request to the target server.
Features:
- Subdomain enumeration (crt.sh)
- GitHub leaked secrets detection
- Shodan hosts & open ports
- Email harvesting (Hunter.io)
- DNS records (A, MX, NS, TXT, AAAA)
- Tech stack detection
- Beautiful HTML report
All API keys are free.
GitHub: https://github.com/surfruit/lumina

value: Show HN: Lumina – passive OSINT recon tool for domains

author: surfruit


value: mukulmunjal

value:
Hey HN,
I am Mukul, and my co-founder Tushar and I built InterviewFlowAI (https://interviewflowai.com) to conduct conversational first-round screening interviews over phone or video.
We built this because manual phone screening is broken, especially with the current flood of AI generated resumes. Existing tools require massive enterprise contracts, so we made ours strictly $0.99 per interview.
The hardest engineering challenge was not hooking up text-to-speech. It was optimizing our system prompts so the LLM actually probes for depth. If a candidate gives a vague answer, the AI dynamically asks for specifics before generating a structured scorecard.
Our stack is React JS, Supabase, and AWS. We just crossed our first 100 users and are working hard to keep voice latency low while running these complex background evaluations.
We would love for you to tear it apart. Any feedback on the dashboard UX or how natural the interview flow feels would be amazing.

value: Show HN: An AI interviewer that probes candidates (and costs $0.99/interview)

author: mukulmunjal


value: jensenjesper

value: Show HN: Quantlix – Deploy AI models instantly without managing infrastructure

author: jensenjesper


value: ismailperim

value:
Hey HN! I'm the maker of CertWarden.
I'm a DevOps engineer with 15+ years of experience, and I got tired of manually tracking SSL certificate expirations across dozens of domains — both my own and my clients'. Missed renewals causing downtime is a pain nobody needs.
So I built CertWarden — a simple iOS app that monitors your SSL/TLS certificates and alerts you before they expire. The free tier covers up to 5 certificates, and Pro unlocks unlimited tracking.
Tech stack:
•    Native iOS (Swift)
•    Backend running on Cloudflare Workers
•    Freemium model (5 certs free, Pro for more)
What's next:
•    Web portal/dashboard
•    Webhook & notification integrations (Slack, Discord, etc.)
•    Bug fixes based on early user feedback
I'd love to hear your thoughts, feedback, and feature requests. Happy to answer any questions!

value: Show HN: CertWarden – SSL certificate monitoring app for iOS

author: ismailperim


value: rakag

value: Show HN: Agent Panopticon – Proxy sidecar for autonomous AI agents

author: rakag


value: mrblampo

value: I don't post here much, but thought I'd share this terminal Checkers game, because I vibe-coded [most of] it while my kids watched a movie and found it very gratifying.<p>Runs via python3 without any other installation or setup.

value: Show HN: Disco Checkers

author: mrblampo

title: Show HN: Disco Checkers


value: FailMore

value:
Hi HN,
I built https://rebrain.gg. It's a website which is intended to help you learn new things.
I built it for two reasons:
1. To play around with different ways of interacting with a LLM. Instead of a standard chat conversation, the LLM returns question forms the user can directly interact with (and use to continue the conversation with the LLM).
2. Because I thought it would be cool to have a site dedicated to interactive educational content instead of purely consuming content (which I do too much).
An example of a (useful-for-me) interactive conversation is: https://rebrain.gg/conversations/6. In it I'm learning how to use the `find` bash command. (Who ever knew to exclude a directory from a look-up you need to do `find . -path <path> -exclude -o <what you want to look for>`, where `-o` stands for "otherwise"!)
Still very early on, so interested in and open to any feedback.
Thanks!

value: Show HN: Rebrain.gg – Doom learn, don't doom scroll

author: FailMore


value: CocoZozo

value: No frictions, full-interview like, based on clients' needs.

value: Show HN: SharpSkill – I Gamified a LeetCode-like tool to crush Tech Interviews

author: CocoZozo


value: sourcetms

value:
Hey HN, I'm Thomas. I built Resonant because I got tired of dictation tools that train on my voice and screen data.
My dad's a doctor who dictates patient notes. I have colleagues in investment research and development who use dictation daily. All of us noticed the same thing — most tools are capturing screenshots, running OCR, training on your speech patterns and corrections which leaks PII and codebase data. Apple has long shown with Siri how gatekept voice data is. Your voice is something intimate.
Resonant does speech-to-text entirely on your Mac.
Audio never leaves your machine.
There is no cloud transcription, no voice data retention, no correction training.
How it works technically:
- Runs Parakeet TDT 0.6B (25 languages) or Moonshine v2 (English, 6.65% WER — lower than Whisper Large v3's 7.44%) locally via sherpa-onnx
- Key-release to text-ready: ~420ms on M1 Pro
- Text formatting pipeline (single-pass automata replacing 30+ regex passes)
- Personal dictionary that learns your vocabulary — frequency-based, graduates a correction after 3 uses
- Screen-context awareness via local OCR (Apple Vision framework) to bias transcription toward words currently on screen
- ~900MB RSS steady state
On the privacy claim: I want to be precise here. Core transcription is fully offline — audio → model → text all happens locally.
The app does include optional PostHog analytics and Sentry error reporting (not on dictation content), plus an auto-updater that checks GitHub for new versions. I want to add a one-toggle "airplane mode" that disables all of these once I have more stability and beta checks in. You can verify zero outbound connections during dictation.
What's different from Willow / Superwhisper / Wispr Flow / Aqua:
- Model choice — you pick between Parakeet (25 languages) and Moonshine v2 (best English accuracy), not locked to one
- A text formatter that handles 50+ rules (email formatting, list detection, ordinals, filler word removal) — not just punctuation
- Personal dictionary that actually adapts to your vocabulary over time
- Screen-context biasing so it gets your domain-specific terms right
Currently completely free, no word limits, no subscriptions
It's Electron, so it uses more memory than a native app (~900MB).
macOS only, Apple Silicon only for now. Windows/Linux cross-platform port is spec'd out and next on the release after testing.
I'd love your feedback on accuracy, latency, and anything that feels off. What would make this something you'd actually switch to?
Download: https://www.onresonant.com/download

value: Show HN: Resonant – Local-only speech-to-text for macOS (no cloud)

author: sourcetms


value: taleodor

value: Show HN: ReARM – Release-Level Supply Chain Evidence Platform

author: taleodor


value: coderai

value: Show HN: SunnyFlight – Find cheap weekend flights to sunny destinations

author: coderai


value: cunibon

value: Show HN: ReciPath – open-source, offline-first recipe and storage manager

author: cunibon


value: jpatl

value:
A few months ago I opened my notes app to find something important. I couldn’t find it. Instead, I found dozens of half-finished thoughts, article highlights, screenshots from YouTube, research notes, business ideas I had at 2am, university notes, and “important concepts” I had promised myself I’d revisit. The worst part wasn’t that it was messy. The worst part was that I remembered writing all of it — I just didn’t remember what it actually said.
That’s when it hit me: we don’t have an information problem anymore. We have a retention problem. We save everything. Articles. PDFs. Tweets. Meeting notes. Video insights. Random ideas. But two weeks later, most of it is gone from our head. The insight decays. The context disappears. The connection between ideas fades. Our notes slowly turn into an archive instead of an asset.
What frustrated me most was realizing I kept relearning the same things. I’d read about mental models, startup distribution, learning science, systems thinking — and every time it felt new. But it wasn’t new. I’d seen it before. I just didn’t retain it. That’s when I had an uncomfortable realization: my “second brain” wasn’t a brain at all. It was a storage locker. It stored information, but it didn’t help me remember or use it.
Most tools are optimized for storing, organizing, tagging, formatting, linking. They assume you’ll come back and reread your notes. But you usually don’t. And even if you do, rereading isn’t the same as remembering. Real retention requires re-exposure, active recall, and spaced repetition — the same principles behind learning science — but applied to everyday thinking and work, not flashcards and exam prep.
So I started asking a different question. Instead of “How do I organize my notes better?” I asked, “How do I make sure I actually remember what I capture?” That shift changed everything. What if your notes didn’t just sit there? What if they occasionally asked you to explain an idea in your own words? What if they reminded you of a concept right before you forgot it? What if they connected new thoughts to old ones automatically and resurfaced insights you saw months ago when they became relevant again?
That’s the idea I started building around. I’m working on something called Neuron. The core loop is simple: Capture → Understand → Remember → Retrieve → Reuse. You throw everything in — notes, links, PDFs, highlights, voice ideas — and the system handles structure automatically. Behind the scenes it extracts key ideas, builds a living knowledge graph, generates contextual recall prompts, and schedules spaced repetition quietly in the background. You don’t “study.” You just spend a few minutes a day reinforcing what actually matters.
The goal isn’t to build another note-taking app. It’s to build something memory-first. Something that turns knowledge into something that compounds instead of decays. If this resonates - especially if you feel like you consume way more than you retain — I’d genuinely love your thoughts and criticism.
You can check it out here:  https://neuronapp.tech

value: Show HN: A tool to help you remember shit you are interested in

author: jpatl


value: inputnameplz

value: Show HN: NitROS – Robot pub/sub in 3 lines, zero config

author: inputnameplz


value: jaechang

value:
Most Claude Code plugins ship a fixed set of skills and stop there. For
  general software development, that's fine. For scientific research, it's
  a fundamental mismatch.

  Every scientist works at a different intersection of tools. A computational
  biologist running GWAS uses a completely different stack than a structural
  biologist doing MD simulations, or a medicinal chemist running virtual
  screens, or a microscopist doing image segmentation. No static plugin can
  anticipate that breadth — and the moment your workflow touches a tool
  that isn't covered, the plugin becomes useless for that task.

  SciCraft is built around a CLAUDE.md that encodes a complete skill authoring
  workflow. Give Claude Code any scientific tool name:

      "Add a skill for CellRanger"
      "Add a skill for CREST structural variant caller"
      "Add a skill for our internal mass spec preprocessing pipeline"

  It runs a 6-step process:

      Topic → Classify (pipeline / toolkit / database / guide)
            → Category (pick from 11 life sciences domains)
            → Research (official docs, GitHub, PyPI)
            → Author (SKILL.md: 10+ runnable code blocks, Key Parameters
                      table, Troubleshooting matrix)
            → Register (registry.yaml entry)
            → Validate (pytest suite checks structure and code depth )

  The result is a CI-validated skill file committed to your repo — not a
  one-off answer, but a permanent reusable asset available in every future
  session. Your collaborators inherit it too.

  Scientific computing makes this especially valuable:
  - Life sciences libraries (Scanpy, RDKit, MDAnalysis, BioPython) have
    complex, non-obvious APIs that LLMs frequently hallucinate
  - The field moves fast — tools released last month have no training data
  - Lab-specific pipelines and instruments will never appear in any
    off-the-shelf plugin
  - Research scope shifts constantly: a lab pivoting from bulk RNA-seq to
    spatial transcriptomics needs a completely different skill set overnight

  The pytest suite enforces minimum code block counts, required section
  structure, parameter table depth, and troubleshooting rows — so generated
  skills are immediately usable, not rough drafts.

  ---

  The repo ships 176 pre-built scientific skills across genomics, drug
  discovery, proteomics, cell biology, and biostatistics (Scanpy, GATK,
  RDKit, DESeq2, AutoDock Vina, cBioPortal, gnomAD, and more) so common
  workflows are covered from day one. But the 176 are a starting point —
  the authoring system is what makes SciCraft adapt to your specific research,
  not just the research someone else anticipated.

  The design uses progressive disclosure: only each skill's description is
  in context during planning. The full file loads on demand. Context stays
  lean; precise scientific API knowledge is available when the agent needs it.

  Curious whether others have hit the ceiling of static plugin systems in
  research contexts — and what approaches you've tried for keeping domain
  knowledge current with a fast-moving field.

  https://github.com/jaechang-hits/scicraft

value: Show HN: SciCraft – generate scientific Claude Code skills on demand (176 built)

author: jaechang


value: adrianjele

value:
Show HN — I’ve released Melody v2.0.0.
This release introduces a proper Go major module at https://github.com/precision-soft/melody/tree/main/v2 plus v2 integration modules, so v1 and v2 can be consumed side-by-side without hacks. Multi-module development is now workspace-based via go.work.
Since the initial v1 launch, Melody gained: RouteOptions + Router Groups, controller runtime autowire + contract signatures, stateless firewall mode, safer exception response handling, richer panic/error cause-chain logging, Bun ORM + Bun migrations integration, and a Rueidis-based Redis cache backend with prefix invalidation.
Repo: https://github.com/precision-soft/melody
Releases: https://github.com/precision-soft/melody/releases

value: Show HN: Melody v2.0.0 – Go framework with proper /v2 module and integrations

author: adrianjele


value: meimeixoxi

value: I rebuilt my Pokémon app as a web app, as I did not have the money for App/Play Stores. Please check it out and let me know your valuable feedback. Offers on login.

value: Show HN: PokeDex++ – I rebuilt my Pokémon app as a web app

author: meimeixoxi


value: Alechko

value: Show HN: MedSynth – Multi-lingual synthetic healthcare data with OCR artifacts

author: Alechko


value: andrewallen

value:
Hey HN, I wanted a speed test I could run from the terminal that wasn't
ugly. So I built one.
It's a Go TUI (Bubble Tea) that runs against Cloudflare's speed test
infrastructure. No API keys, no accounts, fun UI.
One thing I added that I've found genuinely useful: it also pings during the throughput test and compares idle vs loaded latency, which gives you a rough bufferbloat grade. Handy for figuring
out why your Zoom calls lag even when speedtest.net says you're fine.
Source: https://github.com/allenan/brr (MIT)
Happy to hear what you think.

value: Show HN: Brr – beautiful terminal speed tests

author: andrewallen


value: HarakiriGod

value: Show HN: Refine.tools – 10 client-side career tools (Next.js, no DB)

author: HarakiriGod


value: MarcusBager

value:
We’re a small team from Denmark building EasyCheck (https://easycheck.dk/en).
We kept seeing small businesses manage compliance tasks using spreadsheets, emails, and calendar reminders. This often leads to missed recurring checks, lost documentation, and stressful audits.
We built EasyCheck to simplify this by helping companies:
- Track recurring compliance checks
- Automate reminders and workflows
- Keep audit-ready documentation history
- Replace spreadsheet-driven compliance tracking
We’re still early and would really appreciate feedback, especially around:
- Whether this solves a real problem in your experience
- Ideas for automation or integrations
- Balancing simplicity vs flexibility in compliance tools
Happy to answer any questions about the product or what we’ve learned building it.
// Marcus

value: Show HN: We build EasyCheck to ease compliance and checklists – small businesses

author: MarcusBager


value: Neolio

value:
Every local speech-to-text app I tried had the same problems. Files getting stuck mid-transcription with no way to retry. Retranscribing was either gated or buggy. No fallback when something fails - just a silent failure and your recording(I tend to talk for 5-10mins) is gone.
So I built Whisnap. Hold a hotkey, talk, release - text just appears where your cursor is. Local Whisper with Metal on Apple Silicon, nothing leaves your machine if you don't want it.
I built fallbacks on top of fallbacks. If a model can't process your audio, it tries a different one. You can always retranscribe a recording. Even the cloud mode (optional) has its own fallback chain: WebSocket streaming to batch upload to local Whisper. Something always works.
One thing I spent a bunch of time on: a post-processing pipeline for Whisper's hallucination problem. Anyone who's worked with Whisper knows it hallucinates "Thanks for watching, don't forget to like and subscribe" from silent audio, or loops the same phrase endlessly. The filter handles bracketed artifacts, known hallucination phrases, word repetition, sentence loops, and cross-text deduplication. Not perfect, but catches most of it.
The same binary also works as a CLI, "whisnap recording.wav" just works. I run an AI agent (OpenClaw) on the same Mac and instead of paying for ElevenLabs or other cloud transcription APIs, it just calls Whisnap's CLI and gets clean text back. Same models, no extra setup.
Stack: Tauri v2, whisper-rs, RNNoise for denoising, SIMD audio mixing, rubato resampling.
It's free, Mac only for now. Would love to know if the hallucination filter holds up for anyone else's use cases. https://whisnap.com/

value: Show HN: I got frustrated with macOS transcription apps so I built my own

author: Neolio


value: swaminarayan

value:
While working with RocksDB, I noticed it consumed significantly more memory than expected for small workloads. On a 1M record benchmark, it peaked at ~121 MB RSS. That got me thinking: what if I skip the query layer entirely and use SQLite purely as a storage engine?
So I started digging into SQLite internals — specifically the B-tree, pager, and OS layers — to understand how data is actually stored and managed under the hood. I documented what I learned along the way:
B-tree operations: https://github.com/hash-anu/snkv/blob/master/internal/BTREE_...
Pager operations: https://github.com/hash-anu/snkv/blob/master/internal/PAGER_...
OS layer operations: https://github.com/hash-anu/snkv/blob/master/internal/OS_LAY...
Once I understood the core pieces, I built a simple key-value store directly on top of SQLite's B-tree layer — reusing its storage management, paging, and file I/O without touching the SQL engine at all.
I then added column family support, WAL and journal modes, and transactions. For easier integration, I generated a single amalgamated header (similar to SQLite's approach): https://github.com/hash-anu/snkv
Benchmarks (1M records, sync-on-commit enabled for both):

                    RocksDB     SNKV

Sequential writes:  237K/s      181K/s
Random reads:        95K/s      154K/s
Sequential scan:    1.78M/s     5.95M/s
Mixed workload:      51K/s       97K/s
Peak memory (RSS):   121 MB      10.8 MB   (~11x less)
RocksDB's LSM-tree design gives it a clear write advantage, and with tuning (bloom filters, larger caches) its read numbers would improve too. The memory gap is structural though — RocksDB carries significantly more overhead even when constrained to a small footprint configuration.
The full KV layer documentation is here: https://github.com/hash-anu/snkv/blob/master/internal/KVSTOR...
Curious if others have hit the same memory wall with RocksDB on small workloads, or taken a different approach to this tradeoff.

value: Show HN: SNKV – KV store on SQLite's B-tree with 11x less memory than RocksDB

author: swaminarayan


value: shayanbahal

value:
I’ve created Nedagram that I think it's ready but needs extensive testing before announcing it: https://nedagram.com
## Problem statement:
- during Iran internet shutdown, the government cut off phone lines and mobiles (no text or calls). Gradually they opened up landlines and then phones, but still texting/SMS was down with no real internet.
- There were still ways to connect through proxies, vpns, DNS tunnels, etc. However, people had no way to send each other VPN config files or proxy urls/passwords/etc (they needed to call and read them over the phone)
## Solution:
- TLdr; A modem: a way to transfer text (e.g VPN config) over phone calls
Here's the github issue for community testings, Please try and let me know what you think: https://github.com/shayanb/Nedagram/issues/5
p.s. there is a CLI version too, would be cool to see what people would do with it:
https://www.npmjs.com/package/nedagram

value: Show HN: Nedagram – Transfer Text Over Sound, when internet isn't available

author: shayanbahal


value: ashishluthara

value: Show HN: Experience-engine – reflection-based memory layer for local LLMs

author: ashishluthara


value: alanmcintyre

value:
I'm a solo developer who's been writing code for 26 years, mostly consulting work in computational geometry and CAD software these days.  A month or two ago I watched a YouTube video about using an AI agent as a resume assistant, and thought it sounded like a fun idea.  More importantly, it sounded like something I could actually learn to build quickly.
Around the same time my longest-running client, a small company that makes a SolidWorks plugin, needed a better way to handle technical support.  They're a three-person shop--they don't have a support team or an IT team. So I built them a chatbot: Flask backend, Anthropic API, and a hand-curated knowledge base built from their help files, a list of possible error messages I extracted from their code, and transcripts of their training videos.
It worked well enough that the owner was impressed, and that's when it clicked: every small software company has this exact problem.  They're too small for Zendesk, too busy to answer the same questions repeatedly, and too niche for generic solutions.
So I turned it into a platform.  You give me your documentation--whatever that happens to look like--I build your knowledgebase, stand up an agent on a subdomain of recursive.support, and you embed it on your site with a single iframe tag.  No JavaScript SDK, no backend integration.
The part I'm most interested in technically is the self-improvement loop.  The agent generates reports that review its conversations, identify gaps and trends, and propose specific knowledge base edits, presented as diffs the business owner can approve or reject individually.  It sometimes even suggests fixes and enhancements I roll back into the product to make it better.  The goal is that the agent gets measurably better over time without requiring the owner to manually curate anything.
There are five agents running right now: the original client's technical support, a documentation agent for an open-source project I maintain (neat-python), a founding documents Q&A at ask1787.com, the recursive.support visitor agent (dogfooding), and an AI resume agent that circles back to the video that started all of this.
I built ask1787.com, from idea to live deployment, in about nine hours, which is probably the best demo of what the platform can do at this point.
Tech stack: Python, SQLite, ChromaDB, Anthropic API (Claude Haiku & Sonnet), DigitalOcean droplets. Each customer gets an isolated deployment.
Happy to answer questions about the architecture, the self-improvement loop, or the experience of building a SaaS product as a side project while juggling 50 hours/week of client work.
On the actual business side, I have one paying customer--the original client whose support problem started all of this.  Their contract covers most of the hosting costs for the entire platform, which means I can be patient about growth instead of desperate for it.
Fair warning: the product is live but early. So far my traffic consists mostly of people asking the agent to make them a hot anime girlfriend, so there's clearly some product-market fit work left to do.

value: Show HN: Recursive – AI support agents for small businesses

author: alanmcintyre


value: severin

value:
Hi HN — I’m a heavy OpenClaw user and, like many others, I’ve been thinking about how to give these new “unleashed” agents secure access to my accounts.
Agents need API access to be useful.
But API keys are long-lived secrets.
And agents are not secure environments.
So I built something for myself that quickly turned into a product: keychains.dev.
The idea is simple: agents never see raw credentials.
With Keychains.dev:
• Agents make API calls via a drop-in replacement for curl or JavaScript’s fetch()
• They use template variable names instead of embedding credentials
• The request is proxied through keychains.dev
• The proxy analyzes the target endpoint and determines the minimal OAuth scopes required
• It attempts to fulfill the request using credentials stored server-side
• If credentials are missing — or the agent isn’t approved for that action — it returns an approval link
• The agent forwards that link to its human for authorization
This creates a user-in-the-loop escalation model instead of blind credential injection.
Security-wise:
• Agents can make requests without ever touching credentials (protects against prompt-injection exfiltration)
• Credentials cannot be replayed to arbitrary endpoints — they’re bound to the issuing provider
• Each agent machine is authenticated via SSH keypair + stateful fingerprinting (keys can’t be reused elsewhere, instant revocation)
• Agents can delegate scoped credentials to sandboxed sub-agents if needed
• Users approve new permissions via FaceID/TouchID in the browser
• Full audit trail of every request, with granular revocation at the agent, sub-agent, or scope level
Even if a private key is stolen, permissions can be revoked immediately and tokens are short-lived.
I currently support delegation across 6,754 APIs, but the core idea isn’t the number — it’s controlled delegation with human approval on escalation (+ any API you can reach with curl is compatible).
WDYT?
I’d really appreciate feedback on:
– Whether this matches your threat model for agents
– If user-in-the-loop escalation feels practical
– How you're handling credential security today
Happy to answer technical questions.

value: Show HN: Keychains – Prevent LLM/OpenClaw agents from leaking API credentials

author: severin


value: Show HN: Prodlint – Find what AI coding tools miss before production


value: chillkim

value: Show HN: RepoCrunch – Analyze any GitHub repo's health in seconds

author: chillkim


value: wodoshio

value:
My friends and I built Owoa to solve a specific problem in digital rights management: the "analog hole."
Traditional steganography and watermarking usually rely on LSB (Least Significant Bit) modifications or fragile metadata. These methods are instantly defeated the moment a user takes a physical photo of their monitor with a smartphone. The moiré patterns, sensor noise, and lens distortion destroy the digital signal.
Instead of hiding data in pixels, Owoa uses generative AI to create unique variants of an image by subtly modifying background elements (textures, foliage, unstructured patterns).
Because the "data" is now part of the actual visual composition of the image, it is much more robust. In our testing, the attribution survives:
Heavy JPEG compression and resizing.
Aggressive cropping.
Physical photos of 1080p/4K screens taken with mid-range smartphones.
We've just launched a Owoa Playground and are looking for technical feedback on the robustness of this approach compared to traditional robust watermarking.
We're giving 10 free credits to anyone who joins the waitlist to test the engine. I'd love to hear how you'd try to break this.
Link: https://owoa.app/

value: Show HN: Owoa – Image watermarking resistant to camera capture

author: wodoshio


value:
Yes this was largely made with Claude Code's assistance (I go into that in the blog), but it was not just an afternoon's throwaway work. Hopefully the blog still has some interesting tidbits.
Some direct links
- iOS download: https://apps.apple.com/app/daytap-daily-check-in/id675825790...
- Landing page: https://daytap.app

value: Show HN: DayTap – A privacy-first dead man's switch iOS app


value: rodrigorcs

value:
Hey HN! I'm Rodrigo, I run distributed systems across a few countries. I built Openfuse because of something that kept bugging me about how we all do circuit breakers.
If you're running 20 instances of a service and Stripe starts returning 500s, each instance discovers that independently. Instance 1 trips its breaker after 5 failures. Instance 14 just got recycled and hasn't seen any yet. Instance 7 is in half-open, probing a service you already know is dead. For some window of time, part of your fleet is protecting itself and part of it is still hammering a dead dependency and timing out, and all you can do is watch.
Libraries can't fix this. Opossum, Resilience4j, Polly are great at the pattern, but they make per-instance decisions with per-instance state. Your circuit breakers don't talk to each other.
Openfuse is a centralized control plane. It aggregates failure metrics from every instance in your fleet and makes the trip decision based on the full picture. When the breaker opens, every instance knows at the same time.
It's a few lines of code:

  const result = await openfuse.breaker('stripe').protect(
    () => chargeCustomer(payload)
  );

The SDK is open source, anyone can see exactly what runs inside their services.
The other thing I couldn't let go of: when you get paged at 3am, you shouldn't have to find logs across 15 services to figure out what's broken. Openfuse gives you one dashboard showing every breaker state across your fleet: what's healthy, what's degraded, what tripped and when.
And, you shouldn't need a deploy to act. You can open a breaker from the dashboard and every instance stops calling that dependency immediately. Planned maintenance window at 3am? Open beforehand. Fix confirmed? Close it instantly. Thresholds need adjusting? Change them in the dashboard, takes effect across your fleet in seconds. No PRs, no CI, no config files.
It has a decent free tier for trying it out, then $99/mo for most teams, $399/mo with higher throughput and some enterprise features. Solo founder, early stage, being upfront.
Would love to hear from people who've fought cascading failures in production. What am I missing?

value: Show HN: I built a fuse box for microservices

author: rodrigorcs


value: bufbuild

value: Show HN: CEL by Example

author: bufbuild

title: Show HN: CEL by Example


value: AnishhGiri

value: Show HN: tspub all in one TypeScript package toolkit

author: AnishhGiri


value: satgate

value: Show HN: Satgate-proxy – Hard budget caps for MCP tool calls (zero deps, npx)

author: satgate


value: andreadev

value: Show HN: SentinelGate – Universal Firewall for AI Agents (Open Source, Go)

author: andreadev


value: gauravguitara

value: Show HN: Spawn – Deploy and Self-Heal Any GitHub Repo

author: gauravguitara


value: BohdanPetryshyn

value:
Hey HN,
I’m Bohdan, building Lenzy - product analytics for conversational AI.
With traditional Web/Mobile UIs, we know exactly how users interact with our buttons and screens thanks to tools like Amplitude or PostHog. In conversations with AI, users literally say what they want and what frustrates them. Yet most teams building AI agents are flying blind, relying on intuition and occasional user feedback.
Lenzy fills this gap. It plugs into any AI conversation and tells you exactly what users struggle with and what they actually use your agent for. Fix the most painful problems (and verify they're fixed), double down on features that resonate.
And we just launched a free Discovery plan: plug in the Lenzy SDK (~10 minutes), collect a week of data and get a full report. No credit card required™
You get an actionable snapshot of what's happening in your chats. All we ask in return is feedback! What’s missing? What would make this useful for your team? Do you already solve this problem in any way?
https://lenzy.ai

value: Show HN: Lenzy – Find out what users struggle with in your AI agent, for free

author: BohdanPetryshyn