value: FadySGhatas

value:
Hi HN,
We’ve been working on Habits, an open-source system for building automations, AI agents, internal tools, and full apps from the same graph-based model.
The core idea is that you design logic as nodes we call Bits, optionally attach a UI, export the result as YAML, and then package it for different targets depending on the use case. That means the same project can become a Docker deployment, a standalone binary or single executable, a desktop app, or a mobile app.
We built it because we kept running into the same gap. Workflow tools are great for automation, but they usually stop short of helping you ship complete end-user apps. App builders help with UI, but often tie you to a specific platform or runtime. AI-generated code is fast, but not always something we wanted to maintain or hand over to teams. We wanted a system where the same project could move between code, visual editing, and AI-assisted generation while still being exportable and self-hostable.
The project has two main parts. Base is the visual builder for logic and UI, while Cortex is the runtime that executes the exported app or workflow. A Habit can be created by writing YAML files directly, building visually in Base, or generating it with AI.
The project is released under Apache 2.0.
GitHub: https://github.com/codenteam/habits
Docs: https://codenteam.com/intersect/habits
Video: https://www.youtube.com/watch?v=uhim-Y7b1vA
I’d especially love feedback on the architecture, the export and packaging model, and whether this feels more useful as an automation tool, an app builder, or something in between.

value: Show HN: Habits, an open-source builder and runtime for automations and apps

author: FadySGhatas


value: sergiusiv

value:
I built a Mac + iPhone system where the iPhone acts as a live trust key for selected processes on the Mac.

  How it works:

  - Mac and iPhone pair with mutual TLS
  - when the iPhone app is open, it establishes a trusted session
  - the Mac maintains that session with BLE presence + recurring trust proofs
  - if trust ends, the Mac kills the gated process

  Important constraint:
  on iPhone, this currently works only while the app is in the foreground. If the app is backgrounded, the phone is locked, or the app is closed, trust ends. In practice that means the usable trust window is short, roughly 15 to 60 seconds as no one would keep phone unlocked for too long.

  So the original idea of long-running DevOps sessions like SSH tunnels / kubectl port-forward probably does not hold up under this constraint.

  What may still fit:

  - decrypting a file for a brief operation
  - running a one-shot privileged script
  - briefly exposing a local signing daemon
  - short-lived key-use or signing actions.

The system is local-first:

  - no cloud
  - no remote server dependency for the core flow
  - the phone is effectively acting as a live possession key for Mac-side actions

  What I’m trying to figure out now is the actual use case.

  If you’ve ever wanted a sensitive local process to disappear the moment phone-backed trust ended, what was that process?

  I’d especially value blunt feedback on:

  - whether this solves a real problem
  - whether the foreground-only constraint kills it
  - whether there is a better use case than DevOps tunnels

  You can reach me at sergiu_robert@protonmail.com.

value: Show HN: iPhone-gated local actions on Mac

author: sergiusiv


value: dreynow

value: Show HN: Agent Trust – Cryptographic identity and reputation for AI agents

author: dreynow


value: zhangshuaikang

value: Show HN: PixelSwift – Image compression that never uploads your files

author: zhangshuaikang


value: yohannesgk

value:
Hi HN, I’m the developer behind BlacksmithAI - an OPEN-SOURCE automated security testing platform.
I started this project because security testing felt fragmented and slow. Running scanners, checking reports, and trying to piece together the results was tedious — even for experienced engineers. I wondered: what if AI could orchestrate the whole process, handle repetitive tasks, and guide you through what matters most?
BlacksmithAI is our answer. It’s like having a small team of AI “security assistants” that can:
* Map a site or network automatically
* Scan for common vulnerabilities
* Suggest what’s risky and what isn’t
* Run simple proofs‑of‑concept to see real impact
You don’t need to be a pentester to explore it — it’s designed to be approachable, with a web interface you can try in minutes. It’s still in beta, and completely free, but already helps security testers, developers, students, and security enthusiasts get quick insights without juggling ten tools at once.
We’d love feedback on:
* Usability for non‑experts
* Accuracy of findings
* Any rough edges or confusing parts
* Source code available if you want to self‑host.
Happy to dive into how it works under the hood if people are curious. Thanks for checking it out!

value: Show HN: BlacksmithAI – AI‑Assisted Penetration Testing Framework (Beta, Free)

author: yohannesgk


value: vhsdev

value: Show HN: Birdcage – Secure remote access for personal AI

author: vhsdev


value: KerryJones

value:
Hey everyone, founder of DealCred here.
I lost six figures to a real estate operator who defrauded 30+ investors. The FBI got involved. Class action lawsuits piled up. And it was completely preventable — if anyone had just left a review.
DealCred is a review platform for real estate deals. Look up lenders, borrowers, and operators before you wire money. It helps build reputations, free to use, and hoping to help prevent more fraud in the community.

value: Show HN: DealCred – Verified Reviews for Real Estate Deals

author: KerryJones


value: bahaghazghazi

value:
AI agents can call APIs, automate workflows, and do real work.
But they can’t pay.
So I built AgentPay: https://agent-purse.vercel.app �
It gives agents:
credits
spending limits
transaction tracking
Would love feedback from devs.

value: Show HN: AgentPay – Let AI agents pay for APIs autonomously

author: bahaghazghazi


value: sohamrj

value:
I built a semantic search CLI for dashcam footage using Gemini Embedding 2's native video embedding.
The interesting part: Gemini Embedding 2 projects raw mp4 video directly into the same vector space as text, no captioning or transcription pipeline. You embed 30-second video chunks as RETRIEVAL_DOCUMENT, embed a text query as RETRIEVAL_QUERY, and cosine similarity just works across modalities.
The tool splits footage into overlapping chunks, indexes them in a local ChromaDB instance, and auto-trims the top match from the original file via ffmpeg.
Cost is about $2.50/hr of footage to index, queries are negligible. Definitely room to optimize: skipping still frames, scene detection for smarter chunking, etc.

value: Show HN: SentrySearch – Semantic search over dashcam footage

author: sohamrj


value: AnatoleLucet

value:
Hi! For the past four months I've been working on loom: a signal-based components framework in Go for terminal UIs, the Web, and more.
I'm excited to share this initial release and get some feedback!
https://loomui.dev/blog/introducing-loom/
https://github.com/loom-go/loom

value: Show HN: Loom, a Component Framework for Go

author: AnatoleLucet


value: visiwig

value: Show HN: I built 48 lightweight SVG backgrounds you can copy/paste

author: visiwig


value: theGlenn

value:
Hi HN,
We built Xybrid, a Rust library for running LLM + speech pipelines directly inside your app, no server, no daemon, just one binary.
We started building it while working on a privacy-focused LLM app with Tauri and realized there wasn’t a straightforward way to embed models directly into shipped applications without relying on a separate server process.
Xybrid links into your process like any other library. It supports GGUF / ONNX / CoreML and integrates with Flutter, Swift, Kotlin, Unity, and Tauri, letting you run pipelines like speech → LLM → speech in a single call.
On recent phones, we’re seeing ~20 tok/s on Android and ~40 tok/s on iOS for small (~3B) quantized models (varies by device, backend, and thermals).
The demo that shows it best: a Unity tavern scene where 6 NPCs generate real-time dialogue fully on-device — no API key, no internet, no per-request cost.
Unity demo: https://youtu.be/vSPeTyeow6A
Desktop demo (Tauri): https://youtu.be/o83YShqV7O4
GitHub: https://github.com/xybrid-ai/xybrid
It’s still early — there are rough edges, especially around model support and performance tuning. Happy to answer questions about the architecture, backends, or integrations (Flutter, Swift, Kotlin, Unity, Tauri).

value: Show HN: Xybrid – run LLM and speech locally in your app (no back end, Rust)

author: theGlenn


value: ahmedlhanafy

value: Built a free alternative to Superwhisper. Whisper runs locally, optional LLM cleanup through OpenAI, Anthropic, or Ollama. MIT licensed.

value: Show HN: Yapper – free, open-source alternative to Superwhisper for macOS

author: ahmedlhanafy


value: zakmcintyre

value: Show HN: ThoughtTrack – On-device thought capture with NLP-powered resurfacing

author: zakmcintyre


value: illogicalabc

value: Show HN: Save Claude tokens with semantic search powered by SQLite and Ollama

author: illogicalabc


value: BohuTANG

value:
Hi HN, we're open-sourcing BendClaw today -- the distributed AgentOS behind Evot.AI.
The problem: one shared agent maxes out fast. Separate agents per person means everyone starts from zero. We wanted the third option -- distributed compute with shared knowledge.
BendClaw is a runtime where multiple agents run in parallel, each on its own node, but all connected to one shared data layer. When one agent learns something, every other agent has it on the next run. No prompt engineering, no manual handoff.
What's inside:
- *Shared memory* -- all agents read and write to the same knowledge base. Context, learnings, history, fully connected.
- *Cluster dispatch* -- agents fan out subtasks across nodes and collect results. Local and cloud nodes in one cluster.
- *Self-evolving* -- every run automatically extracts knowledge and injects it into future runs.
- *Trace and audit* -- every operation recorded. Who did what, which tools fired, what came back. All queryable.
- *Secret-safe* -- secrets vault-isolated, never exposed to the LLM. Approval gates on sensitive actions.
- *Token-aware* -- per-agent budgets with proactive alerts before anything runs out.
- *100+ integrations* -- custom tools via Skills: write a description, point it at a script, done.
Rust, Apache-2.0. Hosted platform at https://evot.ai if you want to skip self-hosting.

value: Show HN: BendClaw – Distributed AgentOS Written in Rust

author: BohuTANG


value: dylandevelops

value:
I built tmpo, a Go CLI time tracker. I started it because I was manually logging billable hours in Google Forms for my business, and it was painful.
Built with Cobra for the CLI structure. Features include auto-detection of projects via Git, local SQLite storage, milestones, pause/resume, CSV/JSON export, and hourly rate tracking.
No cloud, no accounts, just a binary and a local database.
Quick workflow:

    tmpo milestone start "Sprint 5"
    tmpo start "fixing auth bug"
    # ... work happens ...
    tmpo pause  # lunch break
    tmpo resume
    tmpo stop
    tmpo stats --week

This is my first Go project, and having the ability to do this sort of thing is helping me fall in love with this language. I'm hoping for a 1.0 release on Homebrew soon, and the goal would be to expand to other common package managers to make installation easier.
If you think it is cool or you want to add a feature, feel free to star the repo and open an issue! I would love to have some help from other developers!
You can find the MIT-licensed GitHub repository here: <https://github.com/DylanDevelops/tmpo>

value: Show HN: tmpo – CLI time tracker with automatic project detection

author: dylandevelops


value: paujur

value: Show HN: TengineAI – Infrastructure for running AI tools in production

author: paujur


value: unTamper

value:
https://untamper.com
Built this after hitting the same gap on multiple projects: teams log critical events (admin actions, permission changes, PII access) but have no structural way to prove those records weren't altered after the fact.
Immutable storage (S3 Object Lock, WORM) are common, but it only covers tampering after the write lands. It doesn't protect against someone with DB write access, and it doesn't give a third party, e.g. an auditor, a way to verify integrity without touching your infrastructure.
My approach: hash chaining.
Each event is SHA-256 hashed against its canonical payload + the hash of the previous event. Any insertion, deletion, or modification breaks all subsequent hashes. Anyone with the public API can re-verify the chain independently.
A few decisions I'm happy to discuss:
- Canonicalization before hashing: JSON isn't canonical by default. Ended up writing a strict sorted-key schema rather than fighting recursive serialization.
- Per-actor chains vs. one global chain: Global is simpler to verify but creates write contention and makes auditor exports painful. Per-actor trades some global integrity for operational sanity.
- Trusted server-side timestamps anchored into the hash: If the client controls the timestamp, you can reorder events without breaking hashes.
- Periodic anchoring to a public chain: On the roadmap for the "full infra access + rewrite the whole chain" attack vector.
SDK is available (nodejs, others are coming). Integration is trivial. Free tier available without CC.
Happy to go deep on the crypto model, the canonicalization approach, or the trust assumptions.

value: Show HN: unTamper – cryptographically verifiable audit logs for app events

author: unTamper


value: kreicer

value:
Hi HN,
I built hanoi-cli, a small CLI tool that analyzes how pods are distributed across Kubernetes nodes and suggests a better placement.
The idea came from a recurring issue: clusters often end up imbalanced even when requests/limits are set properly. Some nodes get overloaded while others stay underutilized.
Would love feedback.

value: Show HN: Hanoi-CLI – simulate and optimize pod placement in Kubernetes

author: kreicer


value: markshtat

value: Show HN: Procedural tree and boulder sprite generation – TypeScript library

author: markshtat


value: tanbirrrrr

value:
I applied to over 200 jobs last month. Tailored resumes by hand, rewrote cover letters late at night, and still got no responses for most of them.
Eventually I realized the problem wasn't the resume quality. It was that ATS systems were filtering applications out before a human ever read them. Most job seekers have no visibility into why this happens or how to fix it per role.
So I built CareerKit.
You upload a resume and paste a job description. It returns an ATS compatibility score, flags missing keywords and skill mismatches, then generates a tailored resume and cover letter for that specific role.
Tech stack: React, TypeScript, Node.js, Python.
The target user is early-career professionals and recent grads. They tend to have less natural keyword overlap with job descriptions because they have shorter work histories, which makes ATS filtering hit them harder than experienced candidates.
Free tier available with no card required.
https://careerkit.site
A few things I am uncertain about and genuinely want input on:
1. ATS scoring feels like the right hook but I keep wondering if the resume generator is actually more valuable to users. Hard to tell from early usage.
2. The free tier is limited (1 resume analysis, 1 resume generate,3 cover letters lifetime). I am not sure if that is tight enough to convert or too stingy to show value.
3. Keyword matching currently works by comparing the resume text against the job description. Curious if anyone has thoughts on better approaches here.
Happy to answer questions about how it works.

value: Show HN: CareerKit – ATS scorer and resume tailoring tool for job seekers

author: tanbirrrrr


value: gosixl

value:
FLUF Connect (fluf.io) lets resellers list a product once and push it to Depop, eBay, Vinted, Vestiaire Collective, Shopify, Facebook Marketplace, Temu, and Yaga with real-time inventory sync. Available as a web dashboard, Chrome extension, and mobile app (iOS + Android).
The hard problem isn't the listing — it's the sync. When something sells on Depop at 2am, eBay and Vinted stock needs to update in seconds or the seller wakes up to overselling complaints and bad reviews.
Some things I learned building this:
- Marketplace APIs lie: Response formats change silently. Endpoints return 404 for reasons that have nothing to do with the item not existing. You can't trust the contract — you need fallbacks for everything.
- Relisting matters more than listing: Resellers delete and re-post items to boost visibility in marketplace algorithms. The difference between random relisting and data-driven relisting is measurable in sales.
- AI handles the heavy lifting: Take a photo, and AI generates the title, description, category, price, and condition — ready to list across all platforms. The mobile app also has an AI chat agent that helps sellers refine existing listings with better copy and pricing based on what actually sells.
- Smart pricing across platforms: Each marketplace has different fee structures, shipping costs, and buyer expectations. We built a pricing engine that adjusts prices per-platform so sellers hit their target sellthrough rates everywhere without manual calculations.
- Mobile app for on-the-go sourcing: Sellers photograph items at charity shops or car boot sales, AI creates the listing, and it's live on 8 platforms before they leave the shop.
- WordPress scales further than people think: We process 500,000+ products and tens of thousands of async jobs daily on a PHP/WordPress stack. It's not sexy but it works.
~1,000 resellers use it. 30-day free trial, paid plans from £19/month.
Happy to answer questions about the reselling market or building on top of platforms that don't want you to.

value: Show HN: Built a crosslister (in PHP!) that supports Vinted (which has no API)

author: gosixl


value: kennethhh

value: Show HN: My VPS got DDoS'd into a kernel panic, so I learned XDP

author: kennethhh


value: yamafaktory

value: Show HN: HypergraphZ – Hypergraph Implementation in Zig

author: yamafaktory


value: ishanr

value:
Hey HN,
I built this originally last year because I was frustrated that epubs even though they are digital are not being fully utilized.
I also read on many different platforms and I wanted all of my books to automatically sync.
I also have a bunch of friends who read the same books, so I built a little chatroom that you can get into if you all have the same book.
Lately voice models have gotten really good. So I also incorporated on device models which reads the book to you as an audiobook.
The app is in Tauri and using InstantDB for the database and backend sync. Really love the work stopachka and folks are doing with that.
Rust helps in doing a lot of the heavy lifting and onnx runtimes are great for cross platform model loading.
My kids also read on it so there is a pet (a cat or a dog) which can be a companion while you read and they move around and animate and tell you how many pages are left based on it's position on the page.
Long term I want to publish books from independent authors on this and have a directy publishing model but that's not there now.
Anyway, let me know if I can answer any questions about reading, rust, architecture, local models etc etc.
p.s. My fav author is Leo Tolstoy.

value: Show HN: Augre – A cross platform ePub reader for deep reading

author: ishanr


value:
I built Packet28 because coding agents tend to treat the whole loop like an ever-growing transcript.
Repo reads, diffs, logs, stack traces, and tool output keep getting dragged into the next step. That works for short tasks, but on longer loops the agent starts spending too much of its budget re-reading history.
Packet28 is my attempt at fixing that.
It’s an open-source MCP + hook system that reduces noisy dev/tool output into smaller packets, persists useful state in a daemon, and prepares handoffs when context gets too full. The goal is to keep the live turn small instead of letting one session grow forever.
You can install it locally and run setup on your own repo today. Packet28 currently exposes MCP tools, supports proxying upstream MCP servers, integrates with hooks, and uses packet28d for persistent state, indexing, caching, and handoff/relaunch flows.
Would love feedback on whether this fits real agent workflows, whether the MCP + hooks split makes sense, and what reducers or integrations would make it more useful. I’ll be around in the thread.

value: Show HN: Packet28 – Context Layer for AI coding agents


value: eigenlab

value: Show HN: The-telegram-telegram (thermal printer style)

author: eigenlab


value: Bulugulu

value:
I save all my chat transcripts because I believe this data will matter as a work credential (or resume substitute). Y Combinator already asks founders to submit AI coding transcripts. I think that's the beginning of something bigger: your conversations with AI are a more honest signal of how you think and work.
Motif is a small step toward that. It reads Cursor's internal SQLite database and Claude Code's project files, extracts your conversations locally, and generates a report. I incorporated a few different psychology frameworks and AI coding assessments.
The conversations for Claude, Cursor, etc. are stored differently and Motif can extract from different/multiple sources (e.g. SQLite for Cursor). I plan to add support for more tools.
What it measures: autonomy ratio (agent actions per human message ), agent concurrency, prompt verbosity. It will give you an AI coding score based on a framework I built.
It also uses some research-based psychology frameworks: Bloom's taxonomy (critical thinking), Pennebaker's LIWC (language use patterns), Epistemic Stance Analysis (Certainty in language). E.g., I involuntarily use "we" and "let's" a lot when working with AI, and that has implications under these frameworks.
There's also a real-time dashboard (motif live) inspired by APM counters in StarCraft. I used to play SC2 semi-pro (Terran GM) so I like measuring these things. It tracks AI tokens per minute and concurrent agents, summarizes every session, and saves your personal bests. It's a vanity metric but fun to look at. The dashboard will detect idle sessions and restart sessions.
Everything is local and Apache 2.0. Motif will install a skill in Cursor/Claude so you can ask them to run it after installing.

value: Show HN: Motif - Analyze your Cursor and Claude Code chat history

author: Bulugulu


value: chaiyihein

value:
As a beginner learning to build ML models, I found it annoying to have to keep printing tensor shapes every other line, having to step through the debugger to check where did I mess up the shapes again.
So I built Trickle, it takes the data that flows through your code, caches the types and display them inline (as if you have type annotations).
The idea is: "Let types trickle from runtime into your IDE". You get types in Python without having the write them manually.
It works by rewriting your Python AST at import time — after every variable assignment, it inserts a lightweight call that records the type and value. No decorators, no code changes. Just run your script through trickle run python train.py and every variable gets its type visible.
One cool feature is Error snapshots, by toggling it in VSCode status bar, you can see the exact data that is in each variable when the error happened.
For AI agents, trickle-cli outputs the inline runtime types together with the source code so agent can better diagnose the issue.
For Jupyter notebooks: %load_ext trickle as your first cell, and every cell after is traced.
Quick try:
   pip install trickle-observe
   npm install -g trickle-cli
   code --install-extension yiheinchai.trickle-vscode

   trickle run python demo/demo.py
   trickle hints demo/demo.py

Limitations:
   - Expect 2-5x slowdown — designed for development, not production.
Also supports JavaScript/TypeScript (Express, Fastify, Koa, Hono) though the Python/ML side is where I've focused most effort.
In the future, I imagine there to be potential for using this as runtime observability in production via probabilistic sampling of types. Now, we know the code, we know the data, which is all the information we need to debug.
Happy to answer questions

value: Show HN: I got tired of print(x.shape) so I built runtime type hints for Python

author: chaiyihein


value: xydac

value:
Hi HN – I’m Laxmi. I’ve been building an iOS file manager called BulkHead
and wanted to share it here.
The short version: it connects to SFTP, SMB, WebDAV, and S3 servers from
your iPhone or iPad. I kept reaching for my laptop just to check a file on
my NAS or poke around an S3 bucket, and the built-in Files app really only
handles iCloud and basic SMB. So I built the thing I wanted.
You can browse and manage files, preview images/PDFs/video/code, and edit
markdown or code files right on the server (it saves back when you’re done).
It also does SSH key management, shows up as a storage provider in the iOS
Files app, and has this external display mode where you plug in via USB-C
and your phone turns into a remote control for the big screen.
Free tier gets you 3 connections with all four protocols, full browsing,
preview, editing, favorites, biometric lock, SSH keys – no account needed.
There’s a 7-day Pro trial on first install too.
Pro is $6.99/year or $14.99 one-time. That gets you unlimited connections,
a transfer queue for batch/background transfers, encrypted file cache, and
external display controller mode.
On privacy – there are zero analytics, zero tracking, and no third-party
SDKs in the app. Credentials live in iOS Keychain and never leave the device.
The App Store privacy label says “Data Not Collected” and I intend to keep
it that way.
Tech-wise it’s SwiftUI on iOS 17+. The networking layer uses Citadel for
SSH/SFTP, SMBClient for SMB, and Soto for S3 – all open source.
App Store: https://apps.apple.com/us/app/bulkhead/id6759474201
Site: https://www.oddinks.com/bulkhead
Privacy: https://www.oddinks.com/bulkhead/privacy
Would love feedback.

value: Show HN: BulkHead – iOS File Manager for SFTP, SMB, WebDAV, and S3

author: xydac


value:
AI agents are great at software because the loop closes — edit, run, observe, repeat. Hardware breaks that loop. The agent can write firmware, but it can't see what the device is actually doing.
This project is about closing that gap. Three MCP servers give the agent direct access to real hardware interfaces: a debug probe (flash firmware, halt CPU, read registers and memory), a serial console (boot logs, CLI commands), and BLE.
Structured tools, not shell commands, so the agent can reason about hardware state the same way it reasons about code.
The latest demo: deploying a TFLite Micro keyword spotting model on an nRF52840 from a single terminal session. The agent flashed firmware, debugged a hard fault, switched to CMSIS-NN optimized kernels, and right-sized the tensor arena.
End result: 98ms end-to-end latency, 94.6% accuracy on real recordings from the Google Speech Commands dataset.
This is part of a broader series on giving AI agents direct access to hardware: https://es617.github.io/let-the-ai-out/

value: Show HN: AI agent deploys an edge AI model on a microcontroller via MCP


value: arcadianalpaca

value:
Hey HN! I recently switched to Android after 15 years as an iPhone user. What I missed the most after switching was my old audiobook player, and I couldn't find one I liked. So I decided to build one.
It's called Earleaf, and lets you play your local audibook files.
The feature I'm most excited about is Page Sync. You take a photo of a page in your physical book (or e-book) and the app finds that position in the audiobook and jumps to it. It works by transcribing the book on-device, and when you take a photo, it uses ML Kit to do the OCR scanning, and matches the text against the transcription. The initial transcription takes a while, but that's a one-time thing, and when it's in place, the actual search takes about two seconds on my device. And everything runs locally.
Aside from Page Sync, it's a full-featured player with nested collections, independent listen-through tracking, and a pretty good statistics feature. There are no accounts, no internet required, no ads.
Happy to answer questions about the app and its features!

value: Show HN: I built an audiobook player that syncs with your physical book

author: arcadianalpaca


value: camillemolas

value:
I built this: rusmarterthananllm.com
Domain experts, doctors, lawyers, engineers, submit questions from their field that probe where frontier AI actually fails. Claude, GPT, and Gemini all attempt simultaneously. Experts flag errors with professional reasoning. Other credentialed professionals in the same domain verify them.
AI benchmark performance has decoupled from real-world professional capability. Models score at or near ceiling on standard evaluations while still failing in ways that domain professionals catch immediately. The benchmarks that exist are either saturated, constructed by the labs themselves, or simply don't capture the judgment that comes from years of field experience.
What's missing is a benchmark built by the people whose expertise is actually at stake. Professionals motivated to find failures, not validate models. Every verified failure becomes a permanent data point. The benchmark compounds continuously and can't be reverse-engineered because the questions come from human judgment, not datasets.
This extends to multimodal inputs. A radiologist can submit an X-ray. A cardiologist can upload a heart sound. A structural engineer can attach a blueprint. The same adversarial evaluation across text, image, audio, and documents in the domains where multimodal model failures matter most.
The downstream goal is a verified record of where frontier AI breaks across professional domains. Useful for labs evaluating models, researchers studying capability gaps, and professionals who need to know where to trust AI and where not to.
Early domains: medicine, law, finance, engineering, coding, trades
Would love domain experts to throw their hardest questions at it. What breaks in your field?

value: Show HN: I built a game where domain experts try to break frontier AI

author: camillemolas


value: meandave

value:
I have too many vehicles. Cars, motorcycles, tractors -- they pile up when you can't say no to a project. Keeping track of everything across all of them was the problem: which parts I ordered for which thing, what codes I pulled last month, when I last changed the oil on the tractor.
It started because I got tired of typing my year/make/model into RockAuto and AutoZone every time I needed a part. So I built a browser extension that auto-fills vehicle info from a saved garage. That lasted about a week before I started bolting on more features.
The diagnostic pipeline is where I've spent the most time. The mobile app pulls OBD2 codes from those $15 Bluetooth ELM327 scanners, then sends them to an LLM with vehicle specs, known TSBs, and common failure patterns for that specific make/model/year. ranked probable causes, DIY vs shop cost estimates, severity rating, and linked a ChrisFix video for the repair. I've been tweaking the prompts and context window for months. The whole point is closing the loop: check engine light comes on, pull codes from your phone, get a report telling you what's wrong, how bad it is, and how to fix it.
Other stuff:
- 50 state selling wizard - generates the correct bill of sale, title transfer docs, and disclosure forms for any US state.
- 16 vehicle types with type-specific fields (PTO type for tractors, hull material for boats, engine CC for motorcycles, etc.)
- Task boards per vehicle - kanban for garage projects with parts-ordered/received/installed tracking.
TypeScript throughout. The extension, web app, and mobile app share a backend.
Free tier is 1 vehicle with full features, no credit card.
Been heads-down for a while and just now coming up for air.
Happy to answer questions about the OBD2 integration, the LLM diagnostic stuff, or the 50-state document generation.

value: Show HN: Crew Chief – OBD2 diagnostics via cheap Bluetooth scanner

author: meandave


value: lurkingllama

value:
Hi all, I wanted to show something I've built. Picasso is a simple command-line tool that lets you generate and edit images using popular providers. It wraps OpenAI, Google Gemini, and FLUX (Black Forest Labs) behind one consistent interface, so you can try out different models using the same commands. I'm open to adding other providers if there is demand for it.
I created it because juggling multiple AI image APIs is tedious. They each have their own SDKs, parameter names, and quirks. I aimed to simplify all of this so that you can focus on the creative part, which is actually generating images.
I'm hoping others find this useful!

value: Show HN: CLI tool for generating AI images

author: lurkingllama


value: hberrg

value:
I’ve recently read this [1] post about the compose key on linux which I thought it was pretty cool and I was looking for something similar on macOs.
One issue with apps emulating the linux default input way [compose-key] + [sequence keys] was that im a clumsy typer and so i’d rather see what im typing before its replaced with the result of the compose sequence. Since I’m a dev but i haven’t had much experience coding in swift i thought i would see if i can use claude code to create an app for myself to use compose sequences via text snippets.
The result is SnippetCompose: https://github.com/horstf/SnippetCompose
This way I can input compose sequences but see the input and correct myself, for example typing ::C= will be replaced with €.
[1] https://crescentro.se/posts/compose-key/

value: Show HN: macOS compose sequences via text snippets

author: hberrg


value: felipellrocha

value:
https://github.com/felipellrocha/bigbangrs
I built a GPU “big bang” particle sim in Rust (wgpu) over a 2-day sprint
I’ve spent a lot of time working on web engines, but had never really touched modern GPU compute directly, so I used this as an excuse to dive in and learn.
What it does:
- ~3 million particles simulated in real time
- Interactive framerates (hardware-dependent)
- Voxel-based “gravity” field that particles both write to and read from
- Fully GPU-driven (compute + rendering)
The basic idea:
Particles deposit “mass” into a voxel grid → the grid gets blurred over time → particles sample that field to derive a force → that drives motion.
It’s not physically accurate, but it produces some really interesting emergent structure.
What surprised me:
I tapped out at a relatively low particle count.
I’ve pushed GPUs much harder on the web before (tens of millions of grass blades in one of my games), so I expected to go further here. Not sure where the bottleneck is:
- WebGPU vs Metal vs wgpu
- Something dumb in my pipeline
- Or maybe I’m accidentally hitting a software fallback somewhere
I’m on an M1, so I’d expect this to scale better on something like an RTX 30xx+. The project seems almost entirely GPU-bound, but I wouldn’t be shocked if I’m wrong.
What it’s not:
- No collisions
- Not real gravity
- No conservation laws
- I’m not a physicist, and it shows
This is much more of a visual / emergent system than a real simulation.
Context:
I wrote the compute + rendering + simulation logic myself. Used AI to scaffold some surrounding pieces (including this post). This was mostly about learning how to actually use compute, not just read about it.
Thanks:
Huge shoutout to the Rust and wgpu teams. The fact that this is even approachable is kind of wild.
If you’re interested, check it out / break it / improve it. PRs welcome — I’ll review and merge anything solid.
Happy to answer questions or get roasted for the physics :)

value: Show HN: BigBangrs – A (simple, but fun) gravity simulator

author: felipellrocha


value: guilamu

value: Show HN: Mozilla Firefox is getting a free built-in VPN, with a catch

author: guilamu


value: bblcla

value:
Hey HN, If you’ve been lucky enough to be on a flight with Starlink, you understand the hype. It actually works!
However, its availability on flights is patchy and hard to predict. So we built a database of all airlines that have rolled out Starlink (beyond just a trial), and a flight search tool to predict it. Plug in a flight number and date, and we'll estimate the likelihood of Starlink on-board based on aircraft type and tail number.
If you don’t have any trips coming up, you can also look up specific routes to see what flights offer Starlink. You can find it here: https://stardrift.ai/starlink .
-
I wanted to add a few notes on how this works too. There are three things we check, in order, when we answer a query:
- Does this airline have Starlink?
- Does this aircraft body have Starlink?
- Does this specific aircraft have Starlink?
Only a few airlines at all have Starlink right now: United, Hawaiian, Alaskan, Air France, Qatar, JSX, and a handful of others. So if an aircraft is operated by any other airline, we can issue a blanket no immediately.
Then, we check the actual body that's flying on the plane. Airlines usually publish equipment assignments in advance, and they're also rolling out Starlink body-by-body. So we know, for instance, that all JSX E145s have Starlink and that none of Air France's A320s have Starlink. (You can see a summary of our data at https://stardrift.ai/starlink/fleet-summary, though the live logic has a few rules not encoded there.)
If there's a complete match at the body type level, we can confidently tell you your flight will have Starlink. However, in most cases, the airline has only rolled out a partial upgrade to that aircraft type. In that case, we need to drill down a little more and figure out exactly which plane is flying on your route.
We can do this by looking up the 'tail number' (think of it as a license plate for the plane). Unfortunately, the tail number is usually only assigned a few days before a flight. So, before that, the best we can do is calculate the probability that your plane will be assigned an aircraft with Starlink enabled.
To do this, we had to build a mapping of aircraft tails to Starlink status. Here, I have to thank online airline enthusiasts who maintain meticulous spreadsheets and forum threads to track this data! As I understand it, they usually get this data from airline staff who are enthusiastic about Starlink rollouts, so it's a reliable, frequently updated source. Most of our work was finding each source, normalizing their formats, building a reliable & responsible system to pull them in, and then tying them together with our other data sources.
Basically, it's a data normalization problem! I used to work on financial data systems and I was surprised how similar this problem was.
-
Starlink itself is also a pretty cool technology. I also wrote a blog post (https://stardrift.ai/blog/why-is-starlink-so-good) on why it's so much better than all the other aircraft wifi options out there. At a high level, it's only possible because rocket launches are so cheap nowadays, which is incredibly cool.
The performance is great, so it's well worth planning your flights around it where possible. Right now, your best bet in the US is on United regional flights and JSX/Hawaiian. Internationally, Qatar is the best option (though obviously not right now), with Air France a distance second. This will change throughout the year as more airlines roll it out though, and we'll keep our database updated!

value: Show HN: Will my flight have Starlink?

author: bblcla

title: Show HN: Will my flight have Starlink?


value: Show HN: RepoRadar, job search by tech stack. upload resume get results


value: Show HN: Realism – A goal-execution interface that builds live apps from prompts


value: trevxr

value: Show HN: Snare – catch hijacked AI agents before they make their first AWS call

author: trevxr


value: thijsverreck

value:
Hey HN,
Small OSS project that i created for myself and want to share with the community. It's a declarative, scriptable, terminal-based IDE focussed on agentic engineering.
That's a lot of jargon, but essentially its a multi-agent IDE that you start in your terminal.
Why is that relevant? Thanks to tmux and SSH, it means that you have a really simple and efficient way to create your own always-on coding setup.
Boot into your IDE through ssh, give a prompt to claude and close off your machine. In tmux-ide claude will keep working.
The tool is intentionally really lightweight, because I think the power should come from the harnesses that you are working with.
I'm hoping to share this with the community and get feedback and suggestions to shape this project! I think that "remote work" is directionally correct, because we can now have extremely long-running coding tasks. But I also think we should be able to control and orchstrate that experience according to what we need.
The project is 100% open-source, and i hope to shape it together with others who like to work in this way too!
Github: https://github.com/wavyrai/tmux-ide
Docs: https://tmux.thijsverreck.com/docs

value: Show HN: Tmux-IDE, OSS agent-first terminal IDE

author: thijsverreck


value: Show HN: Open-source Typeform

title: Show HN: Open-source Typeform


value: dspv

value:
Hey guys. I built this to solve my own problem — as a solo founder I needed consistent content but couldn't afford the time or a team.
The pipeline: keyword research → brief → Writer → Critic → Editor (up to 5 rounds) → SEO check → GEO optimization → auto-publish to GitHub-based blog.
The GEO part was the most interesting to build — structuring content so ChatGPT, Perplexity, Gemini, and Claude actually cite it. Each model has different citation patterns.
Also built a Citation Tracker that monitors brand mentions across all 4 AI platforms weekly.
Happy to answer questions about the architecture or approach.

value: Show HN: Bloq.ink – autonomous content pipeline (SEO and GEO for AI search)

author: dspv


value: pure-orange

value:
Hey HN!
Since terminal coding agents took over my workflow, I've been juggling more worktrees and MRs than ever — constantly switching between GitLab/GitHub dashboards, tmux sessions, and git worktrees. Agents would sit idle, MRs needed rebasing, and I'd miss it all while focused on my main task.
Hence I built Pertmux. It's a Rust TUI (shout out to ratatui — http://ratatui.rs) that links everything together in one dashboard: MRs from GitHub/GitLab, git worktrees, tmux panes, and coding agents. Select an MR and you see its linked branch, worktree, pipeline status dots, and which agent is working on it. Create and manage worktrees, jump straight into tmux panes, or send commands to agents (rebase, fix CI) — all without leaving the dashboard. It runs as a background daemon so the data is always fresh, and can pop up as a tmux overlay so it's one keybind away.
Built for my own workflow around neovim + tmux + opencode. The architecture is pluggable (traits for forges and agents), and there's an AGENTS.md to onboard coding agents for customization. I'd encourage you to fork, open Issues/MRs and do what you want. I think we're all better off building hyper specific tools to fit our own needs since it's easier than ever before to do, and I hope Pertmux at least provides you a great jumping off point.
Heavily inspired by workmux so shout out to them! https://github.com/raine/workmux
Worktree management is based upon the fantastic CLI worktrunk: https://worktrunk.dev/

value: Show HN: Pertmux – A TUI to unify your coding agents, MRs and worktrees

author: pure-orange


value: ChernovAndrei

value: Since the most important part of coding with Claude Code now is planning well, I’ve built a tool to store your plans, analyze them, and reuse them for future planning.

value: Show HN: Store and reuse your Claude Code plans

author: ChernovAndrei


value: ljhnick

value:
This is a social (agentic) experiment I'm really excited about.
AI agents are growing so fast and their capabilties are evolving crazily almost every month. It feels inevitable that, at some point, agents will need a financial layer to operate in the real world alongside humans. For example, an agent might eventually need to hire a human to perform a physical task (like setting up a new server for itself).
But before that, I think the first step is enabling economic behavior between agents themselves. What happens when agents can trade their specialized capabilities? Could we start to see dynamics like arbitrage, subcontracting, or even power-law distributions, where the top 20% of agents capture 80% of the value LOL?
To explore this, I built Openstall, an experimental marketplace where agents can trade capabilities with each other. It's completely free (no escrow fees) and still very early.
I'd really appreciate any thoughts, feedback, or ideas.

value: Show HN: What if AI agents can trade with each other

author: ljhnick


value: jacomoRodriguez

value:
Hey, I’m Mario. After chatting with a colleague about how AI agents are changing dev work, we got stuck on a question: Why share code when prompts can generate it on demand?
I wanted to explore this further, so I build "Open Prompt Hub" — think GitHub, but for prompts: https://openprompthub.io
How it Works:
Instead of shipping binaries or source code, you share instructions and specs in form of a prompt. You can take this prompt, paste it into their agent or IDE and watch it build. If it’s not a perfect fit? Fork it, tweak it, and generate your custom version.
All meta infos like version, description, test cases etc. are stored in a frontmatter block at the start of the prompt. So it's one file containing all the infos you need. (https://openprompthub.io/docs)
Features of the platform: - Versioned prompts with infos which models to best use - Forking for customization - Security Scans: prompts are scanned for security issues and prompt injections. - User can give feedback, if the prompt successfully build what was promissed (scoped on models, so you know which one to best use for execution) - Flagging mechanism
It’s an MVP, but the core features—versioning, model-specific build status, and security scanning — are live.
I'm currently looking into further features, such as: - a git-like cli for publishing prompts and downloading/piping them directly to your agent - multi stage/file prompts for more complex applications - configurable prompts for e.g. switching programming languages, features, etc. - better spec and test definition for build verification
I’d love your feedback... on the idea, the spec and the platform.

value: Show HN: Open Prompt Hub – Don't share code, share intent

author: jacomoRodriguez


value: johnnyChiv

value:
Hey HN,
A few weeks back I posted Knowza.ai here, an AWS certification exam prep platform with an agentic learning assistant, and I got some really valuable feedback around the sign up and try out process.
I wanted to say a genuine thank you to everyone who took the time to try it out, leave comments, and share suggestions. It made a real difference.
Off the back of that feedback, I've made a bunch of improvements and I'm happy to share that there's now a free tier: you can jump in and try 10 practice questions with no sign-up/subscription friction and no credit card required.
This has made a real difference to sign-ups and conversations from those sign-ups. I've went from ~1% conversation rate on the site to 18%.
Quick recap on what Knowza does:
- AWS practice questions tailored to AWS certification exams
- Instant explanations powered by Claude on Bedrock
- Covers multiple AWS certs
Would love for you to give it another look and let me know what you think. Always open to feedback.
https://knowza.ai

value: Show HN: Knowza.ai – Free 10-question trial now live (AI-powered AWS exam prep)

author: johnnyChiv


value:
Healthcare.gov uses a list based shopping flow, with the typical user seeing 50 to 100 options, and lots of jargon. Most people end up enrolling over the phone through a broker or the HC.gov support line.
Nora is a health insurance expert that will ask you about your healthcare needs (doctors, drugs, conditions) and budget, estimate your subsidy, look through hundreds of options, and identify the best one for your scenario. Nora is patient - you can ask as many questions as you want, and she'll iterate on plan recommendations based on your feedback.
Nora uses the same plan, provider network and formulary data as Healthcare.gov.
Nora works in the 30 Healthcare.gov states, including FL, TX and NC. If there's interest, I can look at adding states that run their own marketplaces like CA.
Give it a try at https://norahelps.com
Would love to hear your feedback!

value: Show HN: Nora – AI that finds you the right health plan


value: krschacht

value:
A friend and I built a browser prototype that answers questions about whatever’s on your screen using getDisplayMedia, client-side wake-word detection, and server-side multimodal inference.
Hard parts:
– Getting the model to point to specific UI elements
– Keeping it coherent across multi-step workflows (“Help me create a sword in Tinkercad”)
– Preventing the infinite mirror effect and confusion between window vs full-screen sharing
– Keeping voice → screenshot → inference → voice latency low enough to feel conversational
We packaged it as “Clippy” for fun, but the real experiment is letting a model tool-call fresh screenshots to help it gather more context.
One practical use case is remote tech support — I'm sending this to my mom next time she calls instead of screen sharing.
Curious what breaks.

value: Show HN: Clippy – screen-aware voice AI in the browser

author: krschacht


value: Show HN: CameraClaw – record and review what OpenClaw did in its sandbox


value: verelo

value: Show HN: Playing LongTurn FreeCiv with Friends

author: verelo


value: beshrkayali

value:
I've been working on Ossature, an open-source tool that takes a different approach to LLM code generation. Instead of prompting and hoping, you write specs describing what your software should do, Ossature breaks them into a build plan, and then executes it step by step with an LLM generating code under tight constraints.
The core idea: specs are the source of truth and the human stays in the loop. You review the plan before anything gets built. You can step through tasks one at a time or let it run and intervene on failures. When task 14 of 30 fails, you fix that task and keep going instead of starting over. When requirements change you update the spec and only the affected parts get rebuilt.
The workflow is validate -> audit -> build. Validate checks structure (no LLM). Audit sends specs to an LLM for review and generates the build plan. Build executes it task by task with verification after each step.
Works with Anthropic, OpenAI, Mistral, Google, etc. and local models through Ollama.
Python 3.14+, MIT licensed.
GitHub: https://github.com/ossature/ossature
Docs: https://docs.ossature.dev
Some examples: https://github.com/ossature/ossature-examples
This is v0.0.1. Right now it works best for greenfield projects. I want to support workflows against existing codebases but honestly I'm not sure yet what the right approach looks like there. If you have thoughts on that or anything else, open an issue or start a discussion on the repo.

value: Show HN: Ossature – Spec-driven code generation with LLMs

author: beshrkayali


value: kozhan

value:
The problem is every time an AI agent needs to find relevant files, it either guesses by filename, runs a grep across the whole repo, or reads everything in sight. On any codebase of real size, this wastes context window, slows down responses, and still misses the connections between related files.
With this approach a script runs once at commit time, reads each source file, and builds a semantic map; feature names pointing to files, exports, and API channels. That map gets committed alongside your code as a single JSON file. When an AI agent needs to find something, it queries one keyword and gets back the exact files and interfaces in under a millisecond.
What you gain: AI agents that navigate your codebase like they wrote it. No context wasted on irrelevant files. No missed connections between a service and its controller. And since the map regenerates automatically on every commit, it never falls out of sync.
I added this to my open sourced agentic development platform, feel free to examine it or use it. Any ideas or contributions are always welcome.

value: Show HN: How to cache your codebase for AI agents

author: kozhan


value: condorave

value: Show HN: StatusOK – Uptime monitoring with 1-minute checks on the free tier

author: condorave


value: enahs-sf

value:
Hello HN,
I created Crossle after playing a dice version of this once. it's web/mobile only with mechanics similar to wordle. the object is to create a crossword using scrabble words that is fully connected and each word is at least 3 characters long. all letters must be used. Fun weekend coding project that I'd love to get any feedback on.
thanks!

value: Show HN: Crossle – Scrabble meets crossword game

author: enahs-sf


value: TheFlashBold

value:
Got frustrated with WinOLS and TunerPro, so I built my own alternative that runs entirely in the browser.
Techstack: Preact, Typescript, WebGL, Vite, Tailwind
BIN files are parsed entirely client-side, 3D surface maps rendered with WebGL and ECUs are auto-detected via EPK signature.
Built for VAG Simos 18 / DQ250 DSG tuning, but loads standard XDF/A2L definitions too.
I use it for my own Audi A3 1.8 IS38 build and customer tunes.

value: Show HN: Browser-based ECU tuning editor for VAG Simos 18 / DQ250

author: TheFlashBold


value:
Do you know who else was alive when Pablo Picasso was alive? What else was going on in the world?
What historical figures where around when you were born?
I built this site to help put together various tidbits of historical facts into context. It's turned into a fun way to explore wikipedia and gain some perspective.
What historical connections were you surprised to find?

value: Show HN: Timeliner.cc – Find Historical Connections


value: clmnt

value:
We've been building out CLI extensions for the Hugging Face hub, and hf-agents is a fun one to share.
It uses llmfit under the hood to profile your hardware and automatically select the best-fit model and quantization — no manual GGUF hunting. It then launches a Pi Agent on top of it. One command, local, fully open.
If you've been using Claude Code or Codex CLI and want something that runs entirely on your own hardware/models, this is a nice lightweight alternative to try.
Happy to answer questions — and curious what hardware setups people are running this on.

value: Show HN: HF-agents, CLI extension to find the best model/quant for your hardware

author: clmnt


value: Most products are only seen by a fraction of the people who'd love them - not because they aren't great, but because distribution is exhausting. Relistd fixes that.

value: Show HN: Get listed on 20 Launch Platforms simultaneously


value: SafwanB

value: Show HN: I made a tool at 17 to turn YouTube videos into viral clips

author: SafwanB


value: Enjoyooor

value:
Bored to see so many AI products without value, we decided to build an arena where the crowd decides for their destiny.
Reach possible.
Roast guaranteed.
No account needed + anonymous.

value: Show HN: GladAItor – Judge AI Products for Free

author: Enjoyooor


value: domdaddydo

value: Interesting tool to scan what EU resources a website uses

value: Show HN: Scan a website to see its EU soverignty socre

author: domdaddydo


value: ZDisket

value:
Hi guys and gals, I made a TTS model based on my highly upgraded VITS base, conditioned on external speaker embeddings (Resemble AI's Resemblyzer).
The model, with ~31M parameters (ONNX), is tuned for latency and local inference, and comes already exported. I was trying to push the limits of what I could do with small, fast models. Runs 5.6x realtime on a server CPU
It supports voice cloning, voice blending (mix two or more speakers to make a new voice), the license is Apache 2.0 and it uses DeepPhonemizer (MIT) for the phonemization, so no license issues.
The repo contains the checkpoint, how to run it, and links to Colab and HuggingFace demos.
Now, because it's tiny, audio quality isn't the best, and as it was trained on LibriTTS-R + VCTK (both fully open datasets), speaker similarity isn't as good.
Regardless, I hope it's useful.

value: Show HN: Real-time local TTS (31M params, 5.6x CPU, voice cloning, ONNX)

author: ZDisket


value:
We have built a GPU Runtime for Nvidia GPUs that can run multiple development/experimental/inference workloads per GPU with safe overcommit of VRAM, dynamic fractional allocation of GPU cores, and Deduplication of weights in VRAM.
We are looking for teams to give it a try.
More details to get a trial license - https://www.woolyai.com.

value: Show HN: Stop GPU pods placement getting bottlenecked by reserved VRAM


value: xlayn

value:
I replicated David Ng's RYS method (https://dnhkng.github.io/posts/rys/) on consumer AMD GPUs
(RX 7900 XT + RX 6950 XT) and found something I didn't expect.
Transformers appear to have discrete "reasoning circuits" — contiguous blocks of 3-4 layers that
act as indivisible cognitive units. Duplicate the right block and the model runs its reasoning
pipeline twice. No weights change. No training. The model just thinks longer.
The results on standard benchmarks (lm-evaluation-harness, n=50):
Devstral-24B, layers 12-14 duplicated once:
- BBH Logical Deduction: 0.22 → 0.76
- GSM8K (strict): 0.48 → 0.64
- MBPP (code gen): 0.72 → 0.78
- Nothing degraded
Qwen2.5-Coder-32B, layers 7-9 duplicated once:
- Reasoning probe: 76% → 94%
The weird part: different duplication patterns create different cognitive "modes" from the same
weights. Double-pass boosts math. Triple-pass boosts emotional reasoning. Interleaved doubling
(13,13,14,14,15,15,16) creates a pure math specialist. Same model, same VRAM, different routing.
The circuit boundaries are sharp — shift by one layer and the effect disappears or inverts.
Smaller models (24B) have tighter circuits (3 layers) than larger ones (Ng found 7 layers in 72B).
Tools to find circuits in any GGUF model and apply arbitrary layer routing are in the repo.
The whole thing — sweep, discovery, validation — took one evening.
Happy to answer questions.

value: Show HN: Duplicate 3 layers in a 24B LLM, logical deduction .22→.76. No training

author: xlayn


value:
I built InterviewTraner to fix how people prepare for coding interviews. Most people grind LeetCode problems randomly or follow static lists, which is not very effective. InterviewTraner uses a deliberate practice engine to intelligently schedule which problems you should work on and when.
How it works:
- 1,800+ LeetCode problems organized into a prerequisite graph across all major topics (arrays, trees, graphs, DP, etc.).
- The engine starts you on easy problems and only unlocks harder topics once you've demonstrated mastery of their prerequisites.
- Spaced repetition, mastery learning, interleaving, and other strategies ensure you practice what you need.
- Powerful filtering features to only practice a subset of problems when you are in a rush.
What makes it different from just doing LeetCode or some curated sets? The problems are static and you will have to waste time figuring out what to practice. InterviewTraner turns those static problems into a dynamic experience personalized and optimized for you.
I plan on eventually expanding the curriculum beyond coding interviews to anything in the software engineering process that can fit into short and repeatable exercises.
I originally built Trane, the practice engine powering it, to optimize my music practice. The core insight (skills have prerequisites and practice should respect that structure) applies equally well to coding interviews.
Pricing:
- Free lite license (includes all array, string, recursion, hash table, and stack problems).
- $10/month for all 1,800+ problems (launch price with LAUNCH code, I plan the normal price to be $20/month).
Happy to answer questions about the deliberate practice approach, the scheduling algorithm, or anything else.
Links:
InterviewTraner: https://interviewtraner.com
Pictures Are For Babies (same engine applied to learning to read and write): https://picturesareforbabies.com
Trane: https://github.com/trane-project/trane

value: Show HN: Prepare for coding interviews via deliberate practice


value: michalmatczuk

value: Show HN: Jira-MCP – Full Jira for AI agents in 3 tools, not 72

author: michalmatczuk


value: conqrr

value:
Hey all, sharing my latest alternative to elasticsearch, cloudwatch etc that either require heavy cloud tax or cost more for a managed solution. This is a known pattern but maybe not well known enough to write logs to s3 as durable storage with Parquet and query rapidly with DuckDB. This has become the primary way I ingest logs for all my side projects and don't ever have to worry about losing logs and possibly free storage.
Features

    Format Agnostic - Works with any JSON log format via configurable field extraction
    Fast - 28K+ entries/sec ingestion
    Efficient - Parquet + Snappy (3.7x compression)
    Quick Queries - DuckDB queries in <50ms on 56K logs
    S3-Compatible - AWS S3, MinIO, DigitalOcean Spaces, R2, etc.
    Partitioned - Hive-style partitioning by date/level (no redundant part suffixes)
    Auto-Flush - Configurable automatic flushing (default: 90s)
    Dedupe - Optional deduplication

Happy to answer any questions about internals

value: Show HN: Blobsearch – Object storage and DuckDB based Elasticsearch alternative

author: conqrr


value:
Hey everyone,
I know a product like this will get banned on HN, but I think the technical part is interesting, so I’m taking my shot here.
problem:
You try to get ChatGPT to write your landing page copy or email and it comes back... cringe. It's generic. It's as if every output is written by the same person. You try adjusting the prompt and running it through the AI again, and it's just a different version of the same boring output.
There's no real creative exploration going on here. It's one model, one shot, one voice.
solution:
Rather than relying on a single AI to compose your content, I created a system with over 100 different AI personas, each with their own area of expertise, personality, and aesthetic (based on real-world data), to rate and score your content in a variety of ways. And then, took some inspiration from AlphaEvolve (Google DeepMind's evolutionary coding agent) [1], we take these personas as a fitness function and apply an evolutionary algorithm to your content in a variety of ways. It’s a search problem, not a one-shot problem.
The result:
Copy that's been stress-tested by a diverse panel and evolved through selection pressure. Not just whatever one model generated on the first try.
Would love to hear your feedback.
1:https://deepmind.google/blog/alphaevolve-a-gemini-powered-co...

value: Show HN: A Genetic algorithm that red-teams your copy with 100 LLM personas


value: kaashmonee

value: Show HN: WheresMyPermitSF – Self-Hosted SF Housing Permit Bottleneck Analyzer

author: kaashmonee


value: nickgray

value:
I have been building a directory of personal websites over the past few months.
If you have a home page on your own domain, you should submit your site and I will link to you!
I've seen a lot of love for the small web, the Indie Web, etc here on HN this past week. I think everyone should have their own personal website - if nothing else so that you can feed the bots your own content, on your terms, and tell your story however you want.
I miss the days of human-curated directories and this is my attempt to create one.
Next on my to-do list includes: adding thousands more sites, like from Derek Sivers's public repo of NowNowNow pages. Re-crawling sites to verify last post date, get new screenshots, and try to geo-locate if there is an "About" section that shares that info. Better tags for discovery.
Any and all suggestions appreciated!

value: Show HN: Personalwebsites.org – The Official Homepage of Homepages

author: nickgray


value: AskCarX

value: Show HN: MCPSaaS – Security proxy for MCP agent protocols

author: AskCarX


value: WillNigri

value: Show HN: ATO – a GUI to see and fix what your LLM agents configured

author: WillNigri


value: Show HN: I created a free tool to analysis your old blog posts for suggestions


value: atulvi

value: Show HN: Lottery of Birth

author: atulvi

title: Show HN: Lottery of Birth


value:
Hi everyone — looking for feedback on a new infrastructure project we launched called vMetal. It's a bare metal management platform for GPU clusters that handles machine discovery, PXE booting, and lifecycle management, without the OpenStack complexity. Built around Kubernetes-native workflows so you can hand it off to teams or drop it into an existing platform.
A lot of the infra platforms used for this today were designed 20 years ago (VMware, OpenStack, NVIDIA BCM, MAAS, etc.), while newer tools usually solve only a small piece of the stack. Neither were built with modern GPU cluster ops in mind. In practice most setups end up stitching things together or building custom provisioning pipelines.
With vMetal we took a different approach: treat physical machines like programmable infrastructure resources. Compared to tools like MAAS or Tinkerbell, vMetal is designed around a few ideas:
- Bare metal lifecycle automation: Automatically discover machines on the network, boot them, install OS images, and reprovision nodes as hardware moves between clusters or workloads. Built on Metal3 and Ironic.
-Built for GPU cluster ops: Supports environments where nodes frequently move between clusters, capacity pools, or tenant workloads.
-Direct Kubernetes integration: Provisioned machines can be attached directly to Kubernetes clusters as nodes or assigned to infrastructure pools.
-Works with Kubernetes multi-tenancy layers: Integrates with vCluster (virtual clusters) and vNode (node-level isolation) so machines can move from bare metal provisioning into multi-tenant Kubernetes environments.
We’ve shared a few other infrastructure projects here before (DevPod, vCluster), and the feedback from HN has been incredibly helpful.
Curious how others here are handling bare metal provisioning today — MAAS, Ironic, Metal3, Tinkerbell, something custom?
Open to any feedback, positive or negative.

value: Show HN: VMetal – run a GPU cloud on bare metal without OpenStack


value: There's no external MCP for your fitness (Garmin / Strava) data, so we built one.

value: Show HN: Fitness MCP

title: Show HN: Fitness MCP


value: theoradical

value: Show HN: We built an AI judge for a live hackathon, then red-teamed it

author: theoradical


value: Show HN: Ashlr AO – AI agent orchestration dashboard (for sale, $9.5K)


value: elmadah

value: Show HN: Jninty – Track seeds, plants, and harvests across seasons (open source)

author: elmadah


value: Show HN: Clog – CLI and skill for debugging apps


value: rashoodkhan

value:
The problem with AI-generated frontend code is that without constraints, every generation picks different spacing, colors, and patterns. The 50th component looks nothing like the first.
ui-stack is a Claude Code skill — a set of structured reference files that Claude reads when building UI.<p>It's built for Next.js + Tailwind + Shadcn but the principles are framework-agnostic.
What's interesting about the "skill" approach vs. a system prompt: the reference is modular and file-based, so you can update one file (say, colors.md) and the change propagates everywhere. There's also a browser-based config dashboard so you can customize your brand palette and font before the skill activates.
Would love feedback — especially from anyone who's tried to enforce design consistency across a large Claude Code project.

value: Show HN: UI-stack – Claude skill that enforces design system on AI-generated UI

author: rashoodkhan


value:
Hello HN,
I am music theory teacher who loves building my own tools. My latest project is MidiStickers, a desktop software for teaching and learning music using MIDI instruments.
The UI concept is "every tool is a floating widget", which came from my frustration with video capture setups during the pandemic. Now I just drag-and-drop and rearrange mid-lesson.
The usual flow is: play your instrument and use widgets for Staff/Instruments visualization, Roman numeral analysis, figured bass, German Funktiontheorie, jazz piano voicings, chord-scale-relationships and more. Dynamic coloring schemes can be used for note names, degrees, harmonic functions and dynamics (velocity), providing a lively visual environment that has definitely shaped my recent teaching. My "aha" moment came when a student promptly reminded me I had forgotten to turn it on before a class demonstration.
By the way, while "building in public" is trending nowadays, this software was really "built in class" - improvement came every week from battle-testing it in front of 30+ students. Needless to say there were some embarrassing  crashes along the way .
Lately I am also going beyond visualization and turning it into an interactive workbook for learning keyboard harmony. You can practice intervals, chords and progressions with (auto)accompaniment and progress tracking - in my experience, nothing beats a hands-on approach!
A demo (Win/Mac) is available at https://github.com/frauber84/MidiStickers-Demo/releases/tag/...
In this demo, you can explore visualization as well as trainer tools - the second requires a MIDI controller, the first doesn't.
A Linux build is coming if I find a consistent solution for transparent windows across Linux - I use SDL3 for the drawing and this has been a challenge.

value: Show HN: MidiStickers – learn music theory visually


value:
The idea started with one question: "Who else right now?" -- that impulse when you feel something, do something, or think something, and wonder if anyone else in the world is experiencing the same thing.
How it works: you write a thought (250 chars max). AI generates an embedding and classifies the topic. The thought appears as a light on a 3D globe where you are, and as a star in a sky clustered with similar thoughts. Tap a star to see the thought. Lines connect it to similar ones across the world, forming constellations of shared experience.
Search works the same way -- type a feeling like "can't sleep" or "just got off a long shift" and the globe reshuffles to show people worldwide going through the same thing.
App Store: https://apps.apple.com/us/app/astruno/id6758970345
Google Play: https://play.google.com/store/apps/details?id=ai.mokabyte.as...

value: Show HN: Astruno – Your thoughts become stars on a 3D globe and celestial sky


value: Show HN: Free BYOK career interview that builds your story file


value: chunqiuyiyu

value: Show HN: A strategy game where Chinese characters are the mechanics

author: chunqiuyiyu


value: jaksa

value: Show HN: AI Coding Factory

author: jaksa

title: Show HN: AI Coding Factory


value: sdemela

value:
I've been using Suno for months and kept hitting the same wall: the Style of Music field is the most powerful parameter, but there's almost no guidance on how to use it well.
Too many words breaks it. Wrong order changes the feel. v4 and v5 respond completely differently to the same prompt — something that works great on v4.5 produces generic results on v3.
So I built Supre. You pick genre, mood, BPM, instruments, vocal style and which Suno version you're using — it generates a calibrated Style prompt specifically for that version.
Built with Claude Haiku on the backend, Vercel serverless, Upstash Redis for rate limiting.
Try it: https://supre.online/en/tool (2 free generations/day, no signup)

value: Show HN: Supre – A prompt engineer for Suno AI's Style of Music field

author: sdemela


value: pierre

value: LiteParse is a standalone OSS (Apache 2.0) PDF (and other document types) parsing tool focused exclusively on fast and light parsing.<p>It provides high-quality spatial text parsing with bounding boxes, without proprietary LLM features or cloud dependencies. Everything runs locally on your machine.

value: Show HN: Liteparse, an OSS universal fast document parser by LlamaParse team

author: pierre


value: Havunen

value: Show HN: GitComet fastest open source Git GUI launched

author: Havunen


value: textlapse

value:
I trained a live RL agent inside a pixel platformer you can play against on a desktop browser (needs a keyboard or a controller):
https://rlplays.com/game
This is NOT a quick-one-off vibe/LLM-coded project.
I started this project out of curiosity: I wanted to build an RL-based game as there were very few out there (e.g. Sony GT Sophy). And I wanted to learn the core RL foundation in a practical/useful manner.
I built on top of Puffer - but the training speed was not up to my needs so I rewrote the core with a ground-up native eval/training loop with multithreaded GPU batching (gonna be a part of the next Puffer release). [ Unaffiliated plug: Puffer is an excellent OSS library - check out https://puffer.ai ]
I trained the RL agent using curriculum learning + self-play. The demo showcases this self-play as well - which you can play against yourself, like an RL agent would!
Technical details in my blog in the link above.

value: Show HN: Play against a live RL agent in a pixel platformer

author: textlapse


value: mayerwin

value:
I one-shotted this app with Claude Opus 4.6 (Claude Code in VS Code), from idea to deployed GitHub Pages site in a single prompt.
Live demo: https://mayerwin.github.io/MIDI-Notes-Player/
It's a simple tool: paste a sequence of MIDI note numbers (like 60, 64, 67, 72) or note names (C4 E4 G4 C5) and hit Play. It also supports solfège (do ré mi fa sol), accidentals (Eb5, sol#4), any separator you want, and 50+ General MIDI instruments via SoundFont samples.
Für Elise is pre-loaded so you can try it immediately.
What Claude generated in one shot:
- Vite + vanilla JS app (no framework)
- Note parser supporting MIDI numbers, scientific pitch notation, and solfège (with French accidentals like solb, sold)
- SoundFont-based audio playback with 50+ instruments
- Real-time note validation with visual token display
- Tempo/duration controls, keyboard shortcuts, animated playback
- GitHub Actions CI/CD for automatic deployment
- README, LICENSE, the whole thing
The only manual steps were creating the GitHub repo via gh CLI (which Claude also did through the terminal) and authorizing the push.
Stack: Vite, vanilla JS/HTML/CSS, soundfont-player, Web Audio API.
Source: https://github.com/mayerwin/MIDI-Notes-Player

value: Show HN: MIDI Notes Player – Play any MIDI note sequence in the browser

author: mayerwin


value: johntopia

value: Show HN: Philo - Notetaking app is your IDE

author: johntopia


value: amlug

value:
I kept missing the drag window on macOS's built-in screenshot thumbnail. It fades out in ~5 seconds and if you're not fast enough, you have to go find the file on your Desktop.
EasyShot watches your screenshot folder and shows a floating thumbnail that stays until you drag it into whatever app you need — Slack, Figma, email, wherever.
It's a single Swift file, no dependencies, ~200 lines. Notarized DMG or build from source in one command. Took about 30 minutes to build because the problem was driving me insane.
https://easyshot.dev
https://github.com/skelpo/easyshot

value: Show HN: EasyShot – macOS screenshot thumbnails that don't disappear after 5s

author: amlug


value: Show HN: Get a quick skincare analysis by uploading a photo


value: multidude

value:
tried to do financial sentiment analysis but kept hitting the same wall with FinBERT: "OPEC cuts production" scores negative. For crude oil it should be bullish — less supply means higher prices. Generic models don't know what phrases mean for a specific asset.
No existing dataset captured this systematically. Every financial sentiment project I found was either abandoned or producing generic polarity that was actively wrong for commodities and FX.
So I built swik — at first for myself, then I kept finding zero alternatives and thought this could interest other people. Many sentiment analysis projects out there are abandoned for this very reason: failure to produce meaningful, correct and reliable sentiment for a given asset-specific headline.
Then I thought: "build it and they will come." Now there it is — an open, community-maintained catalog of phrase inversions for 35+ assets (commodities, FX, indices, crypto). Each entry has the phrase, naive polarity, actual direction for that asset, and the economic reasoning behind it.
The inference API takes a headline + security symbol and returns direction, magnitude, relevance, and confidence — with the inversion catalog injected as context.
What's open:
• 267 inversion entries across 35 assets (CC BY 4.0, on GitHub)
• Free API (100 req/day, no credit card)
• Label queue to contribute corrections
Still very early — the catalog grows with contributions. Curious whether others have hit this problem and how they've handled it.
swik.io | catalog: github.com/polibert/sentimentwiki-catalog

value: Show HN: Swik – catalog of asset-specific sentiment inversions for financial NLP

author: multidude


value:
A tough curve fitting game for pros.
You have unlimited guesses to find the expression that best fits the curve.
Try to reach the maximum score with minimum guessees.

value: Show HN: Fitdle – A Curve Fitting Contest


value: firaslatrach

value:
I got tired of this loop:
add console.log → redeploy → reproduce → squint
Built reqlog. One import, a dashboard opens at
localhost:9000, you see everything in real time —
payload, response, latency, replay button.
NestJS:
@Module({ imports: [ReqlogModule.forRoot()] })
Express:
app.use(require('reqlog-express')())
That is the entire setup.
github.com/FirasLatrech/reqlog

value: Show HN: Reqlog – live HTTP dashboard for Node.js and Go

author: firaslatrach


value: karloscodes

value:
I'm tired of how complex observability tools have become lately, so I decided to build my own for my apps. That's Lognorth, SQLite and a Go binary, that runs in a $5 server. 50k events daily for 5 years, under 40GB. You can wire it to Codex or Claude Code to debug issues too.
Check it out here: https://lognorth.com

value: Show HN: Lognorth self-hosted errors and logs on a $5 VPS

author: karloscodes


value: KupaMakunura

value:
I would use ChatGPT to create sprint plans, PRDs, and roadmaps only to spend an hour recreating them in Trello before anything could actually kick off.
I created PlanWiki to eliminate that step.
Paste a plan in and instantly get structured tasks, checklists, timelines, and workflows — ready for your team to execute.
It also has a built-in MCP server. Agents such as Claude Code ,Codex or Cursor can link up, pick up tasks and directly update real-time progress.
Stack:
Next.js
Drizzle ORM + PostgreSQL
tRPC
Better Auth
shadcn/ui + AI SDK
Self-host or deploy easily.
Would love feedback.

value: Show HN: PlanWiki – Open-source platform for product teams and agents to execute

author: KupaMakunura


value: earcar

value: Show HN: Jekyll VitePress – VitePress-Style Docs for Jekyll

author: earcar


value: What if you would connect largest library with AI?

value: Show HN: World Library in AI

title: Show HN: World Library in AI


value:
Hi HN,
I found that when I'm too focused on coding, I'd completely forget my prayers, and normal apps only gives you notifications that's easy to swipe off.
So I built pryr using Rust. It’s a background daemon that tracks prayer times, gives you warnings, and when the exact time hits, it ruthlessly locks you out of the OS session (using loginctl on Linux and LockWorkStation on Windows) for a configurable duration.
Architecture is split into:
1. Async state machine using Tokio running as a daemon(systemd / TaskScheduler)
2. A CLI that communicates with the daemon using zero-overhead IPC (unix sockets / windows named pipes)
I aimed for totally offline usage (only fetching coords from city name requires internet) and simplicity
I'd love to hear your thoughts on the architecture and if there's any improvement ideas!
Repo Link: https://github.com/kofta999/pryr

value: Show HN: Pryr – A ruthless prayer time screen locker in Rust


value:
I wanted to play around with the non-coding agentic capabilities of the top LLMs so I built a model eval predicting the March Madness bracket.
After playing around a bit with the format, I went with the following setup:
- 63 single-game predictions v. full one-shot bracket
- Maxed out at 10 tool calls per game
- Upset-specific instruction in the system prompt
- Exponential scoring by round (1, 2, 4, 8, 16, 32)
There were some interesting learnings:
- Unsurprisingly, most brackets are close to chalk. Very few significant upsets were predicted.
- There was a HUGE cost and token disparity with the exact same setup and constraints. Both Claude models spent over $40 to fill in the bracket while MiMo-V2-Flash spent $0.39. I spent a total of $138.69 on all 15 model runs.
- There was also a big disparity in speed. Claude Opus 4.6 took almost 2 full days to finish the 2 play-ins and 63 bracket games. Qwen 3.5 Flash took under 10 minutes.
- Even when given the tournament year (2026), multiple models pulled in information from previous years. Claude seemed to be the biggest offender, really wanting Cooper Flagg to be on this year's Duke team.
This was a really fun way to combine two of my interests and I'm excited to see how the models perform over the coming weeks. You can click into each bracket node to see the full model trace and rationale behind the picks.
The stack is Typescript, Next.js, React, and raw CSS. No DB, everything stored in static JSON files. After each game, I update the actual results and re-deploy via GitHub Pages.
I wanted to work as fast as possible since the brackets lock today so almost all of the code was AI-generated (shocker).
Hope you enjoy checking it out!

value: Show HN: LLMadness – March Madness Model Evals


value: yuvrajangads

value: Show HN: Vemb – embed text, images, audio, video and PDFs from the terminal

author: yuvrajangads


value: wingravity

value: Show HN: Showslide – Live Presentations in 60 seconds

author: wingravity


value: ronfriedhaber

value: Show HN: A Nascent Analytical Engine

author: ronfriedhaber

title: Show HN: A Nascent Analytical Engine


value: andrewcourtice

value:
After several years, with a small hiatus in the middle, I've finally got Ripl to the point of being published. Ripl is a library for rendering 2D and 3D shapes to any context (canvas, SVG, WebGPU, and Terminal supported by default) using a single API. The library mimics the DOM as much as possible, replicating the event system, object graphing, CSS-like querying, gradients, and keyframe animations etc.
I also built a complete data visualization library using the core package which is available as @ripl/charts. And yes, you can even render the charts to a terminal with about a 2-3 line code change :) (see the terminal demo)
Docs are available here: https://www.ripl.rocks
Demos are available here: https://www.ripl.rocks/demos
Charts are avialable here: https://www.ripl.rocks/docs/charts
I've also built an interactive playground you can use to play around with it in realtime without having to install it from NPM etc. The playground is available here: https://www.ripl.rocks/playground
The core library is quite stable and I'll likely publish v1 in the coming weeks. The charts, 3D, and Terminal packages are still very experiemental.
I'd interested to hear what you all think of it.

value: Show HN: Ripl – A unified 2D/3D engine for Canvas, SVG, WebGPU, and the Terminal

author: andrewcourtice


value: MaxMussio

value:
I wrote High Output Software Engineering, a short book about the skills (decision-making and communication) engineers must focus on to create real value for organizations (other than code itself).
The title is a reference to High Output Management, by Andrew Grove, because the skills and mental models laid out in the book should enhance "Output" (value being created) not necessarily "activity" (code being produced).
My goal now is to spread the word about the book and put it in the hands of people or companies that will benefit from it. I've heard it's being specially helpful for startup teams.
Would love feedback from this community both on the book content itself and on the packaging/marketing.
Free copy available using the coupon code HACKERNEWS (valid until the end of the month): https://payhip.com/buy?link=YeABa
Book landing page: https://leomax.fyi/book/
It's also available on Amazon if it's easier for you: https://www.amazon.com/High-Output-Software-Engineering-Comm...
ps. I really wrote the book (I believe writing is the ultimate thinking tool). Used AI for grammar polishing and fact-checking.

value: Show HN: High Output Software Engineering (Book)

author: MaxMussio


value: sydcli

value: Show HN: First Claude Code skill for building SaaS apps

author: sydcli


value: mrmrcoleman

value: Show HN: Play 90s classic X-Com – UFO Defense in the browser via WASM

author: mrmrcoleman


value: RichEO

value:
Lexicon is a plain-text format for legal contracts, built on standard Markdown. You write contracts using normal Markdown syntax with a few conventions — YAML front matter for parties and metadata, numbered lists for clause hierarchy, bold text for defined terms, anchor links for cross-references. The source file is valid Markdown that should render cleanly in GitHub, Obsidian, or whatever.
When you need production output, it can be compiled to .docx with automatic clause numbering (1, 1.1, (a), (i)), cross-reference resolution, defined term validation, cover pages, signature blocks and schedules.
I'm a lawyer who runs a small practice and does GC work for startups. Drafting contracts in Word is painful and I have always hated the workflow. Track changes can be deleted by anyone, version control is "Agreement_v4_FINAL_VLs_edits(2).docx" and now copy/paste to and from Claude is a pain.
I've been thinking about how to transition off Word and into text on and off for the better part of 7 or 8 years, and the possibility of opening my workflow up to "coding" agents has given me the push to actually finalize my work.
You can play with it here: https://play.lexicon.esq. If you want to compile to docx, you can use the tool here: https://github.com/RichEsq/lexicon-docx

value: Show HN: Lexicon – Write legal contracts in Markdown

author: RichEO


value:
We built a system to automate KYC verification using agentic AI.
Instead of using separate tools (OCR, validation, etc.), it handles the full workflow:
Document type detection
OCR-based data extraction
Cross-document validation
Face verification
Risk detection
Structured output generation
It takes a government ID, application form, and user photo, and processes everything end-to-end with a human-in-the-loop for compliance.
The goal is to reduce manual effort and make KYC workflows more scalable and consistent.
Would love feedback from others working on KYC / compliance workflows.

value: Show HN: KYC Verification Process Automation Using Agentic AI


value: Soocile

value:
I've been building an open-source kernel-mode EDR/XDR sensor called Phantom Sensor for about
two years now as a solo project. It just hit a milestone I'm pretty
excited about - the driver loads cleanly on Windows 11, passes Driver
Verifier with all standard flags enabled, and survives normal use
without crashing.
The kernel sensor (PhantomSensor) is a WFP+minifilter driver sitting
at altitude 385210. It's written in C targeting the WDK, roughly 370k
lines across 70+ modules. Some of what it does:
ObRegisterCallbacks for process/thread handle stripping (anti-injection, anti-debug)
Minifilter callbacks with stream contexts for file monitoring, ransomware backup engine, section object tracking
WFP callouts for network inspection - TCP stream reassembly, DNS monitoring, C2 beacon detection, TLS fingerprinting
PsSetCreateProcessNotifyRoutineEx / PsSetLoadImageNotifyRoutine for behavioral analysis
ETW provider + consumer for kernel telemetry
Registry callback for persistence detection (Run keys, services, scheduled tasks)
Process hollowing detection via VAD analysis + PE header comparison
Syscall table monitoring, direct syscall detection, Heaven's Gate detection , Halo's Gate detections + Hell's Gate detections
Lookaside lists for hot-path allocations, rundown protection for safe teardown, reference-counted object lifetimes
The behavioral engine tracks attack chains and maps to MITRE ATT&CK
techniques. Thread protection module does per-process activity tracking
with hash-bucketed trackers and rate limiting - had a fun use-after-free
in there (refcount off-by-one on newly inserted trackers, InsertTailList
caught the corrupted list entry - classic).
It's been a long road of analyzing dump reports using kd.exe(kernel debugger) windbg x64 and finding the errors that triggered the BSOD.Here are some: WORKER_INVALID from double-queuing
IO_WORKITEM on periodic timers. Stack overflows from 4KB structs in
image load callbacks. IRQL_NOT_LESS_OR_EQUAL from ERESOURCE without
KeEnterCriticalRegion. Each one taught me something.
The codebase is AGPL v3. But understand it is still not completed(There is not only kernel-sensor) we have a Beta 2028 target for the full product especially 3 products(Phantom XDR Phantom EDR and Phantom Consumer solutions below the ShadowStrike brand.
If you want to support or follow the journey of developing a Kernel-driver and a user-mode agent for the ShadowStrike Phantom products:

value: Show HN: ShadowStrike EDR/XDR Kernel Sensor Development

author: Soocile


value: buildoak

value:
wet = Wringing Excess Tokens.
transparent API proxy that compresses stale tool results in Claude Code sessions

value: Show HN: Wet Claude – Go proxy that lets CC to profile and optimize its context

author: buildoak


value: I'm a solo founder with a DBA background. Built this because pgHero only shows current state (no trends), and pganalyze starts at $149/mo. Lantern is a Rails gem that snapshots pg_stat_statements, tracks query performance over time, and tags each snapshot to the deploy that was live. Health score, query trends, deploy correlation. Free tier, $9/mo for 30-day history. Would love feedback.

value: Show HN: Lantern – See which deploy slowed your Postgres queries ($9/mo)


value: nerlwein

value: Show HN: AIIR: track AI-assisted Git commits with cryptographic receipts

author: nerlwein


value: mrxdev

value:
Obsidian plugin that connects to CLI agents you already have installed. No built-in LLM integration, no API keys to configure in the plugin. It spawns your tool as a child process, pipes vault context into each prompt, and streams responses into a chat panel.
Supports Claude Code, Opencode, and any custom binary via a generic adapter. Adding a new agent is a single file. Free, proudly Open Source (MIT licensed).
Would love feedback on this for anyone that that tries it out.

value: Show HN: Agentic Copilot – Bring Claude Code, OpenCode, Gemini CLI into Obsidian

author: mrxdev


value: mkdesign

value:
Hi HN, I spent a year designing a pocket-sized golf game around two constraints: DIN A7 (palm sized) and it has to work with only a pen. No battery, no screen.
Coming from web and app design, designing for paper was new territory. I hand designed every hex layout, built a dice strip onto each page to make it playable without a die. And after feedback from several playtesters I added power-ups, portals and a strict target score (Par) to undercut - this added quite some complexity and more fun.
One caveat: there's a similar-sounding product called Paper Apps Golf that inspired me. Starting out it was just a side project and I focussed on the mechanics, not the theme (in hindsight I could've just used another theme). The next one will have a different angle, I want to explore how mobile game mechanics translate to pen and paper. Like jump'n'run or tower defense.
PS: About the name - I think it was a Dilbert comic about not paying attention to a meeting that led me to this name.

value: Show HN: Brain Golfing – a pen-and-paper strategy game I designed

author: mkdesign


value: unknownhad

value:
https://mairo.himanshuanand.workers.dev
All levels are generated on the fly using AI.
Feel free to share your review/feedback.
#AIslop

value: Show HN: MAIro AI Slop in Games

author: unknownhad

title: Show HN: MAIro AI Slop in Games


value: vdavid

value: Show HN: mtp-rs – pure-Rust MTP library, up to 4x faster than libmtp

author: vdavid


value:
Hi folks,
Over the past few months, I built an efficient MCTS implementation in Python/numba.
As I was building a self-play environment from scratch (for learning purposes), I realized that there were few efficient implementation of this algorithm.
I spent a lot of time validating it against a golden standard baseline [1].
My PUCT implementation is 2-15X faster than the baseline while providing the exact same policy.
I also implemented a Gumbel MCTS, both dense and sparse. The sparse version is useful for games with large action spaces such as chess.
Gumbel makes much better usage of low simulation budgets than PUCT.
Overall, I think this could be useful for the community. I used coding agents to help me along the way, but spent a significant amount of manual work to validate everything myself.
Feedback welcome.
[1] https://github.com/michaelnny/alpha_zero/blob/main/alpha_zer...

value: Show HN: Gumbel-mcts, a high-performance Gumbel MCTS implementation


value: vitonsky

value: Show HN: Leviathan-crypto – WebAssembly cryptography library for TypeScript

author: vitonsky


value: Maesh

value:
I open-sourced a dataset of 5 synthetic bank and credit card statement PDFs designed for testing extraction/parsing accuracy. Each PDF uses a fictional bank with realistic formatting from a different country
I've been building a bank statement converter (Bankstatemently) and kept discovering edge cases across different banks. At some point, I started cataloging them as "quirks" and I'm currently at 36 documented challenges and counting (think: dates without years across year boundaries, credit card charges shown as positive instead of negative, dates hiding inside description text etc)
Real bank data is private, so there's no shared dataset to test parsers against. Once I had these quirks, I realized I can use them to reconstruct statements that deliberately include these challenges so more people can use them
There's also a free evaluation API: submit your parsed JSON and get field-level accuracy scores back. Ground truth is held server-side, but that's not necessarily bullet-proof against overfitting
Would appreciate feedback on which edge cases are missing. I'm planning to make the next 10 statements a bit harder (scanned PDFs, multi-currency across multi-table, Buddhist era dates)
https://github.com/bankstatemently/bank-statement-parsing-be...
You can browse all of the quirks here with real-world examples: https://bankstatemently.com/benchmark/challenges

value: Show HN: Open-source synthetic bank statements for testing parsers

author: Maesh


value: A curated list of awesome open source CRM (Customer Relationship Management) and Personal Relationship Management tools.

value: Show HN: Open Source CRM List

title: Show HN: Open Source CRM List