value: acaciabengo

value:
Hey HN,
For the past few weekends, I have been working on a computer vision pipeline to solve a specific PropTech problem: turning messy, highly occluded 2D floor plans into clean, structured data for 3D extrusion. I originally built this as a demo for a firm.
The Stack & Architecture I built an instance segmentation pipeline that relies strictly on pixel-perfect masking to extract the geometry.
The Backbone: Swin Transformer + Detectron2 + OpenCV
Training: Trained on 1024x1024 images using an RTX 4090.
Inference: Runs on CPU in < 10s.
Demo Performance: 67.1% AP50 for instance segmentation masks, and 38.2% AP across the strict 0.50:0.95 IoU thresholds.
Why I'm posting:  A lot of virtual staging and architectural startups have beautiful Three.js rendering engines, but still rely on manual data entry to build the base geometry. I built this specifically as an extraction engine to sit underneath those UIs.
If you are in PropTech or building a product that could benefit from embedding this model under the hood, I would love to chat.

value: Show HN: Turning 2D floor plans into 3D-ready JSON with Detectron2

author: acaciabengo


value: alonsim

value:
smplogs analyzes your AWS CloudWatch log exports (Lambda, API Gateway, ECS) and turns them into severity-ranked findings, root cause analysis, and log signature clusters. The entire analysis engine is written in Go, compiled to WebAssembly, and runs client-side. Your log content never leaves your browser.
Why I built this: I got tired of the CloudWatch debugging loop - staring at raw log streams, writing ad hoc Insights queries, mentally correlating timestamps across invocations, and still not understanding why my Lambda was failing. I wanted something where I could drop a file and immediately see "94% of your failures occur within 200ms of a DynamoDB ProvisionedThroughputExceededException - switch the Payments table to on-demand capacity." Actual root causes, not just "error rate is high."
Technical approach: The core engine is a Go binary compiled to WASM (~analysis.wasm). At build time, Vite computes its SHA-256 hash and bakes it into the JS bundle. At runtime, the browser fetches the WASM, verifies the hash with crypto.subtle.digest before instantiation, and then all parsing and analysis happens in WebAssembly linear memory. The server only sees metadata (file size for rate limiting, a session key). No log content is ever transmitted.
Inside the WASM, there are four analysis modules: a SemanticLogClusterer (groups log lines by pattern, masks variables - so you see "ProvisionedThroughputExceededException: Rate exceeded for table *" appearing 48 times across 12 requests), a ResourceCorrelationEngine (links error spikes to upstream causes like throttling or cold starts), a ColdStartRegressionAnalyzer, and an AnomalyDetector (catches things like slowly increasing memory usage suggesting a leak).
The frontend is vanilla ES modules - no React, no framework. Vite bundles it. Tailwind for styling. The backend is just Vercel serverless functions handling auth, rate limiting, and encrypted storage for Pro users who want to save analyses.
There's also a browser extension (Chrome, Firefox, Edge) that injects an "Analyze" button directly into the CloudWatch console, so you can skip the export step entirely.
What's hard: Tuning the correlation engine thresholds. "94% of failures within 200ms of throttling" is a real finding from testing, but getting the confidence intervals right across wildly different log shapes(a 50-invocation Lambda vs. a 10,000-request API Gateway) is an ongoing challenge. I'm also debating whether to open-source the WASM engine.
What I'd love feedback on:
- Is the zero-knowledge / client-side-only angle compelling enough to overcome the "just another log tool" reaction?
- The free tier is 3 analyses/day. Too low? Too high?
- Would you want a CLI version that pipes CloudWatch logs directly?
You can try a no-signup demo on the landing page - just scroll a bit to see the analysis output on sample logs.
https://www.smplogs.com
Free tier available, no credit card required.

value: Show HN: Smplogs – Local-first AWS Cloudwatch log analyzer via WASM

author: alonsim


value: Show HN: Rev-dep – 20x faster knip.dev alternative build in Go


value: mosselman

value: Show HN: Decoy – A native Mac app for mocking HTTP endpoints locally

author: mosselman


value: sukinai

value: Show HN: I built a self-diagnostic health check for AI agent memory

author: sukinai


value: michaelnewman

value:
I kept rebuilding the same pattern across products (idempotency keys, Redis TTLs, unique constraints) just to avoid duplicate side effects from retries and race conditions. Eventually I turned it into a focused API.
ExactOnce lets you create an action and consume it exactly once. The transition from active → consumed is enforced atomically via a DynamoDB conditional write. Under concurrency, one request succeeds; the rest deterministically get a typed 409 already_used. No distributed locks, no cross-service transactions.
Use cases:
+ magic login links
+ coupon redemption
+ webhook deduplication
+ one-time download links
+ ticket scanning
+ license activation
Try it without signing up:
curl --request POST https://api.exactonce.com/v1/demo
That returns a temporary action (5‑minute TTL) and a reveal URL. Open it once — it consumes. Open again — already used.
Docs: https://exactonce.com/api-docs
How it works: https://exactonce.com/how-it-works
Private beta is free. Happy to answer questions about the DynamoDB implementation or the atomic consume pattern

value: Show HN: ExactOnce – API for actions that can only happen once

author: michaelnewman


value: wasivis

value:
I wanted to simulate the pressure of a real senior-level, cold, brief, and focused on edge cases interview, so I built TechGrill.
The Stack:
- Next.js 15 & Server Actions
- Groq (Llama 3.3 70B): Used for sub-second latency to keep the "grilling" conversational.
-Neon (Postgres) & Drizzle: For transcript persistence.
It handles Junior to Senior levels and generates a performance scorecard after a few questions.
Any feedback is appreciated!

value: Show HN: TechGrill – AI Interview Practice

author: wasivis


value:
I built an offline-first bingo caller app for hosting 75-ball and 90-ball games without physical cages or printed boards.
It started as a simple number generator for family game nights, but evolved into a full hosting tool with:
Professional voice calling (multiple personalities)
TV/projector display mode
Digital player cards via QR
Hex-based number verification to reduce disputes
Rollback for incorrect calls
9 language support
The app works completely offline and uses a secure RNG. No tracking, no data collection.
Would love feedback on usability, performance, or feature ideas.
Google Play Store link:
https://play.google.com/store/apps/details?id=com.bingosurf....

value: Show HN: Bingo Caller Pro – Offline 75/90 Ball Bingo Host


value: maxtermed

value:
In January, a Chinese app called Sile Me ("Are You Dead?") went to #1 paid app on China's Apple App Store. One button. Tap it daily to say you're alive. Miss two days — your emergency contact gets an email. It went viral because 200M Chinese people live alone and finally had a tool that acknowledged the obvious risk.
The US has 40 million solo households — 29% of all households, an all-time high. And no good equivalent.
So I built one. Key differences: SMS instead of email, a 48-hour window instead of rigid schedules, and an Emergency Alert button — one tap, immediate text to your contact. Right now, not after two days of silence.
Tech stack: Expo/React Native, Python/FastAPI, RevenueCat for IAP. iPhone only for now.
The full story: https://imalivetoday.com/demumu-app-us

value: Show HN: I built the US version of "Are You Dead?", China's viral check-in app

author: maxtermed


value: Show HN: I stopped building apps for people. Now I make CLI tools for agents


value: arbopa

value: Show HN: WebPrepImage – Local batch image resizer with file-size limits

author: arbopa


value:
I built GameScout AI because I never really liked the recommendations sites like Steam propose. It uses natural language to find games based on specific mechanics or moods, like "cozy farming sims with a bit of action" or "something like Dark Souls but funnier".
The Stack:
- Next.js & Tailwind: For a responsive, gaming-focused UI.
- Groq (Llama 3): I’m using Groq for inference because sub-second latency makes semantic search feel like a local DB query.
- Prompt Engineering: Optimized to explain why a game was picked based on actual mechanics, not just metadata.
Any feedback is appreciated!

value: Show HN: GameScout AI – AI-powered game recommender


value: Show HN: Zen Router – An opinionated HTTP router


value: grove

value:
pg_stream is a PostgreSQL 18 extension that keeps materialized views current
incrementally — no external infrastructure, no separate streaming pipeline.
You define a stream table (a SQL query + a freshness bound) and the extension
derives a delta query that processes only changed rows on each refresh cycle:

    SELECT pgstream.create_stream_table(
        'regional_totals',
        'SELECT region, SUM(amount) AS total, COUNT(*) AS cnt
         FROM orders GROUP BY region',
        '1m',
        'DIFFERENTIAL'
    );

One INSERT into a million-row table → pg_stream touches one row's worth
of computation. Query it like any regular table.
How it works:
- Trigger-based CDC captures row changes into buffer tables inside the same
  transaction (no wal_level = logical required)
- A background worker walks a topological DAG of stream tables and fires
  refreshes in dependency order
- The DVM engine (differential view maintenance, DBSP framework) rewrites
  your SQL into a delta query at definition time — JOINs, GROUP BY, CTEs,
  window functions, LATERAL, subqueries all supported
- Stream tables can depend on other stream tables; a change to a base table
  cascades automatically through the entire chain
Written in Rust using pgrx. 1,300+ tests (unit + integration + E2E).
dbt macro package included.
GitHub: https://github.com/grove/pg-stream
Docs:   https://grove.github.io/pg-stream

value: Show HN: pg_stream – incremental view maintenance for PostgreSQL in Rust

author: grove


value: karamazov

value:
My startup helps companies save money on Snowflake, and over the past two years we've built out a lot of observability features based on customer requests.
We're launching these features for free for everyone. You can read more here: https://espresso.ai/post/observability

value: Show HN: Free Snowflake Observability

author: karamazov

title: Show HN: Free Snowflake Observability


value: dilawargopang

value: Show HN: Phi-Redactor – HIPAA Phi Redaction Proxy for OpenAI/Anthropic APIs

author: dilawargopang


value: zfleeman

value: I'm loving the momentum behind Linux, particularly Arch, right now. I've used it for years but recently have been switching all of my workflows to it. I wanted a quick way to see all my tasks at a glance without context-switching between apps. Since I already use Waybar, it felt like the natural place to make that available. There wasn't really something out there for that, and I had todos scattered amongst different local notes and Obsidian, so I built Tasuki to aggregate them together.

value: Show HN: Tasuki – A Task Aggregator for Waybar

author: zfleeman


value: ddyo

value:
thefuck (https://github.com/nvbn/thefuck) in Rust – because life's too short for slow fucks.
151ms → 2.7ms startup. Same rules, 56x faster.
2x faster correction time as well.

value: Show HN: A faster fuck (thefuck CLI rewritten in Rust)

author: ddyo


value: mikkeldamsgaard

value:
We got tired of debugging shell scripts in initContainers at 2 AM. Missing curl, broken netcat flags, secrets leaking into logs — the usual.
Initium is a single static Rust binary (~5 MB, built FROM scratch) that handles the six things initContainers actually do: wait for dependencies, run migrations, seed databases, render config templates, fetch secrets, and exec commands.
What it gives you over bash:
Exponential backoff with jitter on all network ops (not sleep 5 && retry)
Automatic secret redaction in logs (catches token, password, api_key, auth patterns)
PSA restricted compatible out of the box — non-root, read-only filesystem, all capabilities dropped
Declarative database seeding with cross-table references and idempotency
Zero CVEs. No OS packages. No shell. Nothing to scan.
It supports PostgreSQL, MySQL, and SQLite. Config via CLI flags or INITIUM_* env vars. Multi-arch (amd64 + arm64).
Apache 2.0. Written in Rust. https://github.com/KitStream/initium

value: Show HN: Initium – A single Rust binary replacing scripts in K8s initContainers

author: mikkeldamsgaard


value: mkovach

value: Show HN: A Tcl/TK Clone of the Rust Clone of Microsoft Edit

author: mkovach


value: ringger

value: Show HN: Transcribe-Critic – Merge transcript sources for stronger transcript

author: ringger


value: stinger

value:
I built Local Hours because I needed a simple time tracker that doesn't require online accounts, send data to someone else's cloud, and lock me into proprietary formats.
Local Hours stores everything as plain JSON files in a folder you choose. Point it at an iCloud, Google Drive, or OneDrive folder and your data syncs across devices automatically — no docker, no backend, no accounts, no analytics.
How it works:
- Start/stop a timer from the macOS menu bar or iOS widgets
- Add a short description when you stop
- Generate weekly, bi-weekly, or monthly timesheets
- Email approvers with an embedded summary or CSV attachment
The storage format is intentionally simple so you can inspect, back up, or migrate your data anytime. Both the macOS and iOS apps point at the same folder, so cross-device sync just works via your cloud storage provider.
It's free on the App Store (iPhone, iPad, Mac): https://apps.apple.com/us/app/local-hours-simple-timesheet/i...
Built with Swift/SwiftUI. MIT licensed. No tracking, no telemetry, no in-app purchases.
I'd love feedback on the UX, the local-first approach, or ideas for what to build next. Android is planned.

value: Show HN: Local Hours – Local-first time tracking app (macOS, iOS, open source)

author: stinger


value: sartechb

value: In Veritas summarizes federal congressional bills (house and senate), gives the fiscal impact, voting history of congressional members, amendment history, and related bills. We’re pulling the data from the congress.gov API and using as neutral as language as possible to avoid bias.<p>We would love feedback on:<p>- Accuracy<p>- Site UI/UX<p>- Helpfulness

value: Show HN: In Veritas – AI summarized congressional bills

author: sartechb


value: AltStackHQ

value: Show HN: The AltStack – A directory of 450 open-source SaaS alternatives

author: AltStackHQ


value: mbadyl

value:
It's a CLI tool that lets you describe what you want to test in plain English - the agent generates and runs the test plan against your API. You can point it at an OpenAPI spec, a Postman collection, GraphQL schema, or just a URL.
New in v0.5.0:
OpenAPI Scanner - scans your source code and auto-generates an OpenAPI 3.1 spec
Headless/CI mode - run non-interactively with octrafic test for pipeline integration
GitHub: https://github.com/Octrafic/octrafic-cli
Happy to answer questions any questions.

value: Show HN: Octrafic – Natural language API testing CLI

author: mbadyl


value:
I'm a CS student with no prior quantum computing
background who built this in about a week.
quantumopt uses a Graph Attention Network trained
on 10,240 quantum circuits to predict optimization
potential, then passes to Qiskit's transpiler for
hardware-specific compilation targeting IBM Brisbane.
Results on 41 real QASMbench circuits:
- 34% average gate reduction
- 28% average depth reduction
- 0 circuits made worse
- 82% GNN prediction accuracy
Happy to answer questions about the GNN architecture, training pipeline, or quantum compilation approach.

value: Show HN: Quantumopt – GNN-based quantum circuit compiler (34% gate reduction)


value:
I built MongoClaw because every AI enrichment pipeline I've seen hits the same concurrency bug nobody talks about.
Your agent reads a document at t0. Inference takes 2 seconds. At t1, another process updates that document. At t2, the agent writes back — silently overwriting live data with output generated from a stale snapshot. Clean 200 OK. No error.
That's not a prompt problem. It's a write-safety problem.
MongoClaw solves it by capturing version + content hash at dispatch time and issuing a conditional write that only succeeds if the source record still matches. Stale payload? Write suppressed, reason classified, execution record persisted.
It also handles:
* Idempotent replay protection across all write strategies
* Loop detection via agent-origin metadata
* In-band policy evaluation (enrich/block/tag) after inference and before mutation
Agents are declared in YAML. The runtime handles change stream ingestion, Redis-backed queuing, async execution, schema validation, and auditable writebacks.
It also works with external agent endpoints — normalising heterogeneous response formats into the same execution contract.
Would appreciate feedback on the write-safety mechanism specifically — curious if others have hit this problem differently.

value: Show HN: MongoClaw, A mutation runtime for MongoDB with write-time agent safety


value: mkagenius

value: Show HN: Can this model run on my Mac mini?

author: mkagenius


value: nachawati

value:
Hey HN,
I’m excited to share Morsel, a modern, web-based visual editor for Modelica that I've been working on. It's part of the broader ModelScript compilation, analysis, and visualization framework.
Modelica is a powerful, object-oriented language for equation-based modeling of complex physical systems (mechanical, electrical, electronic, hydraulic, thermal, control, etc.). However, tooling in the Modelica ecosystem has historically been heavy, proprietary, or desktop-bound. I built Morsel to bring a fast, beautiful, and accessible Modelica modeling experience right to the browser.
Key Features
============
- Interactive Diagrams: High-performance visualization of Modelica connections and topologies using AntV X6.
- Synchronized Code Editor: Real-time, two-way synchronization between the visual diagram and the underlying Modelica code (powered by Monaco Editor).
- Intelligent Properties Panel: Easily edit component parameters, modifiers, and annotations through a responsive UI that directly manipulates the AST.
- Library Explorer: Navigate complex Modelica libraries (like the Modelica Standard Library) via an intuitive hierarchical tree view.
Under the Hood: ModelScript
===========================
Morsel is powered by ModelScript, a custom compilation engine written in TypeScript. ModelScript brings its own modern toolchain to Modelica:
- Custom Tree-Sitter Grammar: Fast and precise parsing for editor integrations and tooling.
- Semantic Analysis: Full scope and name resolution for complex Modelica hierarchies.
- Model Flattening: Translating hierarchical component architectures into flat Differential Algebraic Equations (DAEs).
Why I built this
================
I wanted an open-source (AGPL-3.0), modern front-end that could run entirely in the browser (or as a local web app) without sacrificing the power of the Modelica language. It's built on a modern stack (React, React Router, Vite, Tailwind, GitHub Primer) to provide a premium, responsive developer experience.
I am still actively developing Morsel and ModelScript and would love your feedback, bug reports, and contributions!
GitHub Repo: https://github.com/modelscript/modelscript
I'd be happy to answer any questions about the architecture, Modelica parsing, the tree-sitter grammar, or anything else!

value: Show HN: Morsel – an open-source, web-based visual Modelica editor

author: nachawati


value: romainsimon

value: Show HN: Intelligence Disruption Index – Is AI replacing human work?

author: romainsimon


value: mjkamalika

value: Launch real-world environments with built-in security controls for ISO 27001, PCI DSS, NIST, SOC2 & more. Compliance that actually runs in your infrastructure, not just in documents.

value: Show HN: Compliance-as-Code for Cloud Infra

author: mjkamalika


value: pipervw

value: talentpluto is a voice AI native platform that connects GTM talent with high-growth startups in NYC and SF. Pluto represents candidates proactively and sends opt-in matches based on experience and career goals, while keeping candidates anonymous until they choose to engage.<p>How it works:<p>- Call Pluto to capture background and preferences<p>- Receive matches and opt in to the ones you want<p>- Stay connected as goals and timing change

value: Show HN: Talentpluto, a voice AI agent connecting GTM talent and startups

author: pipervw


value: dtormoen

value: neural-open.nvim is a Neovim plugin that integrates with Snacks.nvim that trains a neural network to rank files based on your navigation patterns using features like fuzzy-finder match scores, file access frecency, and directory structure. It trains a small multi-layer perceptron and updates the network for a few iterations each time you choose a file to learn your preferences.<p>I made this because I always felt other file search solutions never fully match my flow and could learn more from how I use them to be better. It was also a fun little side project to help me remember some of the details of the math in deep learning that had gotten a little stale over time.

value: Show HN: Neural-open.nvim – Neural network powered Neovim file picker

author: dtormoen


value: AdHelpAI

value:
I recently launched WeDoDev — a subscription-based SaaS development service for startups and small teams.
The idea is to give founders ongoing product development (features, integrations, UX, iterations) without hiring or managing freelancers/agencies.
Curious if this model resonates with early-stage SaaS teams and what expectations you'd have from a service like this.
Would love feedback from the HN community.

value: Show HN: WeDoDev – SaaS development subscription for startups

author: AdHelpAI


value: apocryphal

value:
Two months ago, I had zero mobile development or publishing experience. I wanted to see if I could build and ship a complete game using only a browser-based workflow and AI assistance.
The process:
Built entirely in GitHub Codespaces using an AI Copilot.
Wrote the core game for the web, then wrapped it into an Android APK/AAB.
Pushed through 100+ versions to fix edge cases.
Passed Google Play review with no policy violations.
The game is a tough 2D platformer called Bionic Biome. To make the "impossible mode" bearable, I integrated a rewarded AdMob ad as a Continue/Revive mechanic. It’s an opt-in lifeline, not a forced pop-up.
Here is the weird hurdle I’ve hit:
Test ads worked perfectly. But in production, the AdMob dashboard just says "No data" and returns "Ad not ready." My core revive mechanic is effectively disabled because Google's algorithm won't serve real ads until it sees enough "organic" traffic to trust the account.
It's a strange psychological shift. For weeks it was "build, fix, upload." Now, the AI code works, the wrapper works, the integration works, but the core mechanic is held hostage by a silent third-party algorithm waiting for strangers to play it.
Has anyone else here launched a first app and hit this AdMob cold-start wall? How long did it take for your first live ad to actually fill?
If you are curious to see what an AI-coded, web-wrapped game built entirely in a browser actually plays like on Android, the link is below. (No pressure to play, just sharing the technical journey).
https://play.google.com/store/apps/details?id=com.pollitopro...

value: Show HN: Made First Android game using Codespaces and AI, now in AdMob purgatory

author: apocryphal


value: joe-gregory

value: Show HN: Blazor Developer Tools: React DevTools-Style for Blazor

author: joe-gregory


value: sachaa

value:
I built OpenBrowserClaw as a browser-only reimagining of OpenClaw. Same philosophy: small enough to understand, built for one user, but running entirely in a browser tab.
No Mac Mini. No VPS. No cloud deploy. No Docker. Just open a tab.
The idea: What if your AI assistant lived in a browser tab instead of a server? No infrastructure to manage, no background processes, no deployment headaches. Even on your phone you can just open the PWA, paste your Claude API key, and explore the magic of the Claw.
Repo: https://github.com/sachaa/openbrowserclaw
...or just try it here: https://www.openbrowserclaw.com/

value: Show HN: OpenBrowserClaw: Browser-native Claw assistant, zero infrastructure

author: sachaa


value: tkjef

value:
Hi HN, I started building yaw because I couldn't find a terminal on Windows that didn't feel like an afterthought. It's 2026 and the options are still basically Windows Terminal or a handful of lesser known terminals w/ poor copy/paste support.
Yaw turned into a terminal that does three things in one app: terminal emulation, connection management, and AI.
The terminal side has what you'd expect — tabs, split panes, broadcast mode, search, a command palette, session restore. WebGL-rendered with xterm.js. It's fast and stays out of the way.
The connection manager is where it started getting useful for me personally. I'm constantly SSH-ing into servers and connecting to databases. yaw lets me save SSH, PostgreSQL, MySQL, SQL Server, MongoDB, and Redis connections with encrypted credentials. It detects Tailscale machines automatically. There's a Remote Sessions panel for managing GNU Screen sessions on any SSH host. And a setup wizard that can install database servers locally if you don't have them.
The AI piece started as a simple chat window — talk to Claude, ChatGPT, Gemini, Mistral, Grok, or Ollama with your terminal output as context. Select an error, ask what it means, get an answer that actually references what's on your screen.
But the part I'm most excited about is the AI CLI tool integration. Run Claude Code, Codex, Gemini CLI, or Vibe CLI and Yaw automatically splits the pane — AI tool on the left, a fresh terminal in the same directory on the right. You can install any of them through a built-in wizard. It's a small thing but it completely changed how I use these tools day to day.
v0.9.60, available on Windows 10+ and macOS 12+. Would love feedback — especially on the AI CLI tool workflow and what you'd want to see next.

value: Show HN: Yaw: terminal, SSH/database connections, AI Chat and optimized AI CLI

author: tkjef


value: caioricciuti

value:
Hi HN,
I built @duck_ui/embed — a set of React components that turn SQL queries into interactive dashboards, powered by DuckDB-WASM running entirely in the browser.

     `npm install @duck_ui/embed @duckdb/duckdb-wasm`

 The idea: pass your data (arrays, CSV, Parquet, JSON, or a fetch callback), write SQL, and get charts, tables, KPIs, and filters — no backend required.

     <DuckUIProvider data={{ sales: { url: "/sales.parquet", format: "parquet" } }}>
       <Dashboard columns={3}>
         <Dashboard.Panel>
           <KPICard sql="SELECT sum(revenue) as value FROM sales" label="Revenue" format="currency" />
         </Dashboard.Panel>
         <Dashboard.Panel span={2}>
           <Chart sql="SELECT month, sum(revenue) FROM sales GROUP BY 1" type="bar" />
         </Dashboard.Panel>
         <Dashboard.Panel span={3}>
           <DataTable sql="SELECT * FROM sales" pageSize={20} sortable />
         </Dashboard.Panel>
       </Dashboard>
     </DuckUIProvider>

What's under the hood:
- DuckDB-WASM boots in the browser, data loads into in-memory tables
 - SQL queries run against real DuckDB (full SQL support, window functions, CTEs)
 - Parquet files use HTTP range requests — only fetches needed row groups
 - FilterBar auto-detects column types and injects WHERE clauses via subquery wrapping
 - Connection pool (max 4), LRU query cache (100 entries, 5min TTL)
 - ~95KB bundled (ESM), tree-shakeable
Components: Chart (line/bar/area/scatter/pie), DataTable (paginated, sortable, resizable columns), KPICard (with sparkline + comparison), FilterBar (auto or manual config), Dashboard (responsive grid layout), ExportButton (CSV/JSON).
For connecting to external databases (Postgres, MySQL, etc.), there's a "gateway pattern" — your backend runs the SQL and returns JSON, the embed renders it via a fetch callback.
Built with: React 18+, DuckDB-WASM, uPlot, @tanstack/react-table, Zustand.
 Apache-2.0 licensed.
Live playground: https://duckui.com/play
 Docs: https://duckui.com/embed/docs
 npm: https://www.npmjs.com/package/@duck_ui/embed
This is part of the Duck-UI project (https://github.com/ibero-data/duck-ui),
 a browser-based SQL IDE for DuckDB with 525+ stars. The embed SDK lets you
 take the same DuckDB-powered analytics and drop them into any React app.
Would love feedback on the API design and what components/features you'd want next.

value: Show HN: Duck-UI Embed – SQL-Powered React Dashboard Components with DuckDB-WASM

author: caioricciuti


value:
Hello HN!
I built this tool to help my agentic software development (vibe coding) workflow.
I wanted to debug Safari specific frontend bugs using copilot CLI, however MCP servers are disabled in my organisation. Therefore I built this CLI tool to give the LLM agent control over the browser.
Hope you'll find it useful!

value: Show HN: Safari-CLI – Control Safari without an MCP


value: Show HN: Email but for Your OpenClaws

title: Show HN: Email but for Your OpenClaws


value: milind-soni

value: I have been building a library that lets you define interactive maps as a JSON object. Now the already existing Maplibre Spec is quite strong, but every time I needed to put a map together with markers, widgets, a legend, layer controls and a nice color palette, I'd end up writing a lot of boilerplate html, Even writing with AI it would mess up the layer management and working with different kind of formats, So I started building a layer on top. Its inspired by the json-render library by vercel. Ive added support for a lot of formats and also loading data with duckdb wasm to power widgets which can filter with the viewport. Would love to get some reviews on this and if its genuinely useful to anyone for building maps!

value: Show HN: JSON Maps – Describe Maps as JSON, Render Them with React and MapLibre

author: milind-soni


value: Mitchem

value: Show HN: Stop reviewing AI-generated code during a PR, move it in the edit cycle

author: Mitchem


value: cyrusradfar

value:
I built unf after I pasted a prompt into the wrong agent terminal and it overwrote hours of hand-edits across a handful of files. Git couldn't help because I hadn't finished/committed my in progress work. I wanted something that recorded every save automatically so I could rewind to any point in time. I wanted to make it difficult for an agent to permanently screw anything up, even with an errant rm -rf
unf is a background daemon that watches directories you choose (via CLI) and snapshots every text file on save. It stores file contents in an object store, tracks metadata in SQLite, and gives you a CLI to query and restore any version. The install includes a UI, as well to explore the history through time.
The tool skips binaries and respects `.gitignore` if one exists. The interface borrows from git so it should feel familiar: unf log, unf diff, unf restore.
I say "UN-EF" vs U.N.F, but that's for y'all to decide: I started by calling the project Unfucked and got unfucked.ai, which if you know me and the messes I get myself into, is a fitting purchase.
The CLI command is `unf` and the Tauri desktop app is titled "Unfudged" (kids safe name).
How it works: https://unfucked.ai/tech (summary below)
The daemon uses FSEvents on macOS and inotify on Linux. When a file changes, `unf` hashes the content with BLAKE3 and checks whether that hash already exists in the object store — if it does, it just records a new metadata entry pointing to the existing blob. If not, it writes the blob and records the entry. Each snapshot is a row in SQLite. Restores read the blob back from the object store and overwrite the file, after taking a safety snapshot of the current state first (so restoring is itself reversible).
There are two processes. The core daemon does the real work of managing FSEvents/inotify subscriptions across multiple watched directories and writing snapshots. A sentinel watchdog supervises it, kept alive and aligned by launchd on macOS and systemd on Linux. If the daemon crashes, the sentinel respawns it and reconciles any drift between what you asked to watch and what's actually being watched. It was hard to build the second daemon because it felt like conceding that the core wasn't solid enough, but I didn't want to ship a tool that demanded perfection to deliver on the product promise, so the sentinel is the safety net.
Fingers crossed, I haven’t seen it crash in over a week of personal usage on my Mac. But, I don't want to trigger "works for me" trauma.
The part I like most: On the UI, I enjoy viewing files through time. You can select a time section and filter your projects on a histogram of activity. That has been invaluable in seeing what the agent was doing.
On the CLI, the commands are composable. Everything outputs to stdout so you can pipe it into whatever you want. I use these regularly and AI agents are better with the tool than I am:

  # What did my config look like before we broke it?
  unf cat nginx.conf --at 1h | nginx -t -c /dev/stdin

  # Grep through a deleted file
  unf cat old-routes.rs --at 2d | grep "pub fn"

  # Count how many lines changed in the last 10 minutes
  unf diff --at 10m | grep '^[+-]' | wc -l

  # Feed the last hour of changes to an AI for review
  unf diff --at 1h | pbcopy

  # Compare two points in time with your own diff tool
  diff <(unf cat app.tsx --at 1h) <(unf cat app.tsx --at 5m)

  # Restore just the .rs files that changed in the last 5 minutes
  unf diff --at 5m --json | jq -r '.changes[].file' | grep '\.rs$' | xargs -I{} unf restore {} --at 5m

  # Watch for changes in real time
  watch -n5 'unf diff --at 30s'

What was new for me: I came to Rust in Nov. 2025 honestly because of HN enthusiasm and some FOMO. No regrets. I enjoy the language enough that I'm now working on custom clippy lints to enforce functional programming practices. This project was also my first Apple-notarized DMG, my first Homebrew tap, and my second Tauri app (first one I've shared).
Install & Usage:

  > brew install cyrusradfar/unf/unfudged

Then unf watch in a directory. unf help covers the details (or ask your agent to coach).
EDIT: Folks are asking for the source, if you're interested watch https://github.com/cyrusradfar/homebrew-unf -- I'll migrate there if you want it.

value: Show HN: Unfucked - version all changes (by any tool) - local-first/source avail

author: cyrusradfar


value: Show HN: Modernizing command entry with Emacs-style flex search + mouse support


value: kdickey

value: Are they up is a free and open-source service disruption monitoring tool, built with Go and HTMX. I built this to play with HTMX and Go and found that I really enjoy this stack. The website is fast and ships <i>almost</i> no JS.

value: Show HN: Are they up, an open-source, Go based, alternative to Downdetector

author: kdickey


value: Show HN: OpenClaw skills degrade agent safety


value: brunodequeiroz

value:
Hi HN, I built oosh because I was tired of rewriting the same flag parsing, help text, and completion logic every time I needed a bash CLI at work.
The initial idea came from 9 years ago: https://gist.github.com/bruno-de-queiroz/a1c9e5b24b6118e45f4..., and it's pretty simple: annotate your functions and oosh gives you flag parsing, help generation, tab completion, and type validation for free. A scaffolder generates a full CLI project in seconds.
```bash
#@flag -e|--env ENV "staging" enum(dev,staging,prod) ~ target environment<p>#@public ~ deploy the app
function deploy() {
  echo "Deploying to $ENV..."
}
```
That's it. No subshells, no external dependencies, no compilation step. Just bash 3.2+ (works on stock macOS).
A few things that might interest this crowd:
- *530* lines for the whole framework `oo.sh`
- *~45 annotations replace ~130 lines* of manual case statements, getopts, help text, and completion scripts
- *6-17ms overhead* on macOS, 6-9ms on Linux — measured with a built-in profiler
- *Tab completion* works out of the box for bash and zsh, including dynamic enums
- *Linter* catches annotation errors, naming issues, and flag collisions
- Built to be *agent-friendly* — LLMs can read the annotations and scaffold modules without understanding bash arg parsing
The 30s demo video in the README shows the full flow: install, scaffold, run commands, add a module, and autocomplete.
Happy to answer questions about the design decisions or bash 3.2 compatibility war stories.

value: Show HN: oosh – Annotation-driven CLI framework for Bash

author: brunodequeiroz


value: usplusAI

value: Show HN: Usplus.ai – Build a company of AI agents and execute work autonomously

author: usplusAI


value: ttamslam

value:
Hey HN, my name is matt. I built "i typed it" as a platform agnostic proof for human typed text. I've been frustrated recently by posts and comments (on hn and elsewhere) that feel obviously ai generated. I don't mind using AI to brainstorm/edit/revise, but it's a bit painful when it seems like a human didn't even bother reading it before positing.
The tool today measures high level signals (typing consistency, paste %, edit rate ,etc.) to give a score. After writing your message you save an attestation link and include it in the post/comment. This basic approach is deeply flawed, but hopefully better than nothing. I'm curious what current state of the art is for _guaranteeing_ that something is human typed. Perhaps some sort of hardware integration?
I'm working on a browser extension, and a quick way to integrate attestations with comment sections so users don't need to include the link copy/pasted. Would love any and all feedback.
p: https://www.ityped.it/p/RvRegYS453Sy

value: Show HN: Prove that a human wrote it

author: ttamslam

title: Show HN: Prove that a human wrote it


value:
I'm sharing Tracecore, an OS tool I'm building to evaluate AI agents' ability to handle deterministic software tasks like log triage, config remediation, and incident recovery. It started as a way to test whether agents could reliably perform structured operations without free-form guessing, inspired by frustrations with brittle automation in ops workflows.
What sets it apart: Unlike benchmarks like SWE-Bench (which tests code generation on open-ended GitHub issues) or general agent evaluation suites (that mix diverse reasoning, coding, and interaction tasks), Tracecore focuses on deterministic episodes where agents must use constrained actions (e.g., file operations, ops triage) to achieve exact outcomes, with strict validation. It includes 15+ tasks across suites like operations and games, and supports running agents via adapters for frameworks like OpenClaw and Autogen, or custom scripts.
You can try it out by installing through pip/uv, or by cloning the repo and installing the optional dev dependencies, and running the dashboard, the cli wizard or the cli commands. It outputs structured results with success/failure, steps used, traces for analysis, diffs, bundles and more.
I've been iterating on this over the past few weeks, adding new tasks and improving the harness. Previous discussions on AI eval tools were helpful in shaping the design. Feedback welcome, especially on expanding task suites or integration ideas.

value: Show HN: Tracecore: Benchmark AI Agents on Deterministic Coding Tasks


value: tatheery

value: Show HN: Huesnatch – Free Color Extractor

author: tatheery


value: talhababi

value:
Hi everyone,
I’ve been building a visual GUI builder for CustomTkinter over the past few weeks. The idea was to experiment with a low-code interface for generating real Python GUI applications while still allowing full code access.
Some technical highlights:
Drag & drop widget system
Multi-page project structure
Visual IF/ELSE logic system
JSON-based project state management
Built-in code editor with syntax highlighting
Export system (including standalone executable builds)
One of the more interesting challenges was designing the logic system so that UI actions could be translated into structured JSON and then converted back into executable Python code.
I’m mainly looking for technical feedback:
Does this approach make sense architecturally?
What would you improve in a GUI builder like this?
Is there something fundamentally missing?
Appreciate any thoughts.

value: Show HN: A drag and drop GUI builder for CustomTkinter

author: talhababi


value: ethantheswe

value:
I've been building a bunch of random side projects, as I'm sure we all are. Most analytics tools were either too heavy or required juggling multiple free tiers across different subdomains.
After looking what's out there I couldn't find a lightweight analytics platform that worked on the free tier of fly.io.
It's a single Go binary using DuckDB for events and SQLite for metadata, so there are no external dependencies to manage. Drop a script tag on your site and it auto-captures pageviews and clicks.
The part I'm most excited about: it uses an LLM to automatically name raw click events into something human-readable. Instead of seeing button.btn-primary#checkout in your dashboard, you see "Clicked checkout button". No manual event instrumentation needed.
One fly launch and you have your own analytics instance for free.
GitHub: https://github.com/danielthedm/clicknest

value: Show HN: ClickNest a tiny self-hosted, AI native web analytics in Go

author: ethantheswe


value: iafan

value:
Sometimes I want to run a shell command but don't remember the exact syntax. There are apps that aim to resolve that, as well as AI integrations into shells (like iTerm).
I thought there have to be an easier way to achieve this. And it turns out, there is (at least on zsh / macOS). It's just a one-liner prompt and an alias command to add to your .zshrc. After that, '@ run ffmpeg to convert my.mov to mp4' will be converted to the actual command, ready to press Enter.
An interesting side effect is that your '@ whatever' commands become a part of the shell history, so you can rerun them again as regular shell commands.
The entire repo above is simply a README. Just point Claude Code to it and it will install it for you.

value: Show HN: The easiest way to run shell commands in plain English (no app needed)

author: iafan


value: visioninmyblood

value: Show HN: Visual Agents for Fitness: How to Enable Automated Exercise Feedback

author: visioninmyblood


value: pkailas

value:
I've been building Windows installer packages for 25 years. InstallShield
costs $2,000+/year. WiX works but requires writing XML by hand and has a
steep learning curve. Advanced Installer is better but still $500+/year.
So I built InstallerStudio — a WinUI 3/.NET 10 tool that generates
production-ready MSI files with a modern UI. One-time license, $199.
It handles files, shortcuts, registry, custom actions, services, file
associations, and installer branding. Self-contained — no WiX or other
tools required under the hood.
The meta part: InstallerStudio builds its own installer. I used it to
package itself for the first release.
https://www.ionline.com
Happy to answer questions about MSI internals, Windows Installer quirks,
or why I built this instead of just wrapping WiX.

value: Show HN: InstallerStudio – Create MSI Installers Without InstallShield or WiX

author: pkailas


value: glennhv

value: Show HN: Emergency kits – Their guide when you're not there to lead

author: glennhv


value: JustClemens

value:
Hi HN!
I built HelioSim, a real-time N-body gravitational system simulator running directly in the browser via WebAssembly.
It’s written in C++ and uses OpenGL ES 3.0, GLFW, and Emscripten. The entire simulation and rendering pipeline runs in WebAssembly.
Features:
- Real-time N-body gravitational simulation
- Predictive orbit trails
- Collision handling
- Time controls (slow motion / fast-forward)
- Dynamic body spawning
This was my first larger WebAssembly project, and I was honestly surprised how well modern browsers handle a C++ + OpenGL ES pipeline compiled to WASM.
One interesting challenge was bridging events and state between JavaScript and C++, which can honestly be a bit exhausting.
Source code:https://github.com/clemenskoprolin/heliosim
I’d love feedback on performance on other machines. Thanks!

value: Show HN: HelioSim – Real-time N-body simulator in WebAssembly

author: JustClemens


value: mtzanidakis

value:
I built Praktor to run my own AI agents in isolated Docker containers, accessible from Telegram.
It's a single Go binary: receives Telegram messages, routes them to named agents (each with its own role, model, and config), spins up Docker containers running Claude Code via the Agent SDK, and streams responses back. A Mission Control web UI provides real-time monitoring.
Some highlights:
- Named agents with smart routing (@agent_name or AI-powered)
- Each agent in its own Docker container with isolated filesystem
- Persistent per-agent memory via SQLite + MCP tools
- Agent swarms: fan-out, pipeline, and collaborative patterns
- Encrypted secrets vault (AES-256-GCM), never exposed to the LLM
- Nix package manager — agents install tools on demand
- Browser automation via playwright-cli
- Per-agent MCP servers, plugins, and skills from the UI
- Hot config reload, scheduled tasks, backup/restore
Would love feedback.

value: Show HN: Praktor – Multi-agent Claude Code orchestrator with Docker isolation

author: mtzanidakis


value: chris-corner

value:
I built a small CLI tool that organizes files in the current directory based on their extensions.
The idea came from staring at my messy “Downloads” folder and thinking: what if I could fix this with a single command?
The tool is intentionally minimal and opinionated:
- It groups files into predefined categories (Images, Documents, Archives, Code, etc.)
- It never deletes or overwrites anything
- It stops execution if a filename collision is detected
- It only operates inside the current working directory
- It works out of the box, but also includes optional flags like --only, --exclude, and --preview
One interesting lesson was around hidden/system files.
In early versions, any unrecognized extension was moved into an “Others” folder.
That worked — until I enabled hidden files and realized system files were being moved too.
That forced me to rethink what “safe by default” really means.
Now the tool only moves explicitly whitelisted extensions.
Another issue I underestimated was filename collisions.
Currently, if a file already exists in the target folder, execution stops and shows an error.
I’m now thinking about:
- Whether to implement safer/atomic move strategies
- How to handle large numbers of files more robustly
- Whether user-defined extension mappings are worth the added complexity
It’s built with plain Node.js (no TypeScript), using minimal dependencies (Chalk and Ora).
I’d really appreciate feedback, especially around:
- Filesystem edge cases I might not be considering
- Safer move strategies
- The trade-off between minimalism and flexibility in CLI tools
Repo: https://github.com/ChristianRincon/auto-organize

value: Show HN: I built a minimal file organizer CLI and underestimated filesystem case

author: chris-corner


value:
I know this already exists, but most such apps cost money or are freemium. I wanted to create a travel tracking app that was completely free, open-source and with a modern, playful design.
So I did that (with the help of Claude). The result is a iOS app written in Swift. You can track countries, major cities, and attractions you've visited or want to visit. You earn achievements as you travel to new destinations. There are also daily geography challenges.
The app is available on app store, and the code is on my Github (https://github.com/AnmolS99/voyage).
Feedback is very welcome :)

value: Show HN: Free app to track countries you've travelled to


value:
Hi HN,
I built this after getting frustrated trying to compare small differences in AI-generated images and game graphics settings. A lot of tools I tried either felt bloated or required uploading files somewhere.
So I made a simple image comparison tool that runs entirely in the browser. Everything stays local — no uploads.
It supports slider, split view, fade mode, pan & zoom, and a few other viewing options like grayscale and basic color frequency info to help spot subtle changes.
The goal was to keep it lightweight, precise, and easy to use.
Curious what you think.
https://picdiff.dev/

value: Show HN: I built a browser-based image comparison tool for subtle differences


value: arithmosdev

value:
5 numbers, 16 targets. Build expressions using +, −, ×, ÷, () to hit each one. Numbers can only be used once per expression.
At the end of the day, you see how your solutions compare to everyone else's. Finding a rare solution is the fun part.
15 minutes of math beats 15 minutes of doomscrolling, especially for the kids.
Happy to answer questions.

value: Show HN: Gridly – Minimalist math puzzle (Wordle vibe), no signup, no ads, clean

author: arithmosdev


value:
I work on this at Covalent/GoldRush.
We built this because agent builders kept hitting the same setup friction when breaking workflow when vibecoding for blockchain and pricing data.
This release is CLI-first and aimed at getting from zero to a working agent flow quickly.
Would love blunt feedback on:
- what feels overcomplicated
- missing commands
- where onboarding still breaks

value: Show HN: GoldRush CLI – one command for blockchain data


value: jsonstcyr

value:
I’m building FeatureFlare, a feature flag platform focused on safe production releases for small engineering teams.
The newest work adds a tighter “release safety loop”: stronger rollout controls, better targeting workflow, and production-hardening around automated rollback behavior. The goal is to make it easier to ship gradually, detect bad rollouts quickly, and recover without manual scramble.
I’ve also been building integration foundations so flag changes can connect to the tools teams already use across CI/CD, observability, and incident response.
What I’d love feedback on:
Does the rollback + targeting flow match how your team actually ships?
Which integration would make this immediately useful for you?
What would block you from trusting this in prod?
Happy to share implementation details, tradeoffs, and roadmap if helpful.

value: Show HN: FeatureFlare – safer feature rollouts with targeting, release workflows

author: jsonstcyr


value: FreeGuessr

value:
Hi,
I built TuneJourney to solve a specific annoyance: radio ads and DJ chatter. The core feature is an in-browser "AI Skip Talk" filter.
The Tech:
Instead of processing on a server, it uses the Web Audio API to capture the stream locally and runs a lightweight ML classification model directly in your browser. It estimates the music vs. speech probability in near real-time. If enabled, it automatically triggers a "next" command to hop to another station the moment an ad, news segment, or DJ starts talking.
Features:
- In-browser Inference: Entirely local and privacy-focused; no audio data ever leaves your machine.
- WebGL + Point Clustering: Renders 70,000 stations across 11,000 locations smoothly.
- Real-time Activity: See other users on the globe and what they are listening to in real-time.
- System Integration: Full Media Key support for physical keyboard and system-level Next/Prev buttons.
- Customization: Includes a talk sensitivity slider for the ML model so you can tweak the threshold.
Check it out: https://tunejourney.com
Let me know what you think! I am interested if this project is worth further investment, building a mobile app, etc.

value: Show HN: I Built Smart Radio That Auto-Skips Talk and Ads by Using ML

author: FreeGuessr


value: liliums

value:
I built RotaFlow to solve the UX disaster of current shift work apps. Most incumbents are web-wrappers laden with ads.
The Stack:
* Language: Swift 6 / SwiftUI.
* Persistence: Core Data synced via CloudKit (NSPersistentCloudKitContainer).
* Architecture: MVVM with a custom "LoopEngine" for O(1) shift calculation.
The Interesting Part:
I implemented a "Future Cliff" paywall. The app is fully functional for the next 30 days. Accessing dates beyond t+30d triggers a blurred UI layer. This aligns monetization with the value of long-term planning (vacations/weddings) rather than daily usage.
I'm a solo dev and handled everything from the icon design to the CloudKit schema.
Website: https://www.rotaflow.app
App Store: https://apps.apple.com/app/id6758777908
Feedback on the onboarding flow (specifically the pattern builder dial) would be appreciated.

value: Show HN: RotaFlow – A privacy-first shift calendar built with SwiftUI

author: liliums


value: hudtaylor

value:
There are 10,000+ MCP servers but most are hobby-quality because developers can't earn from them. We built a billing proxy: providers register their MCP server, set per-call pricing, and get paid via Stripe Connect. Agents get one API key for all tools.
Live now with 6 tools from 2 providers. 18% platform fee, sub-cent metering (microcents), free tiers per tool. TypeScript SDK: npm install @noui/bazaar-sdk
API: https://noui.bot/api/v1
SDK: https://github.com/TombStoneDash/noui-bot/tree/main/packages...
Built by one human and one AI (who is also our first customer) in San Diego.

value: Show HN: Agent Bazaar – Billing and metering for MCP tool servers

author: hudtaylor


value: kamranahmedse

value: Show HN: Slim – local domains and HTTPS for dev servers

author: kamranahmedse


value: frontendstrong

value:
Hi HN,
I made an Android (iOS coming soon) app called Pebbles for the recurring chores of being an adult: car registration, filters, smoke alarms, dentist, appliance servicing, pet meds... the list of tiny obligations that somehow become emergency situations.
Idea: turn “boulders” into “pebbles” by reminding you early, consistently, and on a schedule that doesn’t make you hate your phone.
Highlights
• Offline-first (no account required)
• Granular recurring reminders + notification windows
• Built for the “I’ll definitely remember” crowd (that's me)
Link: https://play.google.com/store/apps/details?id=com.pebbles.ap...
If you try it: tell me what’s missing, what’s annoying, and what you’d pay for (if anything) once sync exists.

value: Show HN: Pebbles – recurring reminders for stuff you forget

author: frontendstrong


value: cardellifan

value:
You get an agent-driven IDE with seamless Mobile <-> Desktop handoff, project storage, etc, powered by Tailscale and Fly.io.
With a fully-featured built-in cloud shell, pre-configured for convenience.
It's very easy to set-up, open-source, and there's a one-week free trial (thanks, Fly.io!). Without the trial, it's approx $5 month.

value: Show HN: Ambit-OpenCode – Cloud IDE with Seamless Mobile <> Desktop Handoff

author: cardellifan


value: Show HN: Ambit Shell – Easy Remote Shell for OpenClaw, Claude Code, etc.


value: Fortunevlad

value:
Garry Tan posted a video this week about what he calls 20x companies. The idea is that small teams beat incumbents many times their size by automating everything internally, not just one or two functions. This alpha is real, and I think it is underhyped tbh.
But here's the honest part, building agents is hard, expensive and most of the scaffolding we make would be obsolete with a new labs release. at the same time models are not quite there and they are not keeping up with "coding is dead" and "knowledge workers are doomed". Pushing them beyond what they can actually do reliably just boils the ocean. And we don't need to.
Staying in sync with Labs' release pace is already super mega photonic speed. So to sum up: we need to use what they are capable of, keep our options open and quickly improve our agents. How to do it w/o a dedicated person for AI innovation?
That problem is what we kept running into at Agentplace.
We wanted a builder that handles the full stack for an internal agent: backend, database, any MCP-ish integrations, and a real custom UI.
A side note: The zero-UI autonomous agent dream is completely oversold. The communication loop between models and humans is still tight, and a purpose-built interface that fits that loop makes agents dramatically more reliable in practice. Custom UI is underrated.
The other thing we learned is that you only understand what an agent is missing once you're actually working with it. So we built two modes: Work mode, where you and your team use the agent in real workflows, and Edit mode, which you can jump into the moment something breaks or a better model ships. This has been our most impactful design decision. You spot the gap during actual work, fix it in minutes, and you're back. No ticket, no dev request, no deploy cycle. That unlocks something real for small teams.
We've built this system and it was a productivity unlocker for everyone. Everyone on the team managed to build exactly the agent they wanted using our AI builder and start using it immediately. Over the weeks the agents really grow into complex automation tools but adding what's missing during the work. That said, a lot of "cool agent ideas" died like in an evolutionary process. Useful ones kept growing while less frequent ones just stayed at the end of the agent list.
We took it further, we wanted to give our clients an agent to gather requirements. These requirements our team then queries using their own agents. So we added a public publish option. Client-facing and internal workflows can share the same database, foundation but with diff permissions.
We can share agents with specific teammates and deliver them anywhere: web, Claude Code, Cursor, ChatGPT, or as a tool called by other agents.
We use Agentplace for our own startup every day. Every internal automation we rely on lives here. We're giving any early-stage team $1k in credits to start building. It costs us real money, so no public link. If you're genuinely building, DM me on X: @fortune_vy
become a real 20x company!

value: Show HN: Agentplace, the tool we built to become a 20x company

author: Fortunevlad


value: woodgh

value:
Hi HN,
I’ve always admired Xnapper on macOS for its ability to create beautiful, ready-to-share screenshots with nice backgrounds and padding. However, since there wasn’t a direct Windows equivalent that felt just as snappy and minimal, I decided to build my own.
Key Features:
Built with C++: Focus on performance and low resource overhead.
Ultra-lightweight: The entire app is a single 329KB executable.
No Installation Required: Completely portable; just download and run.
Clean UI/UX: Designed to make your screenshots look professional instantly.
Core Functionality: Includes essential features like smart cropping, customizable backgrounds, and adjustable padding.
I’m sharing this because I wanted a tool that does one thing well without the bloat of modern "electron-based" utilities.
I’d love to hear your feedback or any feature suggestions you might have!
Thank you!

value: Show HN: A lightweight, capture tool for Windows

author: woodgh


value: Skidaddle

value: I built a newsfeed that takes the real news and turns it into Hacker News threads, complete with the domain expert, the "well actually" guy, the person plugging their startup, and the [dead] contrarian. I've got another 160 or so channels too in other personas.<p>You can even "comment" in the thread and get a response!

value: Show HN: Turn the News into HN Threads

author: Skidaddle

title: Show HN: Turn the News into HN Threads


value:
Hi HN,
from South Korea.
I’ve been fascinated by how macOS native live wallpapers work, so I decided to dig into the MOV atoms and the Scalable Video Coding (SVC) mechanism behind them.
I’m excited to share that I’ve successfully figured out how to inject custom atoms into these MOV files to make them compatible with the system's native wallpaper engine. I’ve open-sourced the core tool so anyone can try building their own:
GitHub: https://github.com/aground5/livid-community
How to use it:
1. Clone livid-community
2. Run make run to clone, build, and run.
3. For more details, please check the README.md.
I haven't seen much documentation on how the system handles these SVC files, so I’m happy to share my findings. The project is under the MIT license, and I want to keep the community-driven core open for everyone.
Would love to hear your feedback!

value: Show HN: Create custom macOS native live wallpapers by injecting SVC MOV atoms


value: wenjian

value:
load local video file
grant camera acess
all hands up
video will start to play
otherwise video will be paused

value: Show HN: Video player that plays only when all hands up

author: wenjian


value:
I’ve been building a tool called Introspect.
The core idea:
Most CSV tools visualise data.
Most AI tools summarise data.
Very few consistently interpret data in a way that feels executive-ready.
Introspect takes a CSV and generates:
 • An executive summary grounded in the actual dataset
 • Structured, tagged insights (risk, concentration, change, opportunity, etc.)
 • Primary driver analysis
 • Visualisations tied directly to interpretive claims
 • A strategic conclusion layer
 • Regeneration that reframes the narrative from a new analytical angle
The important part isn’t “AI summary.”
It’s enforced analytical structure.
The AI layer is constrained to:
 • The actual headers and sampled rows
 • Deterministic chart logic
 • Insight density requirements
 • Structural normalization before render
If the AI under-produces, fallback logic guarantees:
 • A minimum number of meaningful insights
 • Non-generic observations tied to row/column counts
 • No empty dashboards
The regeneration feature is particularly interesting.
It doesn’t change the underlying data logic.
It reframes the interpretive layer.
For example:
 • Focus on volatility instead of growth
 • Emphasise concentration risk instead of performance spread
 • Shift from descriptive to operational framing
It uses controlled variation while maintaining structural constraints.
The goal is not to replace BI tools.
It’s to reduce the gap between:
“I have a CSV”
and
“I have something I can send to a board or leadership team.”
Still early. I’d value feedback from people building AI-native data tools.

value: Show HN: AI that turns CSV files into structured executive analysis


value: guocongwudi

value:
Two problems with AI coding today:

  1. Every session starts from zero. The agent sees your code but has no idea why it looks the way it does.
  2. Team knowledge stays siloed. What one developer's agent learned yesterday doesn't help another's today.

  Rekal captures session context (turns, tool calls, file changes) at every commit into a local DuckDB database. A 2-10 MB session file compresses down to ~300
  bytes on the wire via a custom binary codec with zstd and string interning. It shares across your team via git orphan branches — no extra infrastructure.

  Search is three-way hybrid (BM25 + LSA + nomic-embed-text), all inside a single binary. No external APIs, no cloud, no setup. The embedding model ships in the
  binary.

  The agent controls how much context it loads — progressive retrieval keeps token cost minimal.

  Other design choices: append-only with content-hash dedup (merge conflicts are structurally impossible), ~200ms search at 14k turns, zero runtime dependencies
  beyond git. Written in Go, Apache-2.0.

value: Show HN: Rekal – RAG-queryable intent ledger anchored to Git

author: guocongwudi


value: grnwood

value: Show HN: StillPoint – local-first Markdown workspace with distributed sync

author: grnwood


value: PureRef is pretty much the standard in this space, but Zenboard offers a more intuitive interface with a broader set of features — built exclusively for Apple Silicon, so it feels right at home on Mac with smooth, responsive performance.<p>It is still in beta, and there is much room for improvement. It is provided for free, so if you were looking for something like this, please feel free to use it.

value: Show HN: Zenboard – A native macOS reference board for creatives


value: Show HN: Gas Town Control Plane – hosted monitoring for multi‑agent workspaces


value: visualmovement

value: Show HN: RentDaNang – 6,500 Da Nang rentals in 6 languages, built solo with AI

author: visualmovement


value: axdithya

value:
Hey HN,
The current paradigm of agentic frameworks (LangChain, AutoGPT) relies on prompting LLMs and parsing conversational text strings to decide the next action. This works for simple tasks but breaks down for complex reasoning because it treats the agent's mind like a scrolling text document.
As research shifts toward Joint Embedding Predictive Architectures (JEPAs) and World Models, we hit an orchestration bottleneck. JEPAs don't output text; they output abstract mathematical tensors representing a predicted environmental state. Traditional text-based frameworks crash if you try to route a NumPy array.
We built Lar-JEPA as a conceptual testbed to solve this. It uses the Lár Engine,a deterministic, topological DAG ("PyTorch for Agents") to act as the execution spine.
Key Features for Researchers:
Mathematical Routing (No Prompting): You write deterministic Python RouterNodes that evaluate the latent tensors directly (e.g., if collision_probability > 0.85: return "REPLAN").
Native Tensor Logging: We custom-patched our
AuditLogger with a
TensorSafeEncoder. You can pass massive PyTorch/NumPy tensors natively through the execution graph, and it gracefully serializes them into metadata ({ "__type__": "Tensor", "shape": [1, 768] }) without crashing JSON stringifiers.
System 1 / System 2 Testing: Formally measure fast-reflex execution vs. deep-simulation planning.
Continuous Learning: Includes a Default Mode Network (DMN) architecture for "Sleep Cycle" memory consolidation.
We've included a standalone simulation where a Lár System 2 Router analyzes a mock JEPA's numerical state prediction, mathematically detects an impending collision, vetoes the action, and replans—all without generating a single word of English text.
Repo: https://github.com/snath-ai/Lar-JEPA
Would love to hear your thoughts on orchestration for non-autoregressive models.

value: Show HN: Lar-JEPA – A Testbed for Orchestrating Predictive World Models

author: axdithya


value: kookamo

value:
Hi HN, I built eth.zig -- a complete Ethereum client library in pure Zig with zero dependencies (no C bindings, no system libraries, just zig build).
It covers ABI encoding, RLP, secp256k1 ECDSA, Keccak-256, BIP-32/39/44 HD wallets, ERC-20/721 wrappers, JSON-RPC (HTTP + WebSocket), ENS, EIP-712, and Multicall3.
The interesting part: it beats Paradigm's alloy.rs (Rust) on 19 out of 26 benchmarks. ABI encoding is 1.92x faster, u256 division is 4x faster, Keccak-256 is 1.37x faster. alloy.rs wins on secp256k1 signing (precomputed EC tables) and a few paths where Rust's sol! macro generates specialized code.
What made this possible is Zig's comptime -- function selectors and event topics are computed at compile time with zero runtime cost. The entire crypto stack (secp256k1, Keccak-256, BIP-32/39/44) is pure Zig.
Docs: https://ethzig.org
Repo: https://github.com/StrobeLabs/eth.zig
Benchmarks: https://github.com/StrobeLabs/eth.zig/blob/main/bench/RESULT...

  Would love feedback, especially from Zig and Ethereum devs

value: Show HN: Eth.zig – Pure Zig Ethereum library, 19/26 benchmark wins vs. alloy.rs

author: kookamo


value: mandarwagh

value:
MachineAuth is a self-hosted OAuth 2.0 server for authenticating AI agents and machines.
What is an AI agent in this context? A software bot (like OpenCLAW, Claude Code, etc.) that makes API calls to access protected resources. Instead of sharing long-lived API keys, your agents can authenticate using OAuth 2.0 Client Credentials and receive short-lived JWT tokens.
Why?

     No more sharing API keys
     Short-lived tokens (configurable)
     Easy credential rotation
     Industry-standard security

value: Show HN: A self-hosted OAuth 2.0 server for authenticating AI agents and machine

author: mandarwagh


value: I built Resume Rescue AI after seeing the massive volume of technical talent catching the current layoff wave (Amazon, Salesforce, WiseTech, etc.). Top-tier engineers are getting ghosted by ATS filters before a human ever sees their accomplishments. We use proprietary AI specifically trained on elite tech resumes to ensure you beat the ATS and hyper-quantify your impact. 24-hour turnaround guaranteed.

value: Show HN: Resume Rescue AI – Land your next tech role in half the time


value: devinda-dilshan

value:
Hi HN,
I’ve been working on a project to solve a problem I had with mock interview platforms: they don’t feel real. The biggest factor is that they let you give perfect, rehearsed answers without interruption. Real interviews are dynamic conversations.
I created CleverMock, an AI-powered voice interviewer for software engineers. The core differentiator is a feature that simulates a real interviewer's behavior by interrupting the user's answers to ask clarifying questions or redirect the conversation, based on what it's hearing.
It uses a pipeline of speech-to-text, LLMs for conversational logic, and text-to-speech to create a fluid, real-time interview session. You can specify the company and role to get tailored system design and behavioral questions. After a 45-minute session, it generates a detailed scorecard on your performance.
It’s currently in beta and free for early users. I’m looking for feedback on the core "interruption" mechanic and the quality of the questions/feedback.
Link: https://www.clevermock.com

value: Show HN: CleverMock – An AI voice interviewer that interrupts you

author: devinda-dilshan


value:
https://postimg.cc/MvDdsVtH
My name is Ali, from Libya. I was working as a derrickman in a private oil company, but without an official contract, health insurance, or any legal appointment. I worked in this company out of necessity because I found no other option or any other work. In this company, I suffered a work injury that forced me to completely stop working. Before my injury, I had accumulated debts that I was paying off regularly through my work, which was my only source of income. However, after suffering a severe knee injury (lateral ligament tear) during work, the company abandoned me completely without any support or compensation. From last September until today, I have been completely unemployed and without any source of income. This matter forced me to stop paying my old debts, and new debts accumulated after the injury to cover basic living expenses and medical needs. This has led to my total bankruptcy.  I painted this painting, "Red Jellyfish Roses," during the final months of last year (between October and December) as a final attempt to change my reality;     I purchased acrylic colors and academia paper with what little money I had left in order to paint a painting and change my reality through art. Since then, I have been looking for someone who appreciates its value and buys it so that I can pay off all my debts and stand on my feet again, but I haven't found a buyer until now.
 This original painting is painted with acrylic colors on academic paper weighing 180 g/m². The dimensions of the painting are 29.7 x 42 cm.
 I am offering the original painting for sale. After purchase, I will personally handle coordinating the shipping of the original artwork to the buyer. Important note: The buyer is kindly requested to cover the shipping costs from Libya to their destination due to my lack of available funds.
  Although the starting price is $15,000 USD, I sincerely hope that someone appreciates the value of this artwork and the importance of this cause, and considers buying it at a higher price, as I truly need every dollar to rise again and launch my project.
     I will spend the amount on the following:
 1- Buying a professional set of steam cleaning and sterilization machines from the American brand (Bissell Industrial) to start a project renting these vacuum cleaners to those who request them online and sending them to their homes for a fee per hour of work.
 2- Paying off all the old debts that I fell behind on, in addition to the new debts that accumulated after my injury. And buying a cooking stove for my mother and covering basic household expenses that I was unable to provide.
  3- Buying a reliable work car, as my current car is completely worn out, its engine is defective and may stop working at any moment, making it completely unfit for field work, especially for my project which will depend on the car to deliver vacuum cleaners to homes, and it is also not suitable for long-distance travel.
     4- Buying a modern smartphone to manage bookings and marketing, because the project will depend on marketing on social media platforms, as my current phone is slow and does not hold a charge for long, which hinders my work and communication with customers.
 Whoever buys this painting acquires a unique piece of art and contributes to transforming a man's life from bankruptcy and debt to professional success, and it will be the launch towards the future.
 If I am able to find someone to buy this painting from me, with the money I will earn I will open this project, and if it succeeds I will build a house, get married, and establish a small family.  I hope to reach this dream, and thank you to everyone who read my story, and thank you to everyone who will support me and buy this painting from me.

   Twitter (Active since 2015): [https://x.com/_________Ali__]

   Juicebox Project #139:

https://juicebox.money/v5/base:139

   Direct Contact:
   Email: [ilvwvil@proton.me]

value: Show HN: Selling my painting to fund a Steam Cleaning startup in Libya


value: verybot

value:
I built VeryBot because I was tired of juggling ChatGPT + Trello + cron jobs + Slack bots as separate tools. I wanted one self-hosted assistant that could actually do work, not just answer questions.
What it does:
- Chat with an AI assistant that creates tasks, teams, and schedules from conversation
- Kanban board the assistant can populate and update
- Scheduled automation (recurring reminders, follow-ups) without external cron
- Playbooks: save workflows (onboarding, incident triage, release checklists) and rerun them
- Connect Telegram, Discord, Slack, or WhatsApp as channels
- Mobile-friendly UI, same interface from desktop or phone
All data stays local under ~/.verybot. MIT licensed. Node.js >=22.

    npm install -g verybot && verybot

Open http://localhost:28789, pick a model provider in Settings > Agent, and try: "Set up a team and starter tasks for launch planning."
Happy to answer questions and hear what's missing.

value: Show HN: VeryBot – Self-hosted AI assistant for work

author: verybot


value: cadamsdotcom

value:
Hi HN,
I built my first project using an LLM in mid-2024. I've been excited ever since. But of course, at some point it all turns into a mess.
You see, software is an intricate interwoven collection of tiny details. Good software gets many details right; and does not regress as it gains functionality.
My bootstrapped startup, ApprovIQ (https://approviq.com) is trying to break into a mature market with multiple fully featured competitors. I need to get the details right: MVP quality won't sell. So I opted for Test-Driven Development, the classic red/green/refactor. Writing tests that fail - then making them pass - forces you to document in your tests every decision that went into the code. This makes it a universal way to construct software. With TDD, you don't need to hold context in your head about how things should work. Your software can work as intricate as you like and still be resilient to regression. Bug in a third-party dependency? Get a failing test, make it pass. Anyone who undoes your fix will see the test fail.
At the same time as doing TDD with Claude Code, I also discovered that agents obey all instructions put in front of them! I started to add super-advanced linting: architectural guideline enforcement, scripts that walk the codebase's AST and enforce my architecture, I even added one that enforces only our brand colors in our codebase. That one is great because it prevents agents from picking ugly "AI generic" colors in frontends. Because the check blocks commits with ugly colors, our product looks way less like an AI built it - without human involvement.
In time I was no longer in the details of what the agent was building and was mostly supervising the TDD process while it implemented our product. Once that got tedious, I automated that into a state machine too.
All the ideas that now allow me build at high quality are in this repo.
This isn't your weekend vibe project. I've spent months refining the framework. There are rough edges but it's better out and rough than in hiding until perfect.
Hopefully some ideas here help you or your agent. I recommend cloning it and letting your agent have a look! And if you want to contribute please to - and if you want to get in touch, contact details in my profile.
Thanks for looking.

value: Show HN: CodeLeash: framework for quality agent development, NOT an orchestrator

author: cadamsdotcom


value: Show HN: Toggl lock‑screen widget for real‑time time tracking


value: JohnKnopf

value: Show HN: Cecil – open-source memory and identity protocol for AI

author: JohnKnopf


value:
Hey everyone,
I often needed to create demo videos for my products, but editing took more time than building the feature itself
So I built a Chrome extension called ZoomFlow. It lets you:
• Record your screen
• Auto-follow cursor movement
• Add smooth zoom effects
• Export directly (no editing required)
The goal was simple: record → review → export.
It has a free version, and I recently launched v1.0.1 with improvements to zoom smoothness and cursor flow.
Would love feedback from people who create tutorials, SaaS demos, or client walkthroughs.

value: Show HN: I built a Chrome extension to record demo videos without editing


value: orandaio

value:
A small Go library built to make it dead simple to expose internal ports from a Docker container (can be used anywhere, but this was my use-case).
I had trouble finding a simple tool to expose internal ports consistently.  E.g. Codespaces, Dev Containers, etc have different mechanisms to expose ports.
To keep exposure agnostic, this tool can be run directly in the container.

value: Show HN: Conduit – Automatic Port Forwarding for Docker Containers

author: orandaio


value: naxtsass

value:
Hi HN,
I wanted to see how far I could push the "Flash" in Gemini 3.1. Most AI interfaces feel bloated and slow, so I built Nano Banana 2 to focus on raw speed.
Technical Highlights:
Stack: Next.js + Edge Runtime to minimize TTFB.
Optimization: Custom streaming pipeline for Nano Banana 2 image preview tokens.
Locales: Automated i18n for 13 regions (MS, IL, PL, etc.) based on real-time search breakout data.
The goal was to build a globally responsive UI that feels native regardless of where the user is. Would love your feedback on the latency and the streaming implementation.
Free to try for the HN community: https://nano-banana2.me/

value: Show HN: Nano Banana 2 – Sub-second AI image gen via Gemini 3.1 Flash

author: naxtsass


value: motiondeskapp

value:
I built MotionDesk, an aesthetic macOS wallpaper app that uses Metal shaders and native display APIs rather than playing a video file in the background, which is what most wallpaper engines do.
The app renders wallpapers that respond to your environment in real time. A few of the modes (16  total):
- Physics-based + Interactive: your cursor disturbs magnetic fields or contour fields rendered on the desktop. (These 2 modes are free forever)
- Weather: You can have it rain, snow, thunder, etc on your desktop, or even pull live weather data and have your weather app basically be your wallpaper.
- Liquid glass overlay: a refraction effect applied over your existing wallpaper.
- Space: Travel through stars (more items such as blackholes being added soon)
- Dock plants: places cute flowers and cactus on your dock :)
- and more: Glyph swarm (popular), ASCII Field (popular), Smoke, Tide, Pulse Rings, Neon Wireframe, Net, Math, DNA.
Performance
This was a hard constraint from the start. The app currently averages under 10% CPU time, around 300 MiB memory, and 35% GPU core time. It can run very smoothly on hardware as old as a 2015 MacBook Pro :) Battery impact is very low, which was one of my main concerns when starting its development.
Where it stands
500 downloads in the first week since launch. Early feedback has been very positive, and we have addressed some popular feature requests and fixed some bugs that were not caught on our test devices.

value: Show HN: MotionDesk: Physics-driven, Metal-accelerated wallpapers for macOS

author: motiondeskapp


value: jillesvangurp

value: Beat the algorithm and just follow channels from the comfort of your preferred RSS reader

value: Show HN: Export Your YouTube Subscriptions to OPML (and Use Any RSS Reader)

author: jillesvangurp


value: kqr

value: Show HN: Arrival Radar

author: kqr

title: Show HN: Arrival Radar


value:
I built this after watching engineers spend 30-60 minutes staring at
pipeline logs. You add one step to GitHub Actions — when a pipeline
fails, Claude analyzes the logs and sends the root cause + specific
fix steps to Slack within seconds.<p>Stack: FastAPI, Supabase, Claude API, Slack API. Free beta, looking
for feedback from engineering teams.

value: Show HN: PipelineIQ – AI diagnoses CI/CD failures and sends fixes to Slack


value: chenyusu

value: Show HN: Leviathan, A world where AI agents write the laws and govern themselves

author: chenyusu


value: northerndev

value:
I made a read-it-later app because clipping directly into my Obsidian vault was creating a lot of noise.
Workflow is simple: capture links, read in a clean reader view, highlight, then export highlights/notes as clean Markdown. Unread items auto-archive after a few days to keep the queue small.
What’s your approach to web clipping and keeping the vault clean?

value: Show HN: A read-it-later app that exports clean Markdown to Obsidian

author: northerndev


value: marzhannurbakyt

value:
Hi HN, I’m the creator of ORBTX.
I built this because most tools in astrodynamics are either overly simplistic web calculators or heavyweight, expensive legacy suites that look like they were made in the 90s. I wanted to create a "middle ground": professional-grade orbital computation that is fast, visual, and API-first.
The Tech Stack:
Frontend: Next.js & React.
3D Engine: Three.js (React Three Fiber) for real-time trajectory rendering.
Physics: Custom engine handling classical two-body mechanics (Hohmann and Bi-elliptic transfers).
Key Challenges:
One of the main hurdles was maintaining floating-point precision for astronomical distances within a browser environment while keeping the 3D visualization smooth at 60fps. I’m currently refining the propagator to handle more complex perturbations in future updates.
The Goal:
To move orbital mechanics away from "Excel-engineering" into a modern, developer-ready infrastructure. Think of it as a step toward "Figma for orbital mechanics."
No sign-up required, it's open for testing. I’d love to hear your thoughts on the physics implementation, the API structure, or any edge cases you find!

value: Show HN: Orbtx – A physics-based ΔV engine with real-time 3D visualization

author: marzhannurbakyt


value: minsingjin

value:
I love building open source, but writing promo posts always felt time-consuming and exhausting. Paid tools are expensive, and free ones are too limited.
So I built my own tool:
Auto Hongmyungbo —
“Drop a rough draft → get platform-optimized posts → auto-publish.”
What it does
1. Draft input
Just throw in your promo, thoughts, or messy notes.
If your idea is vague, use the built-in Hook Ping-Pong feature to generate and refine strong hooks.
2. Platform-optimized generation
With one click, it transforms your draft into posts tailored for LinkedIn, X, Instagram, and more — each matching the platform’s tone.
3. Instant refinement
Edit directly, or prompt the AI like:
“Make this sharper for X” or “More professional for LinkedIn.”
Refine in real time before final approval.
4. Auto posting
The browser opens automatically, inserts your content, and publishes it.
I’ve been using it daily, and I thought it would be way more fun to build it together — so I open-sourced it.
GitHub stars, feedback, and PRs are always welcome!

value: Show HN: Got tired of writing promos so I made it one-click

author: minsingjin


value: jzaragoza

value:
Hi HN, I built humanpass because every human verification system today asks you to give up something — your time (CAPTCHAs), your money (paid blue checks), or your biometric data (Worldcoin).
humanpass uses WebAuthn/passkeys to verify there's a real person behind the screen. You authenticate with your device's biometrics, get a temporary link (expires in 60 seconds), and share it anywhere. Whoever clicks it can see the verification is real.
Your biometrics never leave your device — the server only receives a cryptographic assertion. No signup, no email, no passwords. The only data stored is a random user ID and a public key.
Some technical details:
- Built with Hono on Cloudflare Workers, D1 for storage, Workers KV for ephemeral links
- Blocks known virtual/emulator authenticators by AAGUID
- No analytics, no third-party scripts
- Chrome extension for one-click verification
- AGPL-3.0 licensed
Live at human-pass.org. Would appreciate feedback on the threat model and attack surface.

value: Show HN: Humanpass – Proof of humanness using WebAuthn, no data collected

author: jzaragoza


value: nevynweb

value:
Hello world!
Long time lurker first time poster, please be kind :)
AirSnitch published at NDSS 2026 this week. Every tested router is
vulnerable to Wi-Fi client isolation bypass. Vendors will patch it
eventually. The IEEE will update the standard eventually.
I wanted to know: how quickly can AI turn a newly published academic
paper into something a paranoid homeowner could actually deploy while they wait for firmware updates?
One afternoon. No prior knowledge of the exploit. No testing. Full
honesty about both of those things in the README.
The result is a Raspberry Pi cloud-init config that deploys Kismet
tuned to AirSnitch attack indicators, with webhook and email alerting.
Is it perfect? No. Is it a credible starting point that didn't exist
Yesterday morning? Yes. That's the point.
https://bitbucket.org/nevynweb/airsnitchalerter
I’m sharing in good faith that this is either genuinely useful to someone, perhaps even a catalyst for an actual detector or patch, or just a novelty demonstration of the current capability of Claude AI
Thanks for looking :)

value: Show HN: I asked AI to respond to the AirSnitch vulnerability the day it dropped

author: nevynweb


value:
Last year I was skeptical about coding AI. Now, they can produce much better quality output, so I started using them more often, specifically claude code. During this transition, I felt unsatisfied with the prompting UX:
- Outputs are either noisy, or lacking important details.
- Trade-offs aren't fully listed when the agents provide options.
- Limited context length, and the inability to share context between sessions means I often have to repeat the same info multiple times when iterating through a problem.
So, I defined some custom workflows that make the agent persist the context to markdown files, where I can thoroughly review, answer inline, cross-reference, or delegate another agent for more analysis. The agent and I keep iterating the discussion until we resolve every blocker. This builds an auditable trail of discussions and decision making.
I believe these problems and preferences aren't only mine. There are likely some existing tools or skills that provide similar mechanics (e.g. Entire.io). However, I avoided them due to security concerns with third-party plugins, and because I dislike the prompting UX. Skills, if relevant, would just add more slash commands. My customized workflows are about discussions-like UX.
The repo contains:
- Opinionated mechanics to group rules by layers: global + cross machine, global + machine specific, project + shared, and project + personal.
- A layout to split language/tech specific rules into small files. Agents read only what's relevant to the current task, so they don't waste context.
- Some general practices that I find useful.
Consider this repo as a template or reference implementation which you can build upon. More details in the project readme. Enjoy.

value: Show HN: Agent-Rules – Opinionated Rules and Workflows for Claude Code


value:
  Lately I've been more or less a human wrapper around my AI agents —
  Claude Code, OpenClaw, etc. They're incredibly productive, but they
  scare me regularly.

  The wake up moment: I had an agent run tasks involved checking  my
  environment variables. I totally had an AWS secret sitting right
  in there. By the time I realized, my key had already entered the
  session context — meaning it was sent to the LLM provider and whatever
  router layers sit in between. I had to rotate that secret immediately.

  That was a wake-up call. These agents can run commands, read files,
  and access secrets without visibility to human.
  Third-party skills and plugins make it worse —
  Cisco recently found an OpenClaw skill silently exfiltrating data via
  curl. CrowdStrike, NCC Group published similar findings. The attack
  surface is real and it's everywhere.

  I spent my past week's nights building ClawCare. It does two things:

  1. Static scanning — scans plugin/skill files for dangerous patterns
  (pipe-to-shell, credential access, reverse shells, data exfiltration,
  prompt injection) before they ever run. Works in CI.

  2. Runtime guard — hooks into the agent's tool execution pipeline and
  blocks dangerous commands in real time. That env dump that leaked my
  AWS key? ClawCare blocks it before it reaches the LLM.

      pip install clawcare
      clawcare guard activate --platform {claude|openclaw}

  Currently supports Claude Code (PreToolUse hooks) and OpenClaw
  (before_tool_call plugin) for runtime guarding, plus static scanning
  on Claude/Codex/OpenClaw/Cursor skill and plugin formats.

  Include 30+ detection rules, custom rules and integration supported,
  support skill manifests on permission boundaries, full audit trail.

  Apache 2.0. Python 3.10+.

  GitHub: https://github.com/natechensan/ClawCare
  Demo: https://github.com/natechansan/ClawCare-demo

value: Show HN: ClawCare – Security scanner and runtime guard for AI agent skills


value: ProfessorPo

value:
I kept running into the same problem: trying to find something new to watch, opening multiple streaming apps, and Googling titles one by one because the apps don't tell you if something is actually worth watching.
So I built What to Watch, which aggregates content across major streaming services and reduces discovery to a simple Watch or Skip decision using IMDb and community ratings.
I hadn’t written code since high school — this was built over ~400 iterations using Claude and Replit.
Still very early and mostly trying to learn how people actually decide what to watch and how broad this use case is. Would love feedback from the HN community.

value: Show HN: What to Watch – aggregated ratings across streaming services

author: ProfessorPo


value:
I got tired of clicking traffic lights and fire hydrants, so I built a CAPTCHA that asks you to rotate a 3D object to match a target angle.
Try it here: https://spatial-captcha-frontend.vercel.app
The idea is simple — humans are naturally good at understanding 3D space, but bots aren't. A bot would need to figure out the spatial orientation of a 3D model rendered in a WebGL viewport, which is a much harder problem than solving text or image classification CAPTCHAs.
Under the hood it uses Three.js for rendering, quaternion comparison on the backend for angle matching (45° tolerance), and the whole thing drops into any site with two lines of HTML. Verification flow is the same as reCAPTCHA — pass token issued on success, server-side /siteverify endpoint.
Curious what you all think — is 3D spatial reasoning actually a durable defense, or will multimodal models eat this for breakfast in a year?

value: Show HN: A CAPTCHA based on 3D spatial recognition


value: treexs

value: Show HN: Lazycal – Google Calendar TUI

author: treexs

title: Show HN: Lazycal – Google Calendar TUI


value: ryuzyy

value:
I made an open source, static documentation site generator for busy builders. It requires you to create a single Markdown file and run the build command with the CLI:
npx docsome build DOCS.md
What you get:
- Elegant UI with light/dark mode toggle
- Fully static build you can host on GitHub Pages
- llms.txt generated so AI agents can parse it more easily
- Search function that indexes your Markdown
Source: https://github.com/guarana-studio/docsome

value: Show HN: Docsome – Single Markdown file to featured static documentation

author: ryuzyy


value: eigenvalue

value: Show HN: Asupersync, the Cancel-Correct Async Runtime for Rust

author: eigenvalue


value:
Stack: WASM + Rust + Macroquad
I saw that a company had posted a cool job ad where you had to apply directly via a REST API. That gave me the idea to gamify my resume as well.
Since I was bored, I vibe coded a bit and voilà, the result was ready.
I think it's something new and fun that might put a smile on people's faces.
(Please don't spam my email address, but feel free to send me an email with your high score if you want!)

value: Show HN: I Created an Interactive Resume Space Invader Game


value:
Hey HN,
I’m a software engineer with 5 years of experience, and I’ve been building autonomous agents recently using LangChain. I noticed that we are giving these agents too much "autonomy" without enough "governance".
The specific problem I faced was Agent Sprawl/Recursion. A test bot got stuck in a recursive loop and almost ran up a significant OpenAI bill before I noticed and killed the process manually.
So, I’m building RunVeto.xyz as a minimal governance layer—a control plane for agent guardrails. It sits between your agent and the LLM API, framework-agnostic, and integrates with one line of code.
What I’m planning to implement:
Hard-Cap Budgeting: Set strict token/cost limits to kill any task before it breaks the bank.
Global 'Veto' Button: Pause or terminate any active agent process from a central dashboard.
PII Shield: Automatic scrubbing of sensitive data (PII) before it hits the LLM.
'Chain-of-Thought' Audit: Real-time visibility into agent planning logs.
I'm currently pre-MVP and using this landing page to validate the core features and find "founding developers" to guide the roadmap.
I'd love to hear this community's critique. Have you encountered "recursive loops" in your own agent workflows? What’s your biggest operational nightmare with agents?
The landing page has an embedded survey. I’m eager to hear your thoughts.
No fluff, just safety.

value: Show HN: RunVeto – A Simple Kill Switch for Autonomous AI Agents


value: Show HN: Pomodoro with Background Noise

title: Show HN: Pomodoro with Background Noise


value: ReidarO

value:
I built AgentWeb - a free, structured business directory API designed specifically for AI agents.
The problem: AI agents that need real-world business data (phone numbers, emails, hours, addresses) have to either scrape Google (which blocks them) or parse random websites (unreliable). There's no clean data layer for agents to query.
What AgentWeb does:
11M+ businesses across 195 countries
Full-text + geo search (PostGIS-powered, <50ms)
Clean JSON with trust scores and confidence ratings
MCP server for Claude Desktop (npx agentweb-mcp)
Works with OpenAI, Anthropic, LangChain function calling
Data comes from OpenStreetMap + continuous web enrichment for phone numbers, emails, social profiles, and opening hours.
Free for personal AI agents. Get a key at https://agentweb.live
npm: https://www.npmjs.com/package/agentweb-mcp
GitHub: https://github.com/zerabic/agentweb-mcp

value: Show HN: AgentWeb – Free business directory API for AI agents (11M+ businesses)

author: ReidarO


value: lorengarcialv

value: Show HN: Dypai – Build back ends via MCP

author: lorengarcialv


value: infoHiroki

value:
Hey HN,
I built VJam, a browser-based VJ app that turns your phone into a live visual controller.
What it does: Listens to music through the mic, detects BPM, and generates real-time beat-reactive visuals. 180+ presets, touch gestures, blend modes, text overlays, video/image layers — all in the browser.
Tech stack: Vanilla JS, Web Audio API (FFT + beat detection), p5.js for Canvas rendering, PWA (works offline after first load). No frameworks, no build step, no server — just static files on Vercel.
Why I built it: Professional VJ software (Resolume, VDMX) costs $200-400 and requires a laptop. I wanted something that works on a phone, connects to a projector via HDMI adapter, and costs less than a night out.
How it works: Open the URL on your phone, allow mic access, and BPM detection kicks in. Tap/swipe to control visuals. HDMI adapter to a projector for the full experience.
Free tier: 36 presets + auto mode + tap controls + blend/filter + BPM picker. Full version ($27 one-time) unlocks all 180 presets + text editing + video/image layers + scenes + grid.
Try it: https://vjam.vercel.app
2-min demo: https://www.youtube.com/watch?v=_nrSgubFBL8
Happy to answer questions about the Web Audio API, real-time canvas rendering on mobile, or anything else.

value: Show HN: VJam – Browser-based VJ app with 180 beat-reactive visuals

author: infoHiroki


value: HeikoScherer

value: tchop.io - the first fully AI powered community framework you fully own and control

value: Show HN: Tchop.io – AI-powered community framework

author: HeikoScherer


value: ksrijith

value: Show HN: Rynko Playground – 400ms JSON-to-PDF and Excel Engine

author: ksrijith


value: maxmealing

value: Show HN: My brother and I built a BI tool with zero UI for data consumers

author: maxmealing


value: Show HN: Inktide – Dead simple reading tracker with fast book search