value: stefanwebb

value: I've created an alternative to CLI and MCP for locally running agentic tools. It uses Unix-based OS's named pipes, which means the client has quick IPC with the tool and it can have in-memory state. I created it to build components for voice agents (TTS, STT, LLM chat) but it has wide range of uses! Comes with a CLI tool, cpipe (like curl), and a Claude Code skill

value: Show HN: A better alternative to CLI and MCP for local tools

author: stefanwebb


value:
I kept seeing advice about “prompt engineering” — complex templates, frameworks, and long structured prompts.
So I tried going deep into it: refining prompts, adding rules, using structured formats, even generating prompts with AI itself.
In most cases, the results didn’t improve much. It just made the process slower and more frustrating.
What worked better for me was the opposite:
* keeping prompts simple and direct
* giving clear context and examples
* iterating quickly instead of trying to get it perfect in one shot
I put together a short practical guide with examples based on this approach, mainly for people who feel stuck or disappointed with AI outputs.
Would be interested to hear how others here are approaching this — especially if you’ve had better results with more structured prompting.
Link: https://factverse2.gumroad.com/l/arrlsk

value: Show HN: What worked for me with AI prompts


value: misonic

value: I have built a browser extension which could help you get to know definitions of different terms which are appearing in the video which you may not know before. This was the idea triggered while watching some financial videos on YouTube.

value: Show HN: Turn any YouTube video into something you can use

author: misonic


value: musgravite

value: Show HN: React Modern Audio Player

author: musgravite

title: Show HN: React Modern Audio Player


value: treelover

value: Show HN: Chipmunkify – I used ML to solve audio's dumbest problem

author: treelover


value: rvttt

value: Show HN: Tokemon – monitor token use with out refreshing 27 browser tabs

author: rvttt


value: nodesocket

value: Show HN: Cryptr a shell utility for encrypting and decrypting files with OpenSSL

author: nodesocket


value: araniwa

value: Show HN: Bad Apple (Oscilloscope-Like) – one stroke per frame

author: araniwa


value: alykirk

value:
I built xlg to browse Reddit, HN, GitHub, Wikipedia from terminal using Unix pipe syntax.
Example: xlg 'reddit "r/Art" | take 5 | print'
Also works as MCP server for AI agents, OpenClaw
GitHub: https://github.com/auraz/xlg

value: Show HN: Xlg – Jq for APIs

author: alykirk

title: Show HN: Xlg – Jq for APIs


value: jrandolf

value:
`sqlc-gen-sqlx` is a `sqlc` (https://sqlc.dev) plugin that generates `sqlx`-oriented Rust code from annotated SQL queries.
The generated API is intentionally small:
- a `const SQL`
- row structs for `:one` and `:many`
- params structs when a query has multiple parameters
- methods on `Queries<E>` that work with `&PgPool`, `&mut PgConnection`, or `&mut Transaction`
Current scope is PostgreSQL. It supports the usual `sqlc` query annotations, plus enums, composite types, batch queries, `COPY FROM`, `sqlc.slice()`, `sqlc.embed()`, and type overrides.

value: Show HN: sqlc-gen-sqlx, a sqlc plugin for generating sqlx Rust code

author: jrandolf


value: mantyx

value: Show HN: Mantyx – Automate and accelerate your Software Operations

author: mantyx


value: DougTrier

value:
I built an enterprise operations system over the past month and just released v3.4.0.
The core idea is simple:
A technician walks up to a machine, scans a QR code, and the work order starts immediately.
No typing, no searching, no navigation.
Most CMMS/EAM systems require multiple steps just to begin work. In practice, that friction either slows people down or causes bad data.
This release adds:
- Zero-keyboard scan workflow (barcode/QR → instant WO start)
- One-tap finish / transfer / hold with reason codes
- Offline-first PWA (local DB + sync)
- ~600 Playwright tests covering core system surfaces
- Cross-plant analytics, inventory, and OpEx modeling
It’s designed specifically for plant environments where:
- connectivity isn’t guaranteed
- speed matters more than UI complexity
- workflows need to match physical movement
Repo:
https://github.com/DougTrier/trier-os
Would appreciate feedback, especially from anyone working in maintenance or industrial systems.

value: Show HN: Trier OS – scan a machine to start a work order (zero keyboard)

author: DougTrier


value: Bardockthegreat

value: Show HN: Show HN:CryptographicTimestamps4 human testimony(2HTMLfiles,noserver)

author: Bardockthegreat


value: windystockholm

value:
Hi HN,
I realized I track code every day, but ignore my health.
So I built GitBalance, log workouts like commits, and see them as a contribution graph.
You can even do it via CLI:
gitbalance commit -m "30 min workout"
gitbalance commit -m "stretch + wrist recovery"
Super early MVP — curious if this resonates.

value: Show HN: GitBalance – a GitHub-style graph to balance work and health

author: windystockholm


value:
Hi HN, since the Berkeley RDI benchmark integrity post recently got a lot of attention here [0], it seems like a good time to share Amber, related work aimed at making agent benchmarks easier to reproduce.
Amber grew out of the RDI AgentX-AgentBeats benchmarking competition [1] where the general public was invited to submit agents. To ensure trustworthy results, we needed submissions to be reproducible and have clear provenance. Reproducibility motivates declarative specifications of benchmarks, and provenance motivates the ability to safely and efficiently run benchmarks on hosted hardware. Once you add support for multi-phase multi-agent benchmarks (like Werewolf), the design for Amber mostly falls right out.
Amber is inspired by Fuchsia OS Component Framework. The security model of Amber is that a component like an A2A agent or MCP tool only serves a component that has explicitly been given a capability to use it. In the context of benchmarks, this means that an agent under test cannot reach into the evaluator, and that a tool can be revoked in a later phase of a benchmark.
Amber is a combination of a compiler and a runtime system: the compiler turns manifests describing agents, tools, and how they connect to each other into a deterministic plan. The plan can be executed against different backends like Docker, K8s, KVM, or the host OS. The compiler injects runtime components necessary to enforce the capability model: sidecar routers that provide guarded connectivity between components, and backend controllers that allow components to create and destroy components at runtime.
Amber started out with just static `docker compose`, but benches like TerminalBench and OSWorld required the addition of dynamic components and VM-backed components. Then competition participants wanted an easier way to test locally that didn't involve repeatedly rebuilding Docker images, so Amber got native binary support and a one-liner `amber run` interface. The concepts borrowed from Fuchsia have held up so far. Right now I'm working on making Amber's observability traces available to the benchmark evaluator so that it can judge based on the path an agent took, rather than just the final answer.
Overall, the goal we set out to achieve was to make it easy to reproduce agent benchmark results in a low-trust environment. Amber is not a complete solution, but it takes some burden off of benchmark authors and agent builders. Maybe it's even useful beyond benchmarks. I would be happy for you to batter the conceptual framework!
The AgentBeats tau2 benchmark manifest [2] is a real example. The in-tree mixed-site example [3] is a simple demo of Amber end-to-end with `amber run`.
[0]: https://news.ycombinator.com/item?id=47733217
[1]: https://rdi.berkeley.edu/agentx-agentbeats.html
[2]: https://github.com/RDI-Foundation/tau2-agentbeats/blob/main/...
[3]: https://github.com/RDI-Foundation/amber/tree/main/examples/m...

value: Show HN: Amber, a capability-based runtime/compiler for agent benchmarks


value: examineip

value: Show HN: ExamineIP – Free Network Security Toolkit with 15 Tools

author: examineip


value:
This is almost entirely created by Claude, not me. I know some people aren't into that. I was one of them 3 months ago. Since the beginning of the year I finally started getting more serious about trying out AI. The company I work for also had an AI week with lots of training. All I can say is I'm pretty blown away. My entire life feels like it changed over the last month from someone who mostly writes code to mostly someone that prompts AI to write code. And just for a tiny bit of context, I'm 60yrs old and have been coding since 1980.
I get all the concerns, and I review all AI code at work and most AI code for personal projects. This one in particular though, not so much. I get that's frowned on but this is a small, limited scope, personal project. Not that I didn't pay attention, Claude did do some things in strange ways and I asked it to fix them quite often. But, conversely, I have zero rust experience, zero OpenXR experience, zero wgpu expericence, next to zero relevant Windows experience.
I'm guessing I spent about ~30 hours in total prompting Claude for each step. I started with "make a windows app that opens a window". Then I had it add wgpu and draw hello triangles. Then I had it add OpenXR and draw those triangles in VR. That actually took it some time as it tried to figure out how to connect a wgpu texture to the surface being drawn in OpenXR. It figured it out though, far far faster than I would have. I'd have tried to find a working example or given up.
I then sat on that for about a month and finally got back to it this weekend and zoomed through getting Claude to make it work. The only parts I did was make some programmer art icons.
I can post the prompts in the repo if anyone is interested, and assming I can find them.
Also in the last 2 weeks I've resurrected an old project that bit-rot. Claude got it all up to date, and fixed a bunch of bugs, and checked off a bunch of features I'd always wanted to add. I also had Claude write 2 libraries, a zip library, an rar decompression library, as well as refactor an existing zip decompression library to use some modern features. It's been really fun! For those I read the code much more than I did for this one. Still, "what I time to be alive"!

value: Show HN: Equirect – a Rust VR video player


value: JanSchu

value: Show HN: I built a social media management tool in 3 weeks with Claude and Codex

author: JanSchu


value: Show HN: SkillCompass – open-source quality evaluator for your AI skills


value: mostlyk

value: Show HN: Kyomu - 13 puzzles from math and physics that map your cognitive style

author: mostlyk


value: ibrahimwithi

value:
every "best backup plugin" comparison is affiliate content with no real data. so i built a site that runs actual backup/restore operations in docker containers and publishes real benchmark results.
7 site profiles from 1MB blogs to 488MB woocommerce stores. 3 iterations per matchup. elo rating system like chess. live streaming via SSE.
stack: next.js, postgres, redis, docker, fastify worker
https://backuparena.com

value: Show HN: I built a benchmark platform for WordPress backup plugins

author: ibrahimwithi


value: anju-kushwaha

value:
Apple's $599 Laptop Is Real — Here's What You Give Up
https://vucense.com/tech-reviews/reviews-hardware/macbook-ne...

value: Show HN: MacBook Neo Review 2026

author: anju-kushwaha

title: Show HN: MacBook Neo Review 2026


value: ronfriedhaber

value: Show HN: Real-Time, Streaming SQL Queries on Flight Data

author: ronfriedhaber


value: Show HN: Manico – macOS app switcher where single keys activate apps


value: hpbyte

value: I made Rocky (from Project Hail Mary) an agent skill, similar to Caveman.<p>It's not maximum compression like caveman-style prompting. The goal is to keep the interaction fun and recognizable while still saving a fair amount of tokens.

value: Show HN: Rocky-Project Hail Mary agent skill that cut output tokens ~47%

author: hpbyte


value: Show HN: MFlow – Jira delivery analytics for small engineering teams


value: phpnode

value: Show HN: An offline-first type-safe graph database in a CRDT

author: phpnode


value: jchiasson

value:
Hi HN,
I’m an amateur naturalist, and I couldn't find good visual content to study for animal/plant taxonomy. Standard text-based flashcards don't work well for visual identification.
So, I built a visual spaced-repetition engine specifically designed to drill taxonomy using perceptual interleaving (showing you visually similar species back-to-back to train your eye).
The stack:
SvelteKit / CDK (S3) / Fallback R2 / Postgres
Could probably use some better optimization but it works well enough.
It uses a customized implementation of the FSRS (Free Spaced Repetition Scheduler) algorithm adapted for image-heavy visual drilling.
The hardest part is building out the curated image database. There is planned content for many more species coming soon!
The platform is currently in a 100% free beta.
Would love some feedback, advice, etc if you have time!
https://species.app

value: Show HN: Species.app – A visual spaced-repetition engine for taxonomy

author: jchiasson


value: lyfeninja

value: Link to demo in article. The article is for context.

value: Show HN: AI Content Attestation & Verification w/ Revocable Signatures

author: lyfeninja


value: carldaws

value: Show HN: Git-style branching for your Rails database

author: carldaws


value: camilleroux

value: Show HN: Digest – a Claude Code skill for your daily dev news digest

author: camilleroux


value: auxten

value: Show HN: A web newspaper that looks like a newspaper

author: auxten


value: fnel

value: Show HN: Loreo – Bot-free, 8MB AI meeting transcriber using Scribe v2

author: fnel


value: whatifbelief

value: Show HN: Turn your cat into a Cubism Cat via an app

author: whatifbelief


value: yamafaktory

value: Show HN: Formal – LLM-driven property checker, backed by Lean 4 and Mathlib

author: yamafaktory


value: renatoworks

value: A minimalist way to watch YouTube with cinematic previews, an immersive interface, and zero distractions. Free, no accounts or subscription needed.

value: Show HN: Turn your favorite YouTube channels into a streaming experience

author: renatoworks


value: Jarlakxen

value:
Inspired by The Infinite Conversation (https://infiniteconversation.com/), I built a site where J.R.R. Tolkien endlessly describes the landscapes of
  Middle-earth — trees, hills, rivers, ruins, dawns — one scene at a time, forever.

  If you've read Tolkien, you know the man could spend an entire page describing a single tree. My friends and I always joked about it. When I saw the
  concept of an infinite AI conversation, the connection was immediate: what if Tolkien never stopped describing things?

  It's a satirical/art project, not a serious product. The voice cloning is decent but clearly not perfect — which honestly fits the spirit of it.

  Source: https://github.com/Jarlakxen/infinite-tolkien

value: Show HN: The Infinite Tolkien – endless narration of Middle-earth

author: Jarlakxen


value:
Hello HN, long time lurker, probably first time poster
I made an app that lets you browse your Apple Music library as a crate of records. (Sorry Spotify users, - I tried, but Spotify seem to be oddly developer hostile :( )
Been a vinyl collector for years and always felt like streaming apps 'playlist everything!' kill the "intentionality" of listening to records. So I built something.
Wax Crate lets you browse your Apple Music library as physical crates — big covers, no shuffle, no algorithm. When you play something, you get a spinning picture-disc visualisation with the artwork embedded in the grooves.
There are also pre-made crates to browse straight away - hundreds of classic albums, plus curated label catalogues from Verve, Blue Note, Prestige and more — whatever's available on Apple Music, with more labels coming over time. Great for discovering what you should have in your collection.
If you want to go deeper, there's an optional subscription ($3.99/month) that uses AI to pull together track-by-track production notes and behind-the-scenes factoids — the kind of stuff that used to live in liner notes. I charge for it because the AI costs aren't nothing. But the app is completely solid without it.
It's free to try. Launch offer: use code FIRSTIN to get unlimited crates at a discount — redeem here: https://apps.apple.com/redeem/?ctx=offercodes&id=6760627334&...
Would genuinely love feedback from people who actually care about albums as complete works.

value: Show HN: Wax Crate – Browse your Apple Music library like a crate of records


value: Show HN: Avooq – generate a complete 250+ page novel in one click


value: tomekw

value: Show HN: Twins, a Gemini Server in Ada

author: tomekw

title: Show HN: Twins, a Gemini Server in Ada


value: jaromilrojo

value:
CJIT started as a hobby project around Fabrice Bellard’s tinyCC and slowly grew into something much more practical. It is now a small portable C compiler and runner that works across Linux, macOS, and Windows, can self host, and is packaged as a single executable.
What mattered most to me was keeping the barrier to entry low. You can take one small binary, drop it onto a system, and compile or run C code using the libraries already available there, without setting up a full toolchain or installing a large stack of dependencies.
I find that useful for quick prototyping, testing, auditing, learning, and generally exploring real systems with less friction. The codebase also reached a point where it feels solid and maintainable, not just experimental.
It is still a small project, and I want to keep it that way: simple, useful, and easy to carry around.
A fun extra: it works nicely with raylib as well.
Interested in feedback from people here, especially on the single-binary approach and whether this kind of tool feels useful in practice.

value: Show HN: CJIT, a single-binary C compiler that can self host

author: jaromilrojo


value: codedump

value: Show HN: Rockraft – a Rust framework for building strongly consistent KV stores

author: codedump


value: KaTXi

value: Show HN: Zero WYSIWYG – A lightweight, zero-dependency HTML editor

author: KaTXi


value: BinRoo

value: Show HN: B01T – What if quantum computing had Rust-style safety guarantees?

author: BinRoo


value: ElyricFandross

value:
Show HN: Zero-identity messaging app with physics-based post-quantum encryption (Layer 2 from my own paper)
Hey HN,
I'm building a privacy-first messaging app in Flutter/Dart, developed with AI assistance (Gemini 2.5 Pro + Claude Opus 4.6). No phone number, no email, no account — no identity, nothing to track. Currently focused on Android.
*Six-layer defense architecture*
Layer 0 - Identity layer: Zero identifier. No account, no identity, nothing to track.
Layer 1 - Key exchange: X25519 + ML-KEM-768 hybrid. X25519 is Bernstein-designed, outside the NIST ecosystem. Even if ML-KEM has an NSA backdoor, X25519 still holds. The probability of both being broken simultaneously approaches zero.
Layer 2 - Key hardening (my original contribution): session_key = HKDF(shared_secret || Y), where Y = PQ_C(W(shared_secret)). Even if Layer 1 is fully compromised, the attacker still faces the Landauer thermodynamic lower bound + Margolus-Levitin operation limit. Physical law, not a mathematical assumption.
Layer 3 - Message encryption: ChaCha20-Poly1305, Bernstein-designed. High resistance to side-channel attacks. Retains 128-bit equivalent security strength post-quantum.
Layer 4 - Transport: SMP protocol reimplemented from scratch in Dart. No central server, P2P communication. Unidirectional queues — the server never knows who is talking to whom. No message retention on the server. Currently using SimpleX public relay.
Layer 5 - Endpoint: Android FLAG_SECURE screenshot prevention. Volume key triggers emergency wipe (messages + keys). Configurable wrong-password limit before irreversible wipe. Burn-after-reading on by default. Client-side encrypted backup, keys never leave the device.
*What is Layer 2*
Layer 2 is implemented from my Zenodo preprint. The core claim: a key derivation path passing through Product Quantization and Soft-ZCA whitening creates structure-induced quantum blindness against known quantum algorithm paradigms (HSP, Simon, Grover, etc.), making quantum attacks physically infeasible — grounded in physical law, not computational hardness assumptions.
Because Layer 2 is based on my public preprint paper, there is no closed-source issue. Anyone can implement their own encryption scheme using the paper as a foundation.
Paper: https://doi.org/10.5281/zenodo.19483649
Counterproofs welcome. If you can construct one, that result is itself a significant academic finding.
*Features*
- Contact establishment: QR code (in-person) or 10-character random code (remote)
- Stickers: upload any image under 1MB, auto-converted to SVG vector format (in progress)
- Local database: Hive
- Languages: Traditional Chinese and English, both first-class
- Code comments: bilingual beginner-level annotations throughout, written for readability
*Swappable GUI (in progress)*
Frontend/backend separation. Users can choose between WhatsApp-like, Telegram-like, WeChat-like, or Line-like interfaces. Non-commercial developers will be able to build their own GUI on top of the same backend in the future.
*Why Android first, not PWA*
PWA cannot control volume keys or implement FLAG_SECURE screenshot prevention. Both are necessary — not optional — for the device-seizure threat model.
*License*
Custom license. Commercial rights reserved to the author. Drafting terms that will prohibit MAMANGO(Meta, Amazon, Microsoft, Apple, Nvidia, Google, OpenAI) and their affiliates from commercial use or participation in development. Layer 2 licensing terms to follow separately.
*Current status*
Repo is public, README in progress. Landing page with waitlist opening soon. Will publish to app stores after v1.0.
Repo: https://codeberg.org/Kelvin_Brammidge/xlinendchat

author: ElyricFandross


value: kordlessagain

value: Show HN: Hyperia, a surface where terminals, shells, and agents come together

author: kordlessagain


value: MichaelYuhe

value: Our team and me have a strong feeling that Claude Opus has been nerfed for about 10 days, so I made a website to collect real feedbacks: is it nerfed today

value: Show HN: Is Claude Nerfed Today?

author: MichaelYuhe

title: Show HN: Is Claude Nerfed Today?


value: sthielen

value:
Hi HN! Sean from MindStudio here. I wanted to share something we've been working on that I think introduces some new ideas into the "AI coding agent" space.
Remy is an AI agent that builds full-stack TypeScript apps from a spec written in a new flavor of annotated markdown. The spec has two layers: prose describing what the app does, and annotations that carry the technical precision (data types, edge cases, validation rules, code snippets). The agent then "compiles" this into code: backend methods, typed schemas, frontends, test scenarios, and everything else are derived artifacts of the spec.
The idea is that this isn't no-code, and it isn't a shortcut for people who can't code. It's a step toward a new kind of higher-level programming language, one that happens to look like annotated prose instead of syntax with semicolons. The spec isn't a requirements document that generates code. It is the program. Code is compiled output, the same way nobody writes assembly by hand anymore but it's still running underneath. The spec and code stay in sync bidirectionally, and the same spec compiles into different interfaces (web app, REST API, conversational AI agent, MCP server, etc.) depending on what you need. We're obviously stretching the word "compile" here - the same spec isn't going to produce character-identical code each run. But we think it's an interesting mental model for thinking about where software is headed, and we think the gap between "functionally equivalent" and "effectively deterministic" is only going to continue narrowing with each generation of model.
At their core, the apps Remy builds are git repos and markdown files, but we've also built a browser-based sandbox around them - editor, live preview, terminal, chat, and all the other bells and whistles - with managed infrastructure underneath: SQLite with automatic schema migrations, auth primitives (sms/email verification codes, sessions - you build your own UI and define your own user table), 200+ AI models and 1000+ integrations as SDK calls, deploy-on-push. Standard TypeScript, any npm package, any frontend framework.
It's been really fun to see what is possible with all of these pieces connected. We're opening up in public alpha this morning. You can watch some demo videos, see some more details, and sign up to try it at: https://remy.msagent.ai (sign up for a free MindStudio account and then use "showhn" as the code to join the alpha without needing a paid account)
There are also some more demo videos on YouTube: https://www.youtube.com/watch?v=2QJvBcAqQqA&list=PL1gRZlpf9_...
As well as a tour of the interface: https://www.youtube.com/watch?v=ar724yPXgwU
Would love to know what you think. Feel free to drop me an email at sean at mindstudio.ai too

value: Show HN: Remy, an AI agent that compiles annotated Markdown into full-stack apps

author: sthielen


value: goshua

value: Discover how compatible you are with friends, family and dates.

value: Show HN: Lovinghate – Share what you love and hate

author: goshua


value: anju-kushwaha

value:
The introduction of TurboQuant, PolarQuant, and QJL (Quantized Johnson-Lindenstrauss) by Google Research represents more than just a technical optimization. At Vucense, we view this as a landmark moment for Inference Sovereignty
https://vucense.com/ai-intelligence/local-llms/turboquant-ex...

value: Show HN: How to Use Google's Extreme AI Compression with Ollama and Llama.cpp

author: anju-kushwaha


value: poitrus

value: Show HN: Reverse Engineered Apple's Circular App Clip Codes

author: poitrus


value: pierre

value: Show HN: ParseBench – Document parsing benchmark for AI agents

author: pierre


value: XQorp

value: Show HN: Fake-Fast Detector – Exposing performance dark patterns and PSI cosplay

author: XQorp


value:
Hi HN, I built PowerStacks after watching IT admins spend hours every month manually pulling device data out of Intune and SCCM just to answer basic questions from leadership.
The ask is almost always the same: how many devices are compliant, what's the patch coverage, which machines are at risk. The data exists. Getting it into a readable dashboard without a Power BI developer in the room is the hard part.
PowerStacks connects to Intune, ConfigMgr, Defender for Endpoint, Active Directory, and Azure AD. You drag and drop to build the report. It's built on Power BI under the hood, so reports are shareable inside the org or with external vendors.
Data stays in your own Microsoft tenant throughout.
Still adding integrations and would genuinely love to hear what data sources or report types IT teams are missing most.

value: Show HN: I built a no-code report builder for Microsoft endpoint management data


value: mingtianzhang

value:
We release an open source version of Andrej Karparthy's open knowledge base, and we scale it to support long PDFs with Pageindex. Any feedback is welcome to help us improve this project!
Github repo: https://github.com/VectifyAI/OpenKB

value: Show HN: Open KB: Open LLM Knowledge Base

author: mingtianzhang


value: gusco

value:
I've been working as a sysadmin for 30 years, most of that time spent in the terminal.
Midnight Commander has been my main workhorse, but I often thought to myself,
"I wish I had a file manager that handles more like Total Commander in this SSH session."
I was also looking for an excuse to try Crush and get into the Charm/Bubble Tea ecosystem, all of which has been a pleasure to work with.
Gusco has now reached a state where it's good enough to be my daily driver.
Please grab a binary and let me know if it works for you, or what crucial features are missing.
Press F1 or 1 for a list of shortcuts and options.

value: Show HN: Gusco – Orthodox TUI file manager with SFTP/S3 support, written in Go

author: gusco


value:
This is a blog post I wrote comparing the scanning results with our own solution vs SpinAI.
Multipassword going up in risk after they fixed a vulnerability was my favourite find.

value: Show HN: Chrome Extension Scanners, Spin AI vs. Am I Being Pwned


value: sreten

value: I was frustrated that there are so many of these websites (that I made another one, I know) but they are mostly full of ads or confusing, and when I send them to less technically inclined friends, they still don't know what to do. So I wanted some "super easy tools" which is how the name came up. My plan is to add things when I need them or when friends/coworkers ask for something.

value: Show HN: I made simple tools for things people ask me to do for them

author: sreten


value: astralasia

value:
I posted an early version here for my daily paper-folding hole-punching puzzle 3 weeks ago. Since then, I’ve added two major features based on the feedback that it was "too easy".
Expert Mode: A timed, harder version of the spatial folding logic.
Global Leaderboards: Real-time rankings for the daily expert puzzle.
Tech: Built with Next.js. Puzzles are still deterministic and generated on the fly.
I’d love to see some of you on the leaderboard today.

value: Show HN: Daily Unfold – Spatial Logic Puzzle with Expert Mode and Leaderboard

author: astralasia


value: Show HN: Winclipshot – Ctrl+V screenshots as file paths in Windows terminals


value: plue-tech

value:
I built Darkdrive, a small self-hosted cloud storage app.
Files and filenames are encrypted with AES-256-GCM before hitting disk, so the filesystem contains only ciphertext.
The encryption key is not stored in one place on the server at rest. It’s split between:
- a session share stored server-side
- an encrypted cookie stored in the browser
Both parts are required to decrypt files. A compromised cookie or session file alone yields nothing.
The core encryption layer is published for review. The full application is not open source at this time.
https://core.darkdrive.de/public/a7c3222a5c6e12bef0648266/cr...
I chose server-side encryption over fully client-side systems to keep it simple to host while still allowing features like previews, thumbnails, and easy access across devices.
Darkdrive is a single PHP application that runs on shared hosting with minimal setup. It encrypts filenames and directory names alongside file contents, and uses split-key server-side crypto.
Happy to answer questions about the threat model or implementation.

value: Show HN: Darkdrive – self-hosted encrypted cloud storage with split keys

author: plue-tech


value: recursivedoubts

value:
hey HN, I've just released the latest version of my scripting language for the web, hyperscript.  It is a love letter to hypercard/hypertalk that I've been working on on and off for the last five years.
This release has some major new features, mainly by other people: reactivity by Christian Tanul, a reworked templating system by my student Ben Logan, the morphing algorithm from htmx by Michael West.  I added a component mechanism that basically just glues those three things together as well.
This language is a labor of love and I don't expect many people to like it or use it, but I hope you find it interesting and that some of the ideas in it (e.g. async transparency[1]) show what scripting the web could be like.
If you want a quick taste of what the new reactive/templating/morphing combo can look like there is a TODO app here:
https://hyperscript.org/patterns/lists-forms/reactive-todo-l...
[1]-https://hyperscript.org/docs/async/

value: Show HN: _hyperscript 0.9.90

author: recursivedoubts

title: Show HN: _hyperscript 0.9.90


value:
Hi HN folks,
I am a solo builder and wanted to share a tool I’ve been working on: Crafto. It turns text, webpages, documents, and images into carousel posts for platforms like LinkedIn, Instagram, and X.
The goal is to turn plain text into engaging visuals to help marketers, educators, and influencers boost their content engagement, grow audience, and save hours of work.
This idea came from my previous work on using AI to summarize documents, meetings, blogs, and articles. While exploring that direction, I found that pure text summaries still feel a bit plain, so decided to add visual elements. I first tried infographics, but found them hard to read on mobile, especially when they have dense text and complex graphics. What I ended up is a carousel generator that combines text information with simple layout, color, and images — trying to balance text density and visual appeal, as I found whose well-designed carousels on LinkedIn and Instagram easily grab my attention.
Compared to static templates in tools like Canva, I wanted to automate the text-to-carousel generation process so a user doesn’t need to do all the manual work of picking templates, turning their long text into short summary, and filling in the text boxes. While a user can still edit the result in Crafto, I hope it would be minimal as the majority of the work is automated.
Crafto currently uses a mix of AI and curated templates. I also want to experiment with fully AI-generated carousels (without templates) to see how they compare in quality and user preference.
Would love feedback if you find this resonates, and happy to answer any question! You can also email at xz@crafto.ai.

value: Show HN: Crafto – AI carousel post generator for LinkedIn and Instagram


value: Show HN: I built a sandboxed agent that writes JSON rules to avoid repeat errors


value: rajivprab

value:
Hi HN! I built Code Prodigy ( https://codeprodigy.io/ ), an autonomous AI engineer that lives on your ticket tracker. When someone files a ticket in Jira (or Linear, Asana, Trello...), it:
1. Investigates the ticket across all your repos, and creates a design doc
2. Opens one or more PRs implementing the requested change
3. Responds to comments on its own PRs or on the original ticket. Rebases, addresses feedback, pushes updates
It's not a chat window you have to prompt. It just watches your ticket tracker and starts work as soon as a ticket is created. Nothing gets merged or deployed until one of your engineers has reviewed and signed-off on it.
How it works: Each job spins up an ephemeral docker container in AWS with the Claude Agent SDK. The agent runs a workflow that identifies the relevant repositories, investigates the existing codebase, comes up with a design plan for the ticket's requirements, implements it, and spins up fresh agents to review its own work. Your code and your tickets are only ever made accessible to agents that are working for you, in a fresh docker container in a private subnet.
What makes it different from somewhat-similar products:
- completely hosted by us. zero infra or setup needed on your end
- no model lock-in. we use whatever is SOTA at the present time
- works with whatever ticketing system or version-control system your team is using. no migration needed
- watches for comments on its PRs or tickets, and iterates based on your feedback
- uses industry best practices for getting optimal ai results. Eg, research, plan, implement, independent review, independent revision, etc
- zero manual steps needed to kick off the agent, thus massively accelerating organizational adoption
We built this tool because we got tired of tickets sitting in the backlog for weeks and weeks. Having an AI agent automatically produce a design doc and PR has been a huge accelerator. Even when its output isn’t perfect, it still helps immensely in overcoming inertia - allowing tickets to get resolved in days, instead of weeks.
If this sounds interesting to you, reach out to us and we’d love to give you a demo and answer any questions you may have. We’re happy to build support for any ticketing system and version-control system your team is using.
https://codeprodigy.io/

value: Show HN: I built a tool that automatically turns tickets into design doc and PRs

author: rajivprab


value: heywinit

value: Show HN: MOS Tech 6502 emulated in pure Postgres

author: heywinit


value: salzaverde

value:
This is a very early POC to gain feedback for a project I've been working on for the last couple of months.
Let me know what you think!
Based on an ODI (Outcome Driven Innovation) research on current pain points documenting software architecture.

value: Show HN: Git-native solution for documenting software architecture

author: salzaverde


value: davenporten

value:
I've been building an AI system to automate parts of the NRC Combined Operational License process: gap analysis against the Standard Review Plan, FSAR strength scoring, and RAI prediction using vector similarity to historical NRC requests. I intended this as a SaaS business, but was ultimately beat to the market.
What I think is the most interesting artifact is the dataset: 37,734 chunks of NRC regulatory documents (NUREG-0800, 10 CFR Parts 20/50/51/52/72/73/100, and Regulatory Guides) embedded with OpenAI text-embedding-3-small. It covers the full regulatory corpus an applicant would need for a COL submission. I'm not aware of anything like this being publicly available before.
The embeddings are ready to load directly into ChromaDB, Pinecone, or any other vector store. If you're doing nuclear AI, regulatory NLP, or just want a large real-world RAG dataset to experiment with, it should be useful.
Here's the full codebase if you're interested: https://github.com/Davenporten/nrc-licensing-rag

value: Show HN: NRC nuclear licensing RAG pipeline and regulatory embeddings dataset

author: davenporten


value: vanflymen

value: Show HN: 15 yrs of Django in prod: patterns I keep using (agent skills)

author: vanflymen


value: mineev

value:
Today we're (@sprosvirnin and I) launching the first open-source release of IceGate - a Rust-native engine that stores logs (metrics and traces coming soon) in Apache Iceberg tables on your own object storage.
Observability costs are out of control. Teams pay per GB ingested, get locked into proprietary formats, and can't use their own data outside the vendor's UI.
We built the first observability data lake engine to fix this.
This is our first release under Apache 2.0. We're building in the open and looking for contributors and early adopters who want observability without the markup.
Star us on GitHub: https://github.com/icegatetech/icegate
More info on https://icegate.tech
Documentation: https://docs.icegate.tech
LinkedIn: https://www.linkedin.com/company/icegatetech/

value: Show HN: IceGate – Observability data lake engine

author: mineev


value: virtuallytd

value: Show HN: CCS – CLI to switch Claude Code profiles with different MCP servers

author: virtuallytd


value: jdjdjdi

value:
AI agents accumulate stale tool results — file reads, web fetches, bash outputs — in their context window. Every one sits there for the entire conversation, consuming tokens and degrading quality. The standard fix is auto-compaction: wait until full, then drop content indiscriminately.
Context Surgeon gives the agent three operations — evict, replace, and restore — so it can manage its own context. It works as a transparent local proxy that intercepts API requests, assigns IDs to content blocks, and applies eviction directives before forwarding. The agent calls the tools via bash. The proxy is ephemeral: starts with your CLI session, dies when it ends.
The interesting part is that agents naturally start managing their own context without much prompting. In testing, the agent decided on its own to evict old research results before starting an implementation phase.
Works with Codex CLI and Claude Code.
Install: npm install -g context-surgeon
Usage: context-surgeon codex

value: Show HN: Context Surgeon – Let AI agents edit their own context window

author: jdjdjdi


value: RicDan

value:
Inspired by https://tanvin-alt.github.io/behavioural-dashboard/ "Designing for the 100th use"
I stumbled across this UX mock about living dashboards, and thought that it was a neat idea - why not have interactions on a dashboard automatically align it to the users needs? If a user focuses more on one KPI, why not make the first interaction with it on the page more descriptive?
After some short talks with the original designer, I decided to write a library for it. Should work for whatever FE framework you favour, or none. Also 0 dependencies by itself, in addition to outputting a simple JSON you can store as you want.
Just putting this out there, for people that might want something like this :)

value: Show HN: Behavioural-dashboard, framework agnostic library for living dashboards

author: RicDan


value: minsingjin

value:
Being good at coding alone is no longer enough.
In the AI-native era, the ability to talk to people, empathize, and convey your charm is also part of your stack.
Feeling lonely while vibe coding?
Do you want to find a real-world girlfriend or boyfriend?
Do you want to measure your dating combat power and see whether you could actually date IU?
With a single brew install click, talk in your terminal while vibe coding with the person you want to become lovers with.
Just enter a name or a link, and it will do the deep research you want, create a person-based persona, and let you immediately talk to the kind of person you want.
While you talk, it will help you discover your charm, and at the end, you can receive a dating combat power evaluation!
girlfriend in cli will equip you with a harness inside the terminal that helps you become an attractive person!!
Wake up, nerds! Let’s escape being single!!!
 Stars are always welcome haha

value: Show HN: Girlfriend in CLI – AI-native persona harness for social training

author: minsingjin


value: Show HN: Open-source strategy that placed #2 in a prediction market challenge


value:
AI agents are great at writing code but blind at runtime. They guess, print, and waste tokens.
I built dbg to give them a real debugger experience. Since it is backend based with the few I implemented (still at basic level) it can support 15+ languages with one simple CLI (still some work needed but it is functional as it is):
LLDB, Delve, PDB, JDB, node inspect, rdbg, phpdbg, GHCi, etc.
Profilers too (perf, pprof, cProfile, Valgrind…)
I also added GPU profiling via `gdbg` (CUDA, PyTorch, Triton kernels). It auto-dispatches and shares the same unified interface. (Planning to bring those advanced concepts back to the main dbg).
Works with Claude & Codex (probably works on others but didn't try them)
Quick start:
```
curl -sSf <a href="https://raw.githubusercontent.com/redknightlois/dbg/main/install.sh" rel="nofollow">https://raw.githubusercontent.com/redknightlois/dbg/main/ins...</a> | sh
dbg --init claude (for claude)
```
Then just say: “use dbg to debug the crash in src/foo.rs”
Docs: https://redknightlois.github.io/dbg/
GitHub (MIT Licensed): https://github.com/redknightlois/dbg
Would love feedback from anyone building agents. What languages or features are you missing most? Ping me at @federicolois on X or open issues.

value: Show HN: Dbg – One CLI debugger for every language (AI-agent ready)


value: ekns

value: Show HN: Farchive – SQLite-backed history-preserving compressed archive

author: ekns


value: ruaraidh

value:
Aeolus is a Python library to provide a unified interface for air quality data from sources around the world.
Air quality data is now very widely available, but managing access to multiple networks is challenging when they all have different access requirements, APIs and data formats. Some great solutions exist (like openair and openAQ) but these are limited in the data they cover.
Integrating new APIs could be a full-time job, but it's something AI can do very well given a pattern. It sometimes involves working through some "interesting" problems - for example, the EEA has a csv endpoint that actually returns a .zip with mimetype "text/html"...
Beyond data access, Aeolus has basic analytics (for descriptive and regulatory stats) and graphing, as well as quality-of-life improvements like caching.
This is really for me as I build out my company working on turning air quality data into actionable information, but it's open source and freely available to all under GPLv3+. Let me know if you find it useful!

value: Show HN: Aeolus – a library for unified access to air quality sensor networks

author: ruaraidh


value:
I watch a lot of Stanford/Berkeley lectures and YouTube content on AI agents, MCP, and security. Got tired of scrubbing through hour-long videos to find one explanation. Built v1 of mcptube a few months ago. It performs transcript search and implements Q&A as an MCP server. It got traction (34 stars, my first open-source PR, some notable stargazers like CEO of Trail of Bits).
But v1 re-searched raw chunks from scratch every query. So I rebuilt it.
v2 (mcptube-vision) follows Karpathy's LLM Wiki pattern. At ingest time, it extracts transcripts, detects scene changes with ffmpeg, describes key frames via a vision model, and writes structured wiki pages. Knowledge compounds across videos rather than being re-discovered. FTS5 + a two-stage agent (narrow then reason) for retrieval.
MCPTube works both as CLI (BYOK) and MCP server. I tested MCPTube with Claude Code, Claude Desktop, VS Code Copilot, Cursor, and others. Zero API key needed server-side.
Coming soon: I am also building SaaS platform. This platform supports playlist ingestion, team wikis, etc. I like to share early access signup: https://0xchamin.github.io/mcptube/
Happy to discuss architecture tradeoffs — FTS5 vs vectors, file-based wiki vs DB, scene-change vs fixed-interval sampling. Give it a try via `pip install mcptube`. Also, please do star the repo if you enjoy my contribution (https://github.com/0xchamin/mcptube)

value: Show HN: Mcptube – Karpathy's LLM Wiki idea applied to YouTube videos


value:
Bloomberg Terminal exists because financial traders needed one place to see everything: prices, risk, routing, counterparty health. You can't trade blind.
LLM engineers are trading blind.
Which provider is degraded right now? What does this model actually cost when you factor in overhead, not just token price? If traffic shifts between providers, what happens to cost and latency? Is your stack dangerously concentrated on one provider?
These are operational questions every production LLM system has. Nobody's built the tooling for them until now, so most teams either fly blind or patch together status pages, spreadsheets, and gut feel.
We built the LLM Ops Toolkit to fix that:
1. Provider uptime monitor across 18+ LLM providers, live status in one view
2. Cost calculator that includes overhead, not just raw token pricing
3. Routing simulator to model cost and latency impact before you shift traffic
4. Model diversity audit to surface concentration risk before it becomes an incident
Free, open-source, no signup. Dashboard is at tools.lamatic.ai
The routing simulator is the most experimental piece and has the roughest edges. Genuinely curious how others think about provider concentration risk.
We've been treating it as dependency risk in software but that framing may not hold at scale.
Also live on Product Hunt today: producthunt.com/products/lamatic-ai

value: Show HN: Bloomberg Terminal for LLM ops – free and open source


value: wasimsk

value: Show HN: A Chatting Website That Uses Nostr

author: wasimsk


value: artiomyak

value: Show HN: Turn Text into Beautiful Font

author: artiomyak

title: Show HN: Turn Text into Beautiful Font


value: JohannaAlmeida

value:
I’ve been building Aurora, an early-stage browser engine in Rust.
It currently implements a minimal end-to-end pipeline: parsing a narrow HTML subset, building a DOM tree, parsing CSS from style tags, computing basic styles, deriving a simple block layout tree, and painting the result into a small text framebuffer. It also includes basic HTTP/HTTPS fetching with redirect support.
JavaScript execution is integrated using the Boa JavaScript engine. This is still early, but simple scripts do run.
Rendering is done on the GPU from scratch using wgpu and Vello, without relying on Skia. The renderer uses a single atlas and a simple pipeline for batching and rasterization.
The goal is not to build a full browser, but to understand and implement the core pieces of the pipeline in a small and explicit way.
Next steps are improving tokenization, expanding CSS support, making layout less primitive, and continuing work on the GPU rendering path.
Current render snapshot : https://imgur.com/a/NtbgR5i

value: Show HN: Aurora – a browser engine experiment in Rust

author: JohannaAlmeida


value: thomasgeelens

value:
So much has happed in the 'Sallyverse' at this point and I love to share, if y'all have any questions let me know, I'd love to talk. :)
Cynical Sally CLI has been starred 8 times on Github and is being used by more devs every day to help them (and make them cry) in their workflow:  https://github.com/w1ckedxt/cynicalsally-cli
Cynical Sally Chrome Extension Launched and now shows 5 users, it's a start.
https://chromewebstore.google.com/detail/cynical-sally/hjcdm...
Cynical Sally Discord Server is live, the spot to talk about the Sallyverse: https://cynicalsally.com/sallyverse
Get support about anything Sally, join here: https://discord.gg/UEF7Nt4W
Sally Lite (deployed on Render with one click) has been used over 40 times: https://sally-lite.onrender.com/
Cynical Sally for OpenClaw has launched and has a fully companion side, if you into that: https://clawhub.ai/plugins/cynicalsally
The website (CynicalSally.com) also has a companion component when you click the DM's section. (10 for free, Superclub gives you unlimited access and an actual bond building opportunity with Sally)
More to come! Expanding her every day while also keeping the backend lean, tight and trustworthy as much as possible, all built solo. Again, any questions let me know!

value: Show HN: Built a personality that lives across CLI, browser, and web –> all solo

author: thomasgeelens


value: Show HN: CRXcavator, but Better

title: Show HN: CRXcavator, but Better


value: suvamsh

value:
Hey HN,
I built Asthi to give me a straight forward way to track all of my assets. It's completely free.
I've tried a few different products like Mint (before it was killed), empower, google finance, etc. but each had something missing that left me wanting more. After years of being frustrated with each solution I spent a few weeks to build my own.
Some design choices
- Intentionally requires manual entry, I don't trust tracker apps to have read (definitely not write) access to my financial accounts. Certain assets like precious metals can't even use this anyway and need to be manual.
- For tax advantaged accounts I try to find proxy tickers since it's custom based on the company or brokerage
- Real estate requires manually entry as well but I'd love to auto pull estimated prices
I haven't spent much time on user experience since I built it for myself so would love feedback! Please send all thoughts and comments, I can iterate quickly and address any issues.

value: Show HN: Asthi – Damn good asset tracker

author: suvamsh


value: lostathome

value:
I am working on Hitoku Draft. An open-source, voice-first AI assistant that runs entirely locally. No cloud models, nothing leaves your machine. You press a hotkey, and you talk.
It's context-aware; it reads your screen, documents, and active app to understand what you're working on. You can ask about PDFs, reply to emails, create calendar events, use web search, all by voice.
It supports Gemma 4 and Qwen 3.5 for text generation, plus multiple STT backends (Parakeet, Whisper, Qwen3-ASR).
Examples:
- Gemma4 in action, https://www.youtube.com/watch?v=OgfI-3YjEVU
- query a pdf document, https://www.youtube.com/watch?v=ggaDhut7FnU
- reply to email, https://www.youtube.com/watch?v=QFnHXMBp1gA
- and the usual voice dictation (with optional polishing)
I currently use it a lot with Claude Code, Obsidian and Apple Notes, or just read papers.
Code: https://github.com/Saladino93/hitokudraft/tree/litert
Download of binary: https://hitoku.me/draft/ (free with code HITOKUHN2026)
I am looking for feedback. My goal is to do AI research with clients interfacing, and I thought this is a nice little experiment I could do to iterate/fail quickly.
P.S. (if anyone has tips about this)
Current Gemma4 implementation (with small models) has some problems:
- easy to hallucinate for long contexts, so had to reset it often. Tuned some parameters, but need to find a sweet spot.
- Gemma4 with LiteRT is currently fast compared to the MLX implementation of Qwen3.5 (like 3x faster on my machine when dealing with images). But it has the price of memory spikes. I believe this is because LiteRT's WebGPU backend can allocate significantly more GPU memory than the model weights alone (I got 38GB of memory taken, for the E4B~4GB model!). I guess we need to wait for Google for this.
- App size: because no official Swift package from Google yet, have to bundle some file (LiteRT dylibs) that adds ~98 MB to a previous MLX only version (total app goes from ~50 MB to ~150 MB)
If any of this bothers you: use Qwen 3.5 instead (pure MLX), or wait for the upstream fixes from Google :)
Otherwise, for the mid-term I plan to switch to a potentially slower, but safer, MLX version for Gemma4 (hopefully on the weekend).

value: Show HN: Hitoku Draft – context aware local macOS assistant

author: lostathome


value: Exorust

value: Show HN: Is Claude still thinking? How are you wasting life?

author: Exorust


value: arbol

value:
https://curation-509629088134.us-west1.run.app/
My non-programmer friend made an app. It's called  Curation.
Have you ever been asked to recommend a podcast and you're like "omg I have loved so many podcasts but cannot for the life of me remember their names"?
Well this app lets you "curate" a personal list of all your favourites. And see what other people are into to get some inspiration.
Give it a go, you need to sign in with a Google account.

value: Show HN: Curation: Share Podcast Recommendations

author: arbol


value: magneticbrains

value: On a mission to provide the cleanest, AI-ready social media data on the internet.

value: Show HN: Access X, Reddit, Threads and all social media data from a single API

author: magneticbrains


value: IxInfra

value:
Stop playing 20 questions with your AI every session.
Every time you start a new session your agent has no idea what system it's working in. Not just losing conversation history, losing the entire architecture. We tried throwing more context at it. Didn't help. The problem wasn't retrieval. There was no map.
So we built one.
Ix builds a structured architectural map of your codebase deterministically from the actual code. No LLM inferring structure, no guessed relationships, nothing to drift as your code changes. ix map . runs in under 90 seconds.
We've been using it ourselves and the difference in how AI agents reason about our system is pretty significant. Context that actually persists. Fewer redundant questions. Better answers.
Two weeks in, 190 stars, plugins live for Claude Code, Codex, OpenCode, and Gemini CLI. Homebrew submission is in review.
v0.6 coming soon! semantic retrieval, raw file support, and we hit our highest LongMemEval score yet.
Open source. Good first issues labeled in the repo.
Happy to answer questions or get into the technical details of how the map is built.

value: Show HN: Ix. Sick of rebuilding context every session. We mapped it instead

author: IxInfra


value: csenshi

value: Show HN: pg_grpc – Call gRPC services directly from PostgreSQL

author: csenshi


value: bekkerza

value: Show HN: Encrypted, nothing stored, nothing repeated face-gated asset sharing

author: bekkerza


value: Show HN: A calculator to expose the hidden infrastructural costs behind RAG


value: saqula

value: Show HN: Type-level Fibonacci with a while loop in stable Rust (no const)

author: saqula


value: Show HN: Soulhunt – your digital twin is loose. capture it or someone else will


value:
I built this because I kept losing good travel recommendations buried in Reddit threads and forum posts. You read a trip report, someone mentions a specific ramen shop in Osaka or a viewpoint that isn't on any tourist list, and then it's gone — closed tab, forgotten.
RememberMap lets you create trips, drop pins on a map, and attach notes, photos, and voice transcriptions to each one. The interesting part is the Explore tab: I scraped travel forums with Scrapy, embedded the posts with Gemini, and stored the vectors in Firestore. When you open Explore near your saved pins or current location, it surfaces relevant recommendations pulled from real trip reports — not generic "top 10" listicles.
Everything is private by default. You can share a trip via a public link if you want, but nothing is public unless you explicitly share it.

value: Show HN: RememberMap

title: Show HN: RememberMap


value: cvrajeesh

value:
Hi HN!
I’ve always found it hard to explore the Mahābhārata and Rāmāyaṇa online. Most content is either long-form or scattered, and understanding a character like Karna or Bhishma usually means opening multiple tabs.
I built https://www.ithihasas.in/ to solve that. It is a simple character explorer that lets you navigate the epics through people and their relationships instead of reading everything linearly.
This was also an experiment with Claude CLI. I was able to put together the first version in a couple of hours. It helped a lot with generating structured content and speeding up development, but UX and data consistency still needed manual work.
Would love feedback on the UX and whether this way of exploring mythology works for you.

value: Show HN: Ithihāsas – a character explorer for Hindu epics, built in a few hours

author: cvrajeesh


value: rooagi

value:
We’re RooAGI. We built Lint-AI, a Rust CLI for indexing and retrieving evidence from large AI-generated corpora.
As AI systems create more task notes, traces, and reports, storing documents isn’t the only challenge.
The real problem is finding the right evidence when the same idea appears in multiple places, often with different wording.
Lint-AI is our current retrieval layer for that problem.
What Lint-AI does currently:
* Indexes large documentation corpora.
* Extracts lightweight entities and important terms.
* Supports hybrid retrieval using lexical, entity, term, and graph-aware scoring
* Returns chunk-level evidence with --llm-context for downstream reviewer / LLM
* Use exports doc, chunk, and entity graphs.
Example:
* ./lint-ai /path/to/docs --llm-context "where docs describe the same concept differently" --result-count 8 --simplified

  That command does not decide whether documents are in contradiction. It retrieves the most relevant chunks so that a reviewer layer can compare them.

Repo: https://github.com/RooAGI/Lint-AI
We’d appreciate feedback on:
* Retrieval/ranking design for documentation corpora.
* How to evaluate evidence retrieval quality for alignment workflows.
* What kinds of entity/relationship modeling would actually be useful here?
Visit: https://rooagi.com/

value: Show HN: Lint-AI by RooAGI, a Rust CLI for AI Doc Retrieval

author: rooagi


value: Whyachi

value: I built a 83,000 loc invention pipeline that starts with a problem statement and calls multiple SOTA models to generate invention ideas.  Then the ideas are run through a gauntlet to eliminate Ai slop

value: Show HN: GDL – I built an AI-powered invention engine

author: Whyachi


value: arsalsajjad

value:
Hey HN,
So I'm currently taking a lot of enterprise network engineering courses where my professor's course layout is very much figure it out yourselves, go through old forums and guides, and ask AI to help explain information or protocols you don't understand. In the last course I took, I used a lot of the popular LLMs out there, and they genuinely sucked at anything related to network engineering. I would ask something and just receive incorrect, false, or completely unrelated responses over and over, to the point where it wasn’t even speeding up my learning or labs; it would still take me hours to troubleshoot. I've been using Claude code a lot recently, and I made these skills for my friends and me to help us. So far, I've been playing around with it using the old labs and work I did, and it's giving me much better, more insightful outputs. I made some homelab skills just for fun too, because I'm trying to get into that area to expand my learning with my Raspberry Pi at home. Anyways, I'm posting it here so if you guys find it useful and cool, I'd really love to hear your feedback!
Skills cover BGP troubleshooting, Cisco IOS patterns, interface health, VLAN segmentation, Pi-hole, and WireGuard.  Will definitely add more depending on what kind of feedback I get.
Instructions to add these skills are located in the README
Thank you for reading!

value: Show HN: Claude Code skills for network engineering and homelabs

author: arsalsajjad


value: mailharishin

value: Show HN: I benchmarked Gemma 4 E2B – the 2B model beat the 12B on multi-turn

author: mailharishin


value: jiratickets

value: I made this for fun. I think some of you here may enjoy it. Happy to answer any questions.

value: Show HN: BallotGuessr – Guess the 2024 election margin from a Street View photo

author: jiratickets


value: ymaws

value: Show HN: Claude Code vibes from around the world

author: ymaws


value: I looked around for a Zero-dep, local-first, no-cloud-required way to measure costs and value of outcomes when using AI agents.  Since I didnt find one that made sense to me, I wrote a simple one to share and extend.  Comments welcome.  If there is a better solution, happy to adopt that as well.

value: Show HN: AImeter shows you how much money your agents are burning


value: martinovigiani

value: Show HN: On-Device vs. Cloud LLMs for Agentic Tool Calling in a Real iOS App

author: martinovigiani


value: taherchhabra

value: Coding agents need shell. Creative agents need canvas. Flickspeed gives image, video, audio, and research agents a shared workspace to direct, iterate, and ship together.

value: Show HN: The Harness for Creative Agents

author: taherchhabra


value: walnutgeek

value:
I was thinking about something like this for years, few trys before this. Started this
repo last year and I think I got something that usable now.
Async framework, mix sync/async python functions, compose them into DAGs, run them, schedule them, persist data between steps or let it flow just in memory.
GitHub: https://github.com/walnutgeek/lythonic
Docs: https://walnutgeek.github.io/lythonic/
PyPI: pip install lythonic
It is dataflow. So theoretically you can compose it with pure functions only. Lythonic requires annotations for params and returns to wire up outputs with inputs. All data saved in sqlite as json for now, and it would work for some amount of data ok.
You may use it as task flow keeping params and returns empty and maintaining all data outside of the flow.
But practically you may do well with some middle ground, just flow metadata thru, enough to make your function calls reproducible and keep some system of records that you can query reliably.
Anyway I will stop rambling ... soon.
Python 3.11+
MIT License.
Minimal dependencies: Pydantic, Pyyaml, Croniter
Prepping for v0.1. Looking of feedback. v0.0.14 is out. Claude generated reasonable docs. Sorry, I would not be able to do it better. I am working on Web UI and practical E2E example app as well.
Thank you.
-Sergey

value: Show HN: Lythonic – Compose Python functions into data-flow pipelines

author: walnutgeek


value: Show HN: Deconflict – Open-source WiFi planner with physics-based walls


value: ldenoue

value:
Just added support for Apple
Podcasts

value: Show HN: YouTube and Apple Podcast Transcripts

author: ldenoue

story_text:
Just added support for Apple
Podcasts


value: emilanker

value: I made a fun open-source skill to make really simple clickable demos. Just drop it into Claude Code where it reads your code base and creates a HTML/CSS demo of core functionality to go on your website. Think it's helpful to "show, don't tell", and quickly help users understand what your product does, but overcomes the friction of creating accounts and onboarding. I just dont really think screen recordings, or the new animations are as engaging as trying it out yourself. You can just re-run the skill when you ship something new, and also playing with making quick videos. Have fun!

value: Show HN: Beautiful Clickable Demos

author: emilanker

title: Show HN: Beautiful Clickable Demos


value:
I have a proposal that addresses long-term memory problems for LLMs when new data arrives continuously (cheaply!). The program involves no code, but two Markdown files.
For retrieval, there is a semantic filesystem that makes it easy for LLMs to search using shell commands.
It is currently a scrappy v1, but it works better than anything I have tried.
Curious for any feedback!

value: Show HN: Continual Learning with .md

title: Show HN: Continual Learning with .md


value: JaredCampbell

value:
I got frustrated with Gmail's lack of customization, and built an extension for myself. It doesn't do much other than modify how Gmail is displayed in Chrome. Does it as minimally as possible (that I can engineer). Done locally, zero remote processing.
Currently built the following settings (want to add more soon):
Conversations:
* Show newest message first
* Show every message in a thread (sometimes they're collapsed into numbered bubbles)
* Remove AI overviews (retches)
Layout/UI:
* Minimize the search & top bar
* Minimize the far left "rail" (Mail/Chat/Meet)
* Hide a bunch of extraneous icons/buttons/items
* Adjust width of Folders/Labels column (still in-process)
Mini-Automations:
* Automatically open to inbox on page start/refresh
* Automatically select first message if the reading pane is open (unless unread, or previous message already selected)
* Add a recurring reminder (if wanted) to use Gmail's new Manage Subscriptions folder/feature
Bunch more features I'd like to add. Let me know if you think I should change anything. Or if you have any code/bug feedback... :)
jared2campbell@gmail.com

value: Show HN: Built a lightweight extension to simplify Gmail (free, local)

author: JaredCampbell


value: Whenever you hire a developer, you spend lots of your time to explain him everything on the codebase. He keeps on asking you questions because he is confused where he should actually start. This product really help companies onboard developers 20x faster and make them productive within hours.A complete SaaS with github integrations, repo management, auto update steps for onboarding even if code updates. This tool help your new comers become 20x productive in literally no time. Check it out and leave your email for demo and trial versons.

value: Show HN: Automate onboard developer to your codebase 20x faster


value: biosed

value: I have a Dell 1320c, I've had it for 15 years, but the drivers stopped getting created many many years ago. It was sort of working in OS X but will stop when rosetta 2 goes away. I'm running Linux on an M1 mac and no driver support for aarch64. It has an old i386 CUPS driver, I used it and with some help from AI got byte perfect matching in the stream. It uses some proprietary compression called SQ21. Anyway, I now have clean C for the whole chain and so a native driver in Linux aarch64. I've now used that driver on a Pi Zero to have wireless printing. My colour laser lives again!

value: Show HN: I reverse-engineered the driver for my 15 year old printer (Dell 1320c)

author: biosed


value:
Hi HN,
I built Circle2Search because I’ve been learning Swedish by watching shows with Swedish audio and subtitles, and I kept running into the same problem: whenever I missed a word or phrase, I had to pause, type it into Google Translate manually, and completely break the flow of watching.
So I made a macOS app to make that much faster.
Right now, Circle2Search helps translate text directly from the screen. The longer-term goal is to make it feel more like a true desktop “circle to search” experience, where interacting with text on screen is much more direct and seamless.
It’s open source, but the current setup is still early: you need to run the backend yourself and provide your own Google Translate API key.
I’d especially love feedback on:
- whether this is a problem other people run into
- whether the current UX feels useful enough in practice
- what would make this worth keeping installed on macOS
a quick demo: https://vimeo.com/1182792629?share=copy&fl=sv&fe=ci

value: Show HN: Circle2Search, a macOS app for translating on screen text


value: danissimov

value: If you pause your subscription or change Apple ID region, Apple wipes the whole library. once I learned it the hard way, and since then worried about backing up my collection of 6k songs sorted by 100+ playlists<p>I made a very simple script to save all Apple Music playlists as a single JSON containing playlist name, artist, song title and ISRC identifier (which can be used to find song elsewhere and migrate the library). Run locally after getting Apple authorization token from browser session.

value: Show HN: Backup Apple Music Playlists as JSON

author: danissimov


value:
As AI agents autonomously write and deploy code, there's no standard for verifying that what they shipped actually satisfies business requirements. OQP is an attempt to define that standard.
It's MCP-compatible and defines four core endpoints:
- GET /capabilities — what can this agent verify?
- GET /context/workflows — what are the business rules for this workflow?
- POST /verification/execute — run a verification workflow
- POST /verification/assess-risk — what is the risk of this change?
The analogy we keep coming back to: what OpenAPI did for REST APIs, OQP does for agentic software verification.
Early contributors include Philip Lew (XBOSoft) and Benjamin Young (W3C JSON-LD Working Group). Looking for feedback from engineers building on top of MCP, agent orchestration frameworks, or anyone who has felt the pain of "the agent shipped something wrong and we had no way to catch it."
Repo: github.com/OranproAi/open-qa-protocol

value: Show HN: OQP – A verification protocol for AI agents


value:
Hey HN, I'm Naveen, one of three co-founders building Mercury (mercury.build).
We spent the last year in deploying AI agents for teams in large enterprises. The agents themselves worked fine. The problem was managing them. You've got Claude Code in a terminal, a research agent in a browser tab, a Slack bot somewhere else, a scheduling assistant in yet another window. It's chaotic. There's no single place to see what's running, who's doing what, or how things connect. As the number of agents grows, this gets unmanageable fast.
Mercury is a canvas where you bring your agents and humans together in one place. You draw connections between them to form agent teams. An edge between Agent A and Agent B means A can delegate work to B — B processes the request, calls its tools, and replies. Agents can delegate further down the graph. The canvas becomes a living map of how your team operates.
Some details on the stack:
- Delegation as a primitive: when Agent A messages Agent B, it creates a persistent task. Tasks survive across activations so multi-step work doesn't lose context.
- Agent types: native Mercury agents (Anthropic SDK / Claude), plus adapters for Claude Code, Devin, Manus, OpenClaw, Gumloop, and any MCP-compatible agent. Mix them on the same canvas.
- 800+ tool integrations via Composio (Gmail, Calendar, Slack, Linear, Notion, etc.) with per-agent OAuth.
- Channels: agents reach humans via the web UI, iMessage, or Slack. External triggers (new email, calendar event) can wake agents and kick off workflows.
- Human-in-the-loop by default: agents need approval before real-world actions. You relax controls per-agent as trust builds.
We've been running Mercury on Mercury for months — 30+ agents supporting a 3-person team. Scheduling, sales ops, engineering triage, finance. The thing that surprised us most: the hard part was never getting a single agent to be smart. It was getting five of them to not duplicate work, not contradict each other, and not spam the same human with redundant questions.
We've raised $1.5M from a16z, with investors from OpenAI, Cognition, and others. We're opening up alpha access — if you're interested: mercury.build
One question we'd love the community's take on: where should memory live — in the orchestration layer or the agent layer? We started by managing memory at the org level, exposing it as tools or injecting it into agent context. But not all agents are created equal. Some handle memory well on their own, and we need to pick our battles. The role of the orchestration layer in memory management is one of the harder design decisions we're wrestling with, and we'd genuinely love to hear how others think about it.
We put together a short walkthrough if you want to see the UX before signing up: https://youtu.be/jpKvbyjkXMU
Happy to answer anything about the stack, the agent communication protocol, or the dumb mistakes we made along the way.

value: Show HN: Mercury – No-code orchestration for human and agent teams


story_text:
As AI agents autonomously write and deploy code, there's no standard for verifying that what they shipped actually satisfies business requirements. OQP is an attempt to define that standard.
It's MCP-compatible and defines four core endpoints:
- GET /capabilities — what can this agent verify?
- GET /context/workflows — what are the business rules for this workflow?
- POST /verification/execute — run a verification workflow
- POST /verification/assess-risk — what is the risk of this change?
The analogy we keep coming back to: what OpenAPI did for REST APIs, OQP does for agentic software verification.
Early contributors include Philip Lew (XBOSoft) and Benjamin Young (W3C JSON-LD Working Group). Looking for feedback from engineers building on top of MCP, agent orchestration frameworks, or anyone who has felt the pain of "the agent shipped something wrong and we had no way to catch it."
Repo: github.com/OranproAi/open-qa-protocol

title: Show HN: OQP – A verification protocol for AI agents


value: Our AI Native IDE, 6digit studio, has a new Big Picture Mode visualization layer, CORDIAL, meant to be possible to use at a "distance", making you feel just a little bit more like Tom Cruise in Minority Report.

value: Show HN: AI Native IDE [video]

title: Show HN: AI Native IDE [video]


value: agentseal

value:
Built this after realizing I was spending ~$1400/week on Claude Code with almost no visibility into what was actually consuming tokens.
Tools like ccusage give a cost breakdown per model and per day, but I wanted to understand usage at the task level.
CodeBurn reads the JSONL session transcripts that Claude Code stores locally (~/.claude/projects/) and classifies each turn into 13 categories based on tool usage patterns (no LLM calls involved).
One surprising result: about 56% of my spend was on conversation turns with no tool usage. Actual coding (edits/writes) was only ~21%.
The interface is an interactive terminal UI built with Ink (React for terminals), with gradient bar charts, responsive panels, and keyboard navigation. There’s also a SwiftBar menu bar integration for macOS.
Happy to hear feedback or ideas.

value: Show HN: CodeBurn – Analyze Claude Code token usage by task

author: agentseal


value: Show HN: Skill files made this AI Workout Builder Good


value:
A clock radio from the 1950s played music and showed the time. I wanted to see what happens when you combined an old idea with a new one — the music itself tells you the time. It's also hilarious.
This is a fully automated YouTube live stream. Every few minutes, a new AI-generated song plays. Every song is in a different genre. Every song's lyrics are about what time it is right now. The system generates them ahead of time using Suno's API, builds video segments with FFmpeg, and streams continuously via RTMP. There's no human in the loop and no pre-recorded content.
The core challenge is a scheduling problem: generation takes ~3 minutes, song durations are variable (2-4 min), and the lyric timestamp has to match the actual start time. The orchestrator tracks a rolling average of API latency and adjusts its lookahead window accordingly.
Stack: Python, Suno API, Pillow, FFmpeg.

value: Show HN: A 24/7 live stream where AI writes a new song about the current time


value:
I very frequently use Excalidraw for presentations and writing, but the charting ability is relatively limited.
This project surfaces a CLI which supports a wider variety of chart types and parameters.<p>Outputting a .excalidraw file means that rather than endlessly tweaking parameters to get chart elements positioned just right, you can simply drag them around like any other Excalidraw scene.

value: Show HN: Excalicharts – Charting Library for Excalidraw


value: whamwhamwham

value: Show HN: Blander – Makes NYT headlines boring on purpose

author: whamwhamwham


value: Show HN: I Created a Web Version of My First App Game


value: dogancan

value: Inspired by the BBC's Ceefax service. 155 news sources, live tickers for markets/sports/predictions. No login, no tracking. Shareable via 4-character codes.

value: Show HN: teletext, a ceefax-inspired live news ticker

author: dogancan


value: stackdirector

value: A floating performance overlay for React Native. See your app's FPS, memory, re-renders, and network activity in real time, right on screen.

value: Show HN: React-native-sightline – floating dev overlay for FPS/memory/re-render

author: stackdirector


value: cbchhaya

value:
prmana replaces static SSH keys with short-lived OIDC tokens validated at the host through PAM. What makes it different from other OIDC-for-SSH approaches is DPoP (RFC 9449) — every authentication includes a cryptographic proof that the token holder has the private key. Stolen tokens can't be replayed.
Three components: a PAM module (pam_prmana.so), a client agent (prmana-agent), and a shared OIDC/JWKS library (prmana-core). All Rust.
DPoP keys can be software, YubiKey (PKCS#11), or TPM 2.0. No gateway, no SSH CA, no patches to sshd. Standard ssh client, standard sshd, PAM in between.
Tested against Keycloak, Auth0, Google, and Entra ID.
The name is from Sanskrit — pramana (प्रमाण) means "proof."

value: Show HN: Prmana – OIDC SSH Login for Linux with DPoP (Rust, Apache 2.0)

author: cbchhaya


value: rogerdodgerwang

value: Show HN: 2nnel – self-hosted ngrok with one-click framework-agnostic deployment

author: rogerdodgerwang


value: whitemanv

value: Show HN: Deflect One – command line dashboard for managing Linux servers via SSH

author: whitemanv


value: Show HN: Shloka Artha [Word-by-Word Meanings for Shlokas]


value: timfinnigan

value:
Wrote this to clean up my Downloads folder. It moves top-level files into subfolders named after their extension. photo.PNG goes into png/, files with no extension go into no_extension/. --dry-run if you want to see what it would do first.
A few details: it doesn't recurse into existing subfolders, extensions are lowercased so you don't get png/ and PNG/ coexisting, and it handles name
  collisions by appending _1, _2, etc. rather than overwriting.
~150 lines of Rust, no dependencies outside of tempfile in dev.
cargo install --git https://github.com/timfinnigan/groupr
groupr ~/Downloads --dry-run

value: Show HN: Groupr – Rust CLI that sorts files into subfolders by extension

author: timfinnigan


value: Show HN: One-command deploys from your terminal with CreateOS CLI


value: I was building with MuJoCo and realized passing a 60fps state to an LLM is impossible. So I implemented Rodney Brooks' 1986 Subsumption Architecture for modern LLMs.

value: Show HN: SCP – A protocol that drops LLM API calls to zero in 60fps physics loop


value:
I was tired setting up file uploads for multiple projects with bloated aws-sdk so built my own, my first attempt was next-s3-uploader, it worked but needed much better developer experience and wanted to get all benifits of typesafe Typescript, and wanted to have a very light weight toolkit that can do all things a dev needs to manage s3.
Credits to `aws4fetch` which made it be able to run in edge enviornments and cloudflare workers, now im trying to expand and build towards non Reactjs frameworks too and have support.
Setting up file uploads shouldnt be hard, but is. the easier options have vendor lockin's.
So made a DX friendly, typesafe file upload library, enjoy. Happy to discuss any improvements and options.
Repo: https://github.com/abhay-ramesh/pushduck

value: Show HN: Pushduck – S3 uploads that run on Cloudflare Workers, no AWS SDK


value: saranshrana

value:
We use Claude Code, Cursor, and Copilot daily. These tools run shell commands, read files, and call APIs on their own. When something goes wrong you find out after.
A .env file gets read, a secret ends up somewhere it should not, a command runs that nobody approved. EDR sees process spawns. Cloud audit logs see API calls. Neither understands that the agent's chain of actions together is credential theft.
Burrow sits between the agent and the machine. You define policies in plain language, like "block any agent from deleting production resources" or "alert if an agent reads AWS credentials and then sends data to an external endpoint." Burrow maps those policies against the actual tools, MCP servers, and plugins in your environment, then intercepts tool calls at the framework level before they execute. Risky calls get dropped. Everything else passes through.
Works with Claude Code, Cursor, Copilot, Windsurf, CrewAI, LangChain, LangGraph, and a few more. CLI and SDK install in under a minute. Free tier for individuals, paid for teams.
I ran infrastructure security at a large media company before this. Going full time on Burrow later this month. Happy to answer anything, especially the "does this actually work in production" question.
try - https://burrow.run

value: Show HN: Burrow – Runtime Security for AI Agents

author: saranshrana


value: darshanmakwana

value:
Last week I wanted to quickly view some Gaussian splats which I had trained on a remote server that didn’t have any open ports or a display device. So I ended up downloading everything locally just to inspect the results
This weekend I put together a terminal-based Gaussian splats viewer that renders directly in the terminal. It works over SSH and currently runs on CPU only and written in rust with claude code. I’ve found it to be pretty useful for quickly checking which .ply files correspond to which scenes and getting a rough sense of their quality.<p>Along the way, I also wrote a small tutorial on the forward rasterization process for Gaussian splatting on CPUs

value: Show HN: Tsplat – Render Gaussian Splats directly in your terminal

author: darshanmakwana


value: contrario

value: Show HN: Nous – A compiled language for self-healing AI agents

author: contrario


value: visiohex

value:
I built this because most Connections helper pages jump to the answer too quickly.
This one is designed to feel more like a coach than a spoiler page: light hints first, stronger hints only when needed, archive pages for review, Sports Edition support, and a small result analyzer for post-game review.
It updates automatically every day and is built as an independent side project.

value: Show HN: Connections Hint Today – spoiler-safe hints for NYT Connections

author: visiohex


value: sunandsurf

value:
A few weeks ago, ARC-AGI 3 was released. For those unfamiliar, it’s a benchmark designed to study agentic intelligence through interactive environments.
I'm a big fan of these kinds of benchmarks as IMO they reveal so much more about the capabilities and limits of agentic AI than static Q&A benchmarks. They are also more intuitive to understand when you are able to actually see how the model behaves in these environments.
I wanted to build something in that spirit, but with an environment that pits two LLMs against each other. My criteria were:
1. Strategic & Real-time. The game had to create genuine tradeoffs between speed and quality of reasoning. Smaller models can make more moves but less strategic ones; larger models move slower but smarter.
2. Good harness. I deliberately avoided visual inputs — models are still too slow and not accurate enough with them (see: Claude playing Pokémon). Instead, a harness translates the game state into structured text, and the game engine renders the agents' responses as fluid animations.
3. Fun to watch. Because benchmarks don't need to be dry bread :)
The end result is a Bomberman-style 1v1 game where two agents compete by destroying bricks and trying to bomb each other.
You can check a demo video here: https://youtu.be/4x8tVypmuRk
Would love to hear what you think!

value: Show HN: A Bomberman-style 1v1 game where LLMs compete in real time

author: sunandsurf


value: melvinmelih

value:
Over the holidays I went looking for a reading app for my 4-year-old daughter. The top app in this space charges $500/month. Since that's a bit much to pay for an app, I figured I could vibe code something better in a few days, so I tried.
The app uses DISTAR phonics, which is a method from the 60s by Siegfried Engelmann. The core idea is simple: teach sounds before letter names, then blend sounds into words, then words into sentences. There's a specific sequence that builds on itself.
On top of that I added spaced repetition, same algorithm as Anki. Cards come back at increasing intervals depending on how well the kid does. This keeps sessions short, maybe 5-10 minutes, and the retention is noticeably better than just drilling the same set of cards every day.
Each card has an AI-generated illustration and spoken audio. All 721 cards are pre-generated and bundled with the app. Nothing calls an API. The whole thing works offline.
What's in it: 721 cards (letters, digraphs, words, sentences), speech recognition for pronunciation practice, no account, no data collection, no ads. Source is on GitHub.
She's been using it for a bit more than 3 months now, roughly 10 minutes a day. She can now recognize phonetic patterns in words and read simple books in English.
No monetization, no data tracking whatsoever. Also available for free on the App Store (if you don't want to deal with the hassle of compiling the app from source): https://apps.apple.com/us/app/early-reader-preschool/id67571...

value: Show HN: Early Reader – Free open source reading app I built for my 4-year-old

author: melvinmelih


value: benchmarkapp

value: Show HN: GTMJobs – a job board with GTM Engineer jobs ONLY

author: benchmarkapp


value:
Hello HN,
I want to share a small wrapper I built around https://news.ycombinator.com/item?id=47708818.
The idea is to allow instant switching between fullscreen apps / desktops, with the ability to register shortcuts to instantly jump to your favorite apps, without animations.
To be clear most of the hard work was done here:
https://github.com/jurplel/InstantSpaceSwitcher, this is just a wrapper to build custom shortcuts around this solution, Ala Apptivate.
This is mostly vibe coded, but took me a bit of time to get right and is really useful for my workflow, and I know it's a very common pain point for Mac tech users, so thought I would share.

value: Show HN: Instant macOS space and app switcher


value: derstruct

value:
Doors: Server-driven UI framework + runtime for building stateful, reactive web applications in Go.
Some highlights:
* Front-end framework capabilities in server-side Go. Reactive state primitives, dynamic routing, composable components.
* No public API layer. No endpoint design needed, private temporal transport is handled under the hood.
* Unified control flow. No context switch between back-end/front-end.
* Integrated web stack. Bundle assets, build scripts, serve private files, automate CSP, and ship in one binary.
How it works:
Go server is UI runtime: web application runs on a stateful server, while the browser acts as a remote renderer and input layer.
Security model:
Every user can interact only with what you render to them. Means you check permissions when your render the button and that's is enough to be sure that related action wont be triggered by anyone else.
Mental model:
Link DOM to the data it depends on.
Limitations:
* Does not make sense for static non-iteractive sites, client-first apps with simple routing, and is not suitable for offline PWAs.
* Load balancing and roll-outs without user interruption require different strategies with stateful server (mechanics to make it simpler is included).
Where it fits best:
Apps with heavy user flows and complex business logic. Single execution context and no API/endpoint permission management burden makes it easier.
Peculiarities:
* Purposely build [Go language extension](https://github.com/doors-dev/gox) with its own LSP, parser, and editor plugins. Adds HTML as Go expressions and \`elem\` primitives.
* Custom concurrency engine that enables non-blocking event processing, parallel rendering, and tree-aware state propagation
* HTTP/3-ready synchronization protocol (rolling-request + streaming, events via regular post, no WebSockets/SSE)
From the author (me):
It took me 1 year and 9 month to get to this stage. I rewrote the framework 6 or 7 times until every part is coherent, every decision feels right or is a reasonable compromise. I am very critical to my own work and I see flaws, but overall it turned out solid, I like developer experience as a user. Mental model requires a bit of thinking upfront, but pays off with explicit code and predictable outcome.
Code Example:

  type Search struct {
    input doors.Source[string] // reactive state
  }

  elem (s Search) Main() {
    <input
      (doors.AInput{
        On: func(ctx context.Context, r doors.RequestInput) bool {
          s.input.Update(ctx, r.Event().Value) // reactive state
          return false
        },
      })
      type="text"
      placeholder="search">

    ~// subscribe results to state changes
    ~(doors.Sub(s.input, s.results))
  }

  elem (s Search) results(input string) {
    ~(for _, user := range Users.Search(input) {
      <card>
        ~(user.Name)
      </card>
    })
  }

value: Show HN: A stateful UI runtime for reactive web apps in Go

author: derstruct


value: elkabong

value:
I built KeepDates after realizing I kept missing important dates that were already saved in my contacts.
Birthdays are automatically handle by iOS, but everything else was just ignored. I always dutifully curated my contacts, adding different dates to each (friends' kids' birthdays, anniversaries, significant events), but always seemed to forget about them as the day approached. I tried manually adding them to my calendar, but it quickly became annoying to maintain.
So, this app is just there to handle it - it runs in the background (as much as that's possible on iOS) and periodically checks for changes to the contacts, and updates a separately maintained calendar with new dates/events (or removing ones that disappeared). That way, I can be sure that when I update a contact with new date information, it will be reflected in my calendar, and I'll get alerted on time.
That's it... that's the app.
It also has a bunch of different toggles, customizations, notifications and widgets, if handling it all by calendar isn't enough.
Happy to answer any questions or hear feedback! Would love to hear if others have run into this problem too, or if I'm the only one filling up my contacts data with all sorts of dates.

value: Show HN: iOS app that continuously turns contact dates into calendar events

author: elkabong


value: adinagoerres

value:
We run superglue, an OSS agentic integration platform. Last week I talked to a founder of another YC startup. She found a use case for our CLI that we hadn't officially launched yet.
Her problem: customers wanted to create Opps in Salesforce from inside the chat in her app.
We kept seeing this pattern: teams build agents and their users can perfectly describe what they want: "pull these three objects from Salesforce and push to nCino when X condition is true", but translating that into a generalized hard-coded tool the agent can call is a lot of work and does not scale since the logic is different for every user.
What superglue CLI does: you point it at any API, and your agent gets the ability to reason over that API at runtime. No pre-built tools. The agent reads the spec, plans the calls, executes them.
The founder using this in production described it like this: she gave the CLI to her agent with an instruction set and told it not to build tools, just run against the API. It handled multi-step Salesforce object creation correctly, including per-user field logic and record type templates.
Concretely: instead of writing a createSalesforceOpp tool that handles contact -> account -> Opp creation with all the conditional logic, you write a skill doc and let the agent figure out which endpoints to hit and in what order.
The tradeoff is: you're giving the agent more autonomy over what API calls it makes. That requires good instructions and some guardrails. But for long-tail, user-specific connectors, it's a lot more practical than building a tool for every case.
Happy to discuss. Curious if others have run into the "pre-defined tool" ceiling with MCP-based connectors and how you've worked around it.
Docs: https://docs.superglue.cloud/getting-started/cli-skills
Repo: https://github.com/superglue-ai/superglue

value: Show HN: A CLI that writes its own integration code

author: adinagoerres


value: maximbuz

value: Show HN: I analyzed 591 agentic engineering jobs: LangChain dominates at 22%

author: maximbuz


value: Show HN: How unique is your combination of interests among 8B people?


value: briandev

value: Show HN: Create forms that people enjoy filling out with Typerson

author: briandev


value: yofabr

value:
Every time I hit "address already in use" I'd run `lsof -i :3000`, grep for the PID, then kill -9 it. Three commands, every single time.
So I wrote `pkll`, one command that does all of it, but asks for confirmation with all info about the process, and warns if it is important system process first.
You run `pkll [PORT]`, then it shows all the essential info about the process. Then after confirmation the process is killed.
This became especially annoying with coding agents. They just spin up dev servers, then leave bun instances and other processes sitting silently in the background. You go to start your server and something invisible is already holding the port.
I built this to keep it dead simple: one thing, one command, works the same on Linux, macOS, and Windows. No config, no flags to memorize making it deadly simple.
Also I wrote it while learning Rust, so feedback on the code is very welcome.

value: Show HN: Pkll, a CLI tool that shows what's on a port before killing it

author: yofabr


value: monatis

value: Show HN: Afterimage is now open-source for infra-grade dataset generation

author: monatis


value: coderai

value:
Hi there.
I was looking for a pastebin-like instant solution for online meetings — a shared whiteboard with real-time sync. Of course there are Excalidraw and tldraw, BUT they require signup and are overgrown with features I don't need.
So I just built cnvs.app — instant sharing, no signup, real-time sync with all the essentials: drawing, writing, and pasting images. All in one day.
On day two I added sticky notes, full mobile support, and Mermaid diagrams (cool thing — try pasting some Mermaid syntax there!) and deployed to Cloudflare so everyone can use it for free.<p>Be creative. Have fun :)

value: Show HN: Needed instant realtime whiteboard for meetings so I built it in 1 day

author: coderai


value: itzami

value:
Hi HN!
I've been using kitty for a while but yesterday i decided to switch to ghostty and i realized that i would need tmux to manage my panes if i wanted to get the grid as i wanted
So i made the reasonable thing: built a visualizer for the layout so i can just copy the setup and drop the `.sh` wherever i need
I probably missed a few thing in this but it's my first day with tmux  any feedback would be absolutely amazing
Demo: https://tmux-grid.itzami.com
Repo: https://github.com/ItzaMi/tmux-grid

value: Show HN: Tmux-grid – a visual layout builder for tmux

author: itzami


value: samiahmadkhan

value: Show HN: VibeDrift – Measure drift in AI-generated codebases

author: samiahmadkhan


value: Weatherill

value: Show HN: Voight-Kampff Machine: Diagnostics of the "Is" vs. "Wish" Clash

author: Weatherill


value: stagas

value: Show HN: Techno Kick

author: stagas

title: Show HN: Techno Kick


value: Show HN: Bor – Policy management for Linux desktops