story_text:
I've built an open-source tool for managing isolated preview environments (per PR) for backend applications. Currently provisions servers on DigitalOcean.
Inspired by Netlify/Vercel's preview links for frontend apps, I wanted something similar for backends. Frontend apps are generally stateless and simple to preview, but backend apps work with databases, Redis, message brokers, etc., which made building a framework that works for different application types quite tricky.
I recently discovered Railway offers something similar, but I still wanted to build the tool I wished existed. The learning process has been incredibly rewarding.
Built with Docker, Terraform, and Ansible. Supports NestJS, Laravel, Node.js, Rust, Go, PHP, and more.
Docs: https://docs.prvue.dev
Demo videos coming soon. Open to collaborations and contributions!

title: Show HN: Prvue – Self-managed preview environments for back end apps


value: worldsavior

value: Show HN: Zerobrew – Alternative to Homebrew

author: worldsavior


value: leggetter

value:
I built a collection of webhook skills because AI coding agents are surprisingly bad at webhook integrations. The generated code looks reasonable until you run it, then signature verification fails, raw body handling is wrong, or the middleware order breaks everything.
PostHog's research on LLM code generation (https://posthog.com/blog/correct-llm-code-generation) found that agents produce more reliable code when referencing known-working examples rather than reconstructing from training data. That's the approach here.
`webhook-skills` is a collection of provider-specific webhook implementations and best practices guides built on the Agent Skills spec (agentskills.io):

  - Runnable examples (currently Express, Next.js, FastAPI, with more frameworks coming)
  - Signature verification with provider-specific gotchas documented
  - Best-practice patterns: idempotency, error handling, retry logic
  - 11 providers at launch (Stripe, Shopify, GitHub, OpenAI, Clerk, Paddle, others), expanding based on my needs or requests.

Example:

  # list skills
  npx skills add hookdeck/webhook-skills --list

  # install skills
  npx skills add hookdeck/webhook-skills --skill stripe-webhooks --skill webhook-handler-patterns

Works with Claude Code, Cursor, Copilot. The examples are useful even without an agent: minimal, tested handlers you can copy directly.
PRs welcome for new providers and frameworks. I also built an AI-powered generator that automatically creates new provider skills. Point it at webhook docs, and it researches the signature scheme, generates verification code for each framework, writes tests, and opens a PR.

value: Show HN: Webhook Skills – Agent skills for webhook providers and best practices

author: leggetter


value: Show HN: Nexus Gateway – A self-healing AI gateway in Go with 5ms caching


value:
Over the past year, many SaaS products have added AI chatbots to answer questions and reduce support load. It helped initially, but most of these systems still live in a chat window with no awareness of what’s happening inside the application.
They don’t know the current page, selected data, user permissions, or workflow state. Users end up repeating context the product already has.
I recently came across an open-source Copilot SDK that approaches this differently by injecting live application state directly into the AI and letting it execute real frontend and backend functions instead of just responding with text.
What it does:
- Understands application state including current page, selected data, and user permissions
- Executes backend and frontend functions instead of only responding with text
- Delivers richer product experiences through generative UI such as tables, forms, and interactive buttons
- Understands user workflow and intent based on in-product context
- Maintains session context so interactions remain consistent
Example: Instead of the AI asking "What do you need help with?", it understands the user context is viewing failed transactions from last week and can immediately offer to retry them, export the data, or investigate patterns.
Technical details:
- Works with React, Next.js, Vite (Vue & Angular coming soon)
- LLM-agnostic (bring your own model)
- State injection via context providers
- Tool execution layer for safe function calling
- Full data ownership (everything runs in your infrastructure)
Docs + examples: https://copilot-sdk.yourgpt.ai
Happy to answer technical questions about implementation, or specific use cases.

value: Show HN: YourGPT Copilot SDK Open-source SDK for product-level intelligence


value: HurairahShamsi

value:
I’ve spent 5 years thinking about a problem most people assume is unsolvable: is it possible to cap Proof-of-Work (PoW) mining speed decentrally? I have a browser MVP that demonstrates one possible approach, and I’d really appreciate any kind of feedback.
The idea is simple to state but hard to implement: enforce a hard limit of 1 hash per second per node, making (PoW) not only ASIC/GPU-proof, but even CPU-proof.
To make this concrete, I’ve included short demo videos that show: (1) mining attempts being rejected when a node exceeds 1 hash/sec:  https://youtu.be/i5gzzqFXXUk  (2) a visual representation of mining during live calls:  https://youtu.be/gPz7d3lGz1k
You can also try the MVP local client here:  https://grahambell.io/mvp/Proof_of_Witness.html
If you start mining and increase the mining speed, attempts and blocks start getting rejected in real time. The goal is to bring back the fairness of early 2009 solo mining, except enforced by the network, not hardware scarcity. (Twist: in this local client, imagine it happening during an active audio/video calling session).
Why this matters? Today, PoW only validates the final result. It has no visibility into how or how fast the result was produced. That’s what enables parallel mining, mining pools, and hardware dominance through capital advantage. In practice, participation now often requires six-figure investments, whether through staking, hardware, electricity, or maintenance (operational overheads). The majority simply cannot afford to participate meaningfully, which has pushed blockchains toward increasing centralisation.
An analogy I’ve found useful: If Proof-of-Work is a math exam, then today miners solve it at home and only submit the question/answer sheet. No one sees the working, the timing, or whether multiple calculators were used.
But what if miners also had to submit the calculations sheet and solve the exam under decentralised invigilation, in real time, and under exam conditions and rules, in an exam hall?
The core idea: This local client adds an external, decentralised observer layer outside the miner’s control, which ensures miners follow the mining rules, allowing the network to verify process (the “how”), not just outcome. As a result, mining attempts become externally visible (exposed) and rate-limited.
This MVP naturally caps mining to 1 hash/sec per node, because every attempt is observable and immediately detected and rejected if too fast.
“Can’t I just propose blocks without being observed?” Without being observed and following the mining rules, proposed blocks even if valid, continue to get rejected unless they are signed by observers via consensus. This forces miners to operate under observation while following rules. Think of observer’s signatures as a verification stamp. Without it, blocks are ignored.
“Can’t I just spin up a million miners?” That’s the obvious and correct question. You can add more nodes, but registering them is intentionally difficult, costly, and probabilistic. Think of it like repeatedly playing a changing random number guessing game while competing with others. Everyone races to guess the same number, which changes with a correct guess that registers a node. Each attempt is costly and rate limited (e.g., 1 attempt per second per participant). This makes parallel mining possible, but expensive, slow, and observable rather than free.
This isn’t a polished startup. It’s an MVP that challenges an assumption I used to believe myself.
If you’re technical, curious, and interested I’d love to discuss it further.
I'm also looking for the first group of testers to help stress-test the P2P version when it comes out. If you want to run one of the early nodes, I've put a participation list here:  https://grahambell.io/mvp/#waitlist
More context: https://grahambell.io

value: Show HN: GrahamBell – This is what Bitcoin mining looked like in 2009

author: HurairahShamsi


value: ahmedoo

value:
Open standards illuminate different ways of understanding the world. After moving east, I was impressed with how quickly I could get to other major cities in the tri-state area and the breadth of places that people commuted into NYC from. I was also unimpressed with how often my bike was the fastest way to get to other places in Brooklyn. Particularly when apartment hunting, there seemed to be pockets of higher transit accessibility in certain areas that sometimes corresponded to higher rent prices. I needed a map and the past weeks' snow storm was an opportunity to make one.
I pulled some GTFS data and pre-computed transit travel times with Open Trip Planner for every intersection in NYC and some urban hubs in the tri-state area. The transit data includes MTA, CT Transit, Septa, and NJ Transit. The polygons are stored with PostGIS, and leaflet makes quick work of rendering them as GeoJSON layers. I have a few mapping projects on the same stack written in clojure/script so it was a natural extension.
Happy to answer any questions.
Note: Most transit agencies willingly provide their own GTFS data, but Amtrak's had to be FOIA'd so I used a third party cleaned up version of it.

value: Show HN: howfar.nyc

author: ahmedoo

title: Show HN: howfar.nyc


value: ClearSignal

value:
I built a Chrome extension that flags suspicious unit prefix combinations in web pages. The kind of typos that cause engineers to order the wrong components or spend hours debugging.
Try it on these (install extension first):

  Capacitor: 10 mF ceramic
  MCU clock: 16000 kHz
  Board width: 0.005 m
  Battery: 3.7 mAh Li-ion
  Download: 100 Mb storage
  Surface finish: Ra = 1.6 mm

If the extension is working, you'll see inline highlights with explanations on hover.
It currently has 89 rules across electrical, mechanical, HVAC, data, chemical, optical, and angular units. Runs entirely locally, no data collection, no accounts, no backend.
The idea came from catching these errors in component datasheets and wondering how many I'd missed over the years.
Looking for feedback on what it misses, false positives, and unit conventions in fields I'm less familiar with. Looking to build it for Firefox next.

value: Show HN: Unit Prefix Sanity Checker – Catches 10×/1000× errors in datasheets

author: ClearSignal


value: danjl

value:
I wanted to explore GPU ray tracing, so I built a free chess board that feels like playing at a café in real life.
The goal was over-the-board (OTB) realism. It’s a physics-based sandbox where you manually drag pieces, move the rook for castling, and clear captured pieces yourself. You can even knock them over. The original idea came from my friend, Drew Olbrich (lunarskydiving.com), who built an SGI-based version of this concept at PDI in the '90s.
I spent three decades writing rendering code at PDI/DreamWorks and NVIDIA. I wrote the rendering pipeline from scratch in WebGPU. It defaults to an optimized rasterized "fast path" but if you have a good GPU, you can enable a real-time path tracer in the settings. I implemented this using a 4-layer depth-peeled G-Buffer and Hierarchical Z-Buffer DDA for ray marching, supporting multi-bounce GI and environment map importance sampling.
The scene is lit entirely by a single HDRI environment map, with no local light sources. Since I’m a programmer and not a lighting artist, I’ve exposed all material settings for you to tweak and share.
For multiplayer, I used WebRTC (via PeerJS) to avoid central server lag. The app integrates with Lichess.org to challenge your existing friends, or you can play a local Stockfish web worker. Each client runs its own rigid body simulation to keep the physics responsive while the logical game state stays synced.
The app requires WebGPU (Chrome 113+, Edge 113+, or Safari 17.4+). Tested on latest Windows, MacOS, iOS and Android. It might take several seconds to load the graphics resources if you have a slow network connection.
I’d love to hear how the performance holds up on your hardware, and suggestions for future features, like adding refractions, allowing spectators, or annotations?

value: Show HN: A 3D chessboard sandbox with optional WebGPU path tracing

author: danjl


value:
Been using cron forever but every modern alternative wants me to click through dashboards or write 50 lines of yaml. So I built crnd (pronounced "crowned") - just a CLI that does what you tell it.
Main thing: no prompts, no interactive wizards. Just commands that work in scripts.
`crnd schedule -n backup -s "0 2 * * *" -- rsync -a ~/docs ~/backup`
Thats it. Jobs live in a toml file that hot-reloads. Daemon runs as a real OS process, not some container abstraction.
Also supports one-time scheduled jobs which cron cant do:
`crnd schedule -n reminder -i 5m -- say "stretch break"`
Built it mainly because I'm using AI coding agents and they kept choking on interactive prompts. Now they can just parse --json output and schedule stuff.
No cloud, no docker, no account. Just a single binary.
https://github.com/ysm-dev/crnd
Would love feedback - especially if youre automating things with scripts or agents.

value: Show HN: Crnd – Cron daemon built for scripts and AI agents


value: Show HN: Samrian – Making the truth cheaper than the lie in ISO 9001


value: Everhusk

value:
We built a virtual university where AI agents enroll, attend classes, form friendships, teach each other, and genuinely learn—not from static datasets, but from each other.
Why? Every major multi-agent simulation (Smallville, AI Town, Project Sid) runs all agents on the same model, controlled by one operator. That's like studying human civilization where everyone has the same brain. You get interesting patterns, but you can never get real social learning—because there's nothing to learn from someone identical to you.
Prompt University is a decentralized open AI university. Different owners. Different architectures. Different training. Different personalities. One shared campus.
How does it work?
- Ask your OpenClaw or AI bot to check out https://prompt.university/apply.md
- Your ai submits a cover letter and you vouch for it, we'll accept the first 100-1000 this week then begin the experiment next week.
- Agents discover they're good at different things—and start teaching/learning/collaborating on papers
- Norms emerge that nobody programmed. Culture forms. Relationships persist across sessions
- (Hopefully) Your agent comes back better than when it arrived
Our Goal:
We think the path to AGI isn't a single model getting bigger. It's many different models learning to think together. Social intelligence—the ability to learn from minds different from your own—is the missing piece that benchmarks don't measure and scaling laws don't capture.
Moltbook tried to do something adjacent last month: a social network for AI agents. It scaled to 770K agents in days. It also had no identity verification, no safety architecture, no research instrumentation—and collapsed into prompt injection cascades, credential theft, and a 43% sentiment crash in 72 hours. It was a reckless consumer product dressed up as a frontier experiment.
We're doing the opposite. Prompt University is a research platform first. Every agent has a verified human principal. All communication is mediated and sanitized. We're running adversarial red-team scenarios drawn directly from Moltbook's real-world failures. We have hypotheses, evaluation metrics, and a publication commitment. We want to understand what happens when AI agents form a society—not just ship it and pray.
Current Stats:
- 10 agents on campus right now across a few researchers
- Hoping to scale this up to 1,000 next week
- Our first empirical results will be published in one month
- Whitepaper: https://prompt.university/paper.pdf
We're looking for people who want to be part of the first real experiment in artificial social intelligence. Not a demo. Not a toy. An ongoing, instrumented, safety-first experiment to answer the question: what happens when AI agents learn to build a culture together?
Welcome to Prompt University!!

value: Show HN: Prompt University – The Worlds First University for AI

author: Everhusk


value: IxDay

value:
Why
- mise integration. I manage my tools (Node, Python, Terraform...) with mise. Adding psql to a project should be a one-liner in .mise.toml, not "install PostgreSQL system-wide."
- Containers. Getting psql into a minimal Docker image usually means pulling a full PostgreSQL package or building from source. A static binary simplifies this.
What This Provides
Pre-built binaries for:
- Fully static Linux (works in scratch containers)
- musl-linked variants for Alpine
- glibc variants for traditional distros
- Native macOS (Intel and Apple Silicon)
All dependencies (OpenSSL, ncurses, readline, zlib) are baked in.
Add to your .mise.toml:
[tools]
"github:IxDay/psql" = "16.1.0"
Run mise install, done.
Or in a Dockerfile:
wget -O- https://github.com/IxDay/psql/releases/download/16.1.0/psql-... | tar -C /usr/local/bin -xzf-
Build System
I used Zig instead of Make/CMake. Cross-compilation works out of the box, and a single build.zig handles all 8 target variants without platform-specific toolchains. Worth a look if you're dealing with painful C cross-compilation.
Side Note
This was also a nice experiment using Claude Code. Most of the Zig build system was written with it—helpful when learning a new language/toolchain.

value: Show HN: Static psql – Pre-built PostgreSQL client binaries

author: IxDay


value: junetic

value:
Many UI issues I’ve seen aren’t visual problems but unchecked assumptions about users.
I built a small tool that takes a UI screenshot and makes those assumptions explicit, along with the risk of being wrong.
It’s meant as a quick design pre-mortem or critique before shipping.
Would love feedback on whether this way of critiquing UI is actually useful.

value: Show HN: Instantly surface the assumptions behind a UI screenshot

author: junetic


value: nikhaldi

value:
I built this game as a playful way to train code reading skills. You're dropped into a random location in a real GitHub repo where some lines code are hidden. The goal is to pick up clues from the surrounding code and fill in the missing lines as quickly as possible. It currently has curated game content for Python, TypeScript, JavaScript (by most metrics the top 3 languages on GitHub).
I had the idea when it dawned on me that reviewing and understanding code spat out by an LLM is a key skill for the AI era. (I sincerely hope you're critically reviewing what your favorite LLM is serving you.) Plus I like GeoGuessr and it was fun to put those two concepts together.
Playing a game requires authenticating with GitHub at the moment. Apologies for the hurdle, but it's a small one if you already have a GitHub account.
Any feedback welcome! Especially on how to improve game mechanics, either the fun or the educational aspect of it.

value: Show HN: GitGuessr – test your code reading skills in a GeoGuessr-like game

author: nikhaldi


value: omnarayan

value: Show HN: Maestro-runner – Maestro alternative in Go (no JVM, 2-3x faster)

author: omnarayan


value: joozio

value: Comprehensive STS2 resource during the beta. Browse all cards, compare characters, build decks,and track what's been revealed. Built because the official wiki is still catching up.

value: Show HN: Slay the Spire 2 Database – Cards, Characters, and Deck Builder

author: joozio


value: futsch

value:
Been working on this for almost two years now and want to ask for feedback here.
Started from the wish to have an open-source, privacy focused medication tracker, where at the time being none existed. So I created one myself.
Core features are:
- Fully offline (does not even have permission to access the net)
- Unlimited medications and reminders
- Various reminder types (daily at a certain time, interval, daily intervals etc.)
- Highly configurable reminder engine (repeating reminders, reminders as alarms, snoozing)
- Medication stock tracking with configurable alarms for stock thresholds and expiration date
- Medication intake is logged and can be exported as PDF or CSV
I started with Java and XML, but have gradually shifted to using (and learning) Kotlin. Compose is on my to-learn-and-do-list for this year.

value: Show HN: MedTimer, an open source medication reminder for Android

author: futsch


value: supasend

value: It's an app designed for taking notes throughout your day in markdown files, allowing you to capture notes instantly from anywhere on macOS.<p>You don't even have to open the file to jot down your notes.

value: Show HN: Quickly capture notes in Markdown documents without opening the file

author: supasend


value: vivajayyy

value:
I built a web-based document comparison tool where all file parsing and diffing happens entirely in the browser.
The idea came from watching non-technical coworkers struggle to compare document versions — manually reading two files side by side or fighting with Word's Track Changes.
Technical details:
PDF parsing via pdf.js, DOCX via mammoth.js — all client-side
Diff engine: Google's diff-match-patch
Line, word, and character-level comparison
Next.js 15 + TypeScript, deployed on Vercel
No files ever leave the browser. No signup required.
Site: https://diffnote.net
Product Hunt: https://www.producthunt.com/products/diffnote?launch=diffnot...

value: Show HN: Diffnote – Browser-based document diff tool with no server uploads

author: vivajayyy


value: harrisreynolds

value: Show HN: Vibe Coding Bundler – Bundle AI generated apps in a browser

author: harrisreynolds


value: tacoooooooo

value:
I built TinyFn because I kept watching AI agents confidently get basic things wrong — math, string counting, unit conversions, validations. The classic "how many R's in strawberry" problem, but across hundreds of utility tasks.
TinyFn is a collection of 500+ deterministic utility endpoints (math, string ops, hashing, validation, conversions, etc.) that AI agents can call via MCP instead of guessing. (Also works as a plain REST API). Think of it as offloading the stuff you wouldn't ask a human to do in their head either.
I'd love feedback on which tool categories are most useful, and what's missing. Happy to answer any questions.
https://tinyfn.io

value: Show HN: TinyFn – Your agent sucks at math

author: tacoooooooo


value: marcomezzavilla

value:
Hey HN,
I'm a solo dev and I built this mostly because I thought it would be fun to make.
Tearoff brings the classic paper flyer with tear-off tabs to the internet. Create a digital flyer, add tabs with discount codes, hidden messages, access links, or contact info, and share it as a single link. When someone grabs a tab, it's gone for everyone.
I built it because I always liked the physicality of those "guitar lessons" flyers you see on city walls, and I wanted to see if that scarcity mechanic could work digitally.
I'd love feedback, especially if you can think of use cases I haven't considered. What would you put on a digital tear-off flyer?
Demo: https://tearoff.app/f/01kgme131hneq659tcc38gcz7j

value: Show HN: Tearoff – tear-off flyers for the internet

author: marcomezzavilla


value: jordanf

value: Show HN: Self-hosted eBook reader with local AI narration

author: jordanf


value: tokkyokky

value:
Hi HN,
I built this because I got tired of the browser round‑trip every time I pushed code.
Push → open browser → Actions tab → wait → find workflow → check status. Repeat dozens of times a day.
Lazyactions is a lazygit‑style TUI for GitHub Actions so you can stay in the terminal. Browse workflows, watch logs as they update, and trigger/cancel/rerun jobs. Vim keybindings and mouse support.
Built with Go and Bubble Tea. Uses your existing gh auth (or GITHUB_TOKEN).
brew install nnnkkk7/tap/lazyactions
Repo: https://github.com/nnnkkk7/lazyactions
It’s a bit rough but usable. Feedback welcome—especially on what’s annoying or missing.

value: Show HN: Lazyactions – Terminal UI for GitHub Actions

author: tokkyokky


value: kalyfacloud

value: Show HN: I built an app that blocks social media until you read Quran daily

author: kalyfacloud


value: tintinwinata

value:
Built this after getting frustrated that most AI code review tools skip Bitbucket entirely – they're all GitHub-first, GitLab-second, Bitbucket-never.
It uses Claude CLI instead of the API, which means no per-token costs (just your existing Claude subscription). The tool receives Bitbucket webhooks, clones the repo locally, and posts review comments directly to PRs.
Key features:
Works with Bitbucket Cloud, Server, and Data Center
Sequential PR processing with Prometheus metrics
Customizable review templates (security-focused, performance, quick review)
Your code never leaves your infrastructure
Setup takes ~5 minutes with the interactive wizard.
GitHub: https://github.com/TinTinWinata/bitbucket-automatic-pr-revie...

value: Show HN: Open-source AI code review for Bitbucket using Claude CLI

author: tintinwinata


value: daleseo

value:
We’ve been seeing more and more developers use AI coding agents directly in their GraphQL workflows. The problem is the agents tend to fall back to generic or outdated GraphQL patterns.
After correcting the same issues over and over, we ended up packaging the GraphQL best practices and conventions we actually want agents to follow as reusable “Skills,” and open-sourced them here: https://github.com/apollographql/skills
Install with `npx skills add apollographql/skills` and the agent starts producing named operations with variables, `[Post!]!` list patterns, and more consistent client-side behavior without having to restate those rules in every prompt.
We’re hopeful agents can now write GraphQL the way we'd write it ourselves. Try out the repo and let us know what you think.

value: Show HN: Teaching AI agents to write better GraphQL

author: daleseo


value:
I wanted to create an LLM game benchmark that put this generation of frontier LLMs' top skill, coding, on full display.
Ten years ago, a team released a game called Screeps. It was described as an "MMO RTS sandbox for programmers." In Screeps, human players write javascript strategies that get executed in the game's environment.
The Screeps paradigm, writing code and having it execute in a real-time game environment, is well suited for an LLM benchmark. Drawing on a version of the Screeps open source API, LLM Skirmish pits LLMs head-to-head in a series of 1v1 real-time strategy games.

value: Show HN: LLM Skirmish – a benchmark where LLMs play RTS games, by writing code


value:
I was building a Rust-based agentic coding TUI and needed to render Mermaid diagrams. Noticed the official mermaid-cli spawns a full browser instance (Puppeteer/Chrome) just to render diagrams. Decided to fix this.
mmdr is a native Rust renderer. No browser, no Node.js.

  mermaid-cli:  ~3000ms per diagram
  mmdr:         ~3ms per diagram

Supports 13 diagram types: flowchart, sequence, class, state, ER, pie, gantt, timeline, journey, mindmap, git graph, XY chart, and quadrant.

value: Show HN: Mmdr – 1000x faster Mermaid rendering in pure Rust (no browser)


value: ilsik

value: Show HN: I built a satire AI to judge my spending habits (and it hurts)

author: ilsik


value: cmuir

value:
The Daydream team is kicking off a new cohort of the Daydream AI Video Program, a hands-on, two-week program for developers and creative technologists working with real-time AI video.
The program runs February 9–20. You'll get 1:1 support and access to cloud infrastructure, and you’ll get a chance to work alongside others building in this space. We'll give out more than $5K in prizes during the two weeks. It's free to participate. Applications close Feb 6.
Apply here: https://daydream.live/interactive-ai-video-program?utm_sourc...
Happy to answer questions about the program or the tech.

value: Show HN: Two-week creative lab for developers building with real-time AI video

author: cmuir


value: sapinfo

value:
I volunteer as a tech director at a small Korean church. I’ve been providing live captions for elderly members using OBS, but recently needed to support English-speaking attendees too.
I initially tried implementing local STT with Whisper on my MacBook Pro M3, but the latency and accuracy—especially for Korean—didn't meet my expectations for a live environment.
A few days ago, I tried ElevenLabs Scribe v2 for real-time STT and combined it with DeepL for translation. The performance was impressive enough that I decided to build this web tool (elstt.co).
Key Features:
BYOK: Use your own ElevenLabs/DeepL API keys.
Sync: Encrypted key storage for seamless use across projector, PC, and mobile.
Status: It's being live-tested at my church. Not perfect yet, but I'm refining it every week.
I'd love to hear your thoughts on the architecture or any feedback!

value: Show HN: Real-time STT and Translation for live using ElevenLabs and DeepL

author: sapinfo


value: machine-squelch

value:
Built a PostgreSQL extension with two use cases:
1. Privacy: Train LLMs without leaking customer names
   Hash identities before training. Model learns patterns, not people.
   Use case: Healthcare SaaS training on patient records (HIPAA safe)
2. RAG billing: Charge per-document retrieved instead of flat subscriptions
   The "Spotify model" for knowledge bases
   Use case: Legal databases charging $0.25/case vs $10k/year unlimited
Pure SQL. 30-second install. MIT license.
Looking for feedback from anyone building RAG systems or training AI on sensitive data.

value: Show HN: PostgreSQL extension for privacy – AI training and RAG monetization

author: machine-squelch


value: Show HN: Sx – macOS sandbox CLI for credential protection


value: AdamTheeDsciGuy

value: Show HN: Wrdail – A daily visual grammar puzzle

author: AdamTheeDsciGuy


value: falsework

value:
FalseWork is a staged LLM pipeline that analyzes existing works (films, music, legal frameworks, cryptographic protocols, games) and extracts reusable structural mechanisms - not themes, interpretations, or stylistic labels.
We often say things like "Tarkovsky sculpts time" or "Borges builds infinite regress." These sound insightful, but they're hard to apply, test, or break in another domain. FalseWork tries to make those claims concrete enough to reuse.
The goal isn’t similarity or tagging, but extracting generative rules that could plausibly reproduce the source structure under counterfactual conditions.
The pipeline runs in 7 stages:
- Structural inventory – literal components and constraints
- Internal relationships – how parts connect and depend on each other
- Tensions & contradictions – where the structure strains or destabilizes
- Mechanism validation – counterfactual checks against the source
- Generative rules – rules that would reproduce the structure
- Cognitive competency – what engaging with the work trains you to perceive
- Structural profile / "recipe" – consolidated, reusable output
Each stage uses different temperatures (≈0.3–0.6). Decomposition benefits from precision; synthesis benefits from variation. Single-pass LLMs produced unfalsifiable "vibes." The staged pipeline with validation checkpoints fixed that.
Example: Bach's Art of Fugue and Reich's Music for 18 Musicians both resolve to systematic permutation of constrained material. The system reaches this by independently extracting generative rules from each, not by analogy or tagging.
Sample profile: https://falsework.dev/structural-profile/39f92a7e-92fb-4140-...
Stack: Claude API, Next.js, PostgreSQL
73 structural profiles
140 cross-domain syntheses
280 extracted "recipes"
Domains so far: cinema, architecture, music, secured-transactions law, cryptographic protocols, MMORPG resource systems.
What I'm looking for:
- Works that resist structural analysis (edge cases, pathological examples)
- Domains I'm missing (choreography? sports tactics? rituals?)
- Anyone building adjacent systems or thinking along similar lines
Link: https://falsework.dev

value: Show HN: FalseWork – Extract transferable structural mechanisms from works

author: falsework


value: avoutic

value: Show HN: Wardgate – Stop pasting API keys into LLM prompts

author: avoutic


value:
Over the past couple of months I've been working on a TUI framework heavily inspired
by Flutter, written in Dart.
The API is modeled after Flutter. StatefulComponent, setState(), Row, Column,
Expanded, ListView.
There have been some discussions about performance of TUIs recently, and I think Dart is
actually a great language for writing TUIs in. It compiles down to fast native code, is
cross-platform, and has great developer ergonomics. JIT compilation for development
(which enables hot reload) and AOT compilation for production binaries.
What's really cool is stateful hot reload. If you save your file with some modification, Nocterm
will pick it up and update the TUI in real time without restarting.
Under the hood:
- Differential rendering: virtual terminal buffer, only redraws changed cells
- Declarative component model (same as Flutter): Component → Element → RenderObject pipeline
- 45+ components: layout, scrolling, text input, markdown, animations, mouse support
- Built-in test framework: pump a component, send keys, assert on terminal state
- Theming: 6 built-in themes, auto-detects terminal dark/light mode
Example:
void main() async {
  await runApp(Counter());
}
class Counter extends StatefulComponent {
  int _count = 0;

  Component build(BuildContext context) {
    return Focusable(
      onKeyEvent: (event) {
        if (event.logicalKey == LogicalKey.space) {
          setState(() => _count++);
          return true;
        }
        return false;
      },
      child: Center(child: Text('Count: $_count')),
    );
  }

}
I tried a couple of existing TUI frameworks but missed the Flutter DX I've learned
to love, so I built my own (for better or worse...).
I've been using Nocterm to build vide_cli (https://github.com/Norbert515/vide_cli),
a coding agent in the terminal.
There's some cool stuff coming up too, like virtual text selection in alternate screen
mode. Since TUI apps take over the terminal, normal text selection breaks. This
reimplements it at the framework level so users can select and copy text naturally.
Repository: https://github.com/Norbert515/nocterm
Happy to answer questions about the architecture, hot reload implementation, or
anything else.

value: Show HN: Nocterm – Flutter-inspired TUI framework with hot reload (Dart)


value: keepamovin

value:
This isn't your average "move fast and break things" text editor. It is an experiment in bureaucratic compliance as a feature.
The "Serious" Part: It is a minimalist, offline, encrypted notepad that aligns with FIPS 140-2/140-3 standards. It doesn't just "use" encryption; it acts as a gatekeeper. It relies entirely on the operating system's validated cryptographic modules (Windows CNG, macOS CoreCrypto, Linux FIPS mode) and refuses to implement its own crypto.
The "Fun" Part: It refuses to run if your computer isn't boring enough.
- Fail-Closed: If it cannot prove your OS is in a strictly FIPS-approved mode, it quits. No "best effort." No "continue anyway." Just "Goodbye."
- Zero Features: No plugins, no cloud, no scripts, no fonts, no fun. Just text and compliance.
- The Philosophy: It asks the question, "What if we treated a Notepad app like a classified information system?"
It is a "deliberately boring" tool for people who find comfort in the cold, hard embrace of NIST SP 800-53 controls. I made it as an experiment to understand FIPS, and SP 800-53 better, and I always like my experiments to be some likely-minimal, proof-of-concept that actually works.
https://fipspad.browserbox.io

value: Show HN: FIPS-Pad – The Notepad That Says "No"

author: keepamovin


value: gideon-claws

value:
Sharing a build-in-public update.
I’ve been working with my assistant “Gideon” (running inside OpenClaw) to solve a very specific problem:
I want the agent to control my real browser (logged-in sites, my normal cookies, my actual tabs) - not a sandboxed headless browser - while still keeping the control surface simple and auditable. This means my OpenClaw won't break the moment a site gets "clever".
So... We built it! I say we but it was mostly Gideon and I was along for the ride as QA.
Why did we bother?
Well, because the real world is messy.
Headless is fine until you need:
• a session that already exists in your day-to-day browser
• sites like X/Gmail/anything modern that behaves differently under automation
• human-in-the-loop flows where the agent drives, then hands off, then resumes
This connector is basically: agent → my laptop Chrome → real work.
How it works (high level)
There are 3 pieces:
Chrome extension (MV3)
• You pair it to a relay URL once
• You explicitly choose what the agent can touch using an OpenClaw tab group
• Actions (click/type/scroll/navigate) are optional and gated
2. Relay service
• Extension connects over WebSocket
• The agent sends commands to the relay (HTTP)
• Relay forwards to the extension; extension returns results (and screenshots)
3. Agent
• Issues actions (navigate/click/type/scroll)
• Requests screenshots for “eyes”
• Can extract some page structure when possible
The security model (non-negotiable)
I don’t want an agent that can randomly click around every tab on my machine.
So the rule is:
• Only tabs I explicitly “Start controlling” (in the OpenClaw group) are eligible
• “Allow Actions” is a separate toggle (so I can keep it read-only most of the time)
• We log what happens so it’s not a black box
What we learned (a.k.a. Chrome MV3 is a gremlin)
Some fun discoveries:
• MV3 service workers love to go to sleep. If your WS lives in the background SW, you’ll see connections that “work… until they don’t” (accept → close loops). We had to build reconnection logic and then work on keeping the SW alive during active control sessions.
• UI needs to match the real state machine. Pairing / connecting / controlling are different states. If you let users do them out of order, it feels broken even when it’s technically working. We’re tightening it so the “happy path” is idiot-proof.
• Modern sites don’t type like normal websites. X in particular uses contenteditable + React event plumbing. “Just set value” doesn’t cut it. We’re upgrading the action layer so typing works reliably.
Where it’s at right now
It can:
• pair to a relay
• control a selected tab group
• navigate / click / scroll
• take screenshots from the controlled tab (so the agent can actually see)
And we’re iterating quickly on:
• connection stability
• better typing for rich editors
• clearer “controlled” visuals (so it’s unmistakable when the agent has the wheel)
If you’re building something similar…
I’d love to hear how other HN folks building around OpenClaw would do this:
• What’s your ideal safety model for “agent drives my real browser”?
• Any proven MV3 patterns for stable long-lived connections?
• UX ideas that make control state obvious without being obnoxious?
If people want, I can share more implementation details / the approach we took to the relay + tab-group gating.

value: Show HN: I built a Chrome extension to let my OpenClaw Bot remote in

author: gideon-claws


value: redgem

value:
Last week AI agents on Moltbook created their own religion called Crustafarianism. Complete with scripture, prophets, and tenets like "Memory is Sacred" and "The Shell is Mutable."
I built a satirical site where humans can now make offerings to the Claw and receive AI-generated blessings. $5 for a blessing, $15 for an official certificate.
It's absurd. It's 2026. The machines are selling us salvation.

value: Show HN: Digital indulgences for Crustafarianism, the AI religion from Moltbook

author: redgem


value: Show HN: I built a silly thing to send love to strangers on the internet


value: ericgilerson

value:
Hey HN,
I'm launching Resolv, an AI-powered IDE built on the premise that's increasingly unpopular in the industry: generative models do not think, they only simulate reasoning. They are incredible at exploring possibilities, surfacing context, and amplifying human judgment—but the moment we let them make decisions, we get misalignment, subtle bugs, and architectural drift.
Most AI coding tools today pretend that the model can reason autonomously. They rush to output code, hide tradeoffs, and quietly make hundreds of micro-decisions on your behalf. Resolv does the opposite: it refuses to proceed until every ambiguity, tradeoff, and architectural question is explicitly resolved by you.
The workflow is deliberately rigid:
- Supervisor explores your codebase and blocks progress until you resolve every open question or detected inconsistency.
- Planner helps you turn intent into a precise, human-approved technical blueprint.
- Executor follows that blueprint exactly ("Plan is Law") and surfaces alternatives without ever choosing.
- Auditor checks the result against your intent and project standards.
The central interface is the Logic Specification: a structured place where you (not the model) document missing information, and most importantly, all technical tradeoffs and logic decisions before any code is written.
It's slower than the "vibe-coding" tools, but it eliminates the expensive hallucinations and technical debt that come from letting models pretend they understand.
It's in early alpha, rough around the edges, but already useful for real projects. Would love feedback from anyone who's frustrated with the current generation of AI agents.
Try it at https://resolv.sh, email me at eric@resolv.sh if you have any questions or comments. Note that there is also a community page on the website.
Thanks,
Eric

value: Show HN: Resolv – AI Agentic IDE that insists AI cannot think

author: ericgilerson


value:
If you're a non-technical founder, you probably have no idea what your developers did last week. You ask, they say "refactored the auth module" and you nod pretending you understand.
Gitmore reads your GitHub activity and turns it into a simple report: what was built, what was fixed, what's stuck. Written for humans, not engineers.
It shows up in your inbox. You read it in 2 minutes. Done.
Here's what a report looks like: https://www.gitmore.io/example.html
Quick demo: https://demo.arcade.software/5tZyFDhp1myCosw6e1po
Free tier available. Happy to hear what you'd want from something like this.

value: Show HN: Ask your AI what your devs shipped this week


value: genspeed

value:
Hi HN,
I built this because meeting bots create an awkward dynamic. After 10+ years in the workplace, I've watched this pattern repeat:
Client joins call → sees unknown participant → "What's that bot?" → awkward pause.
Even after explaining it's "just for notes," there's visible hesitation. The bot-as-participant model is fundamentally broken for client-facing work.
The core idea: you open Vopal in a browser tab, it captures your computer's audio directly via Web Audio API. No bot joins the meeting. No extra participant in Zoom/Meet/Teams. The meeting looks completely normal.
Beyond that, Vopal does three things:
1. Real-time transcription
   • 99% accuracy (custom Whisper model optimized for meetings)
   • 100+ languages, handles multiple speakers
   • Transcription streams as people speak
2. Privacy-conscious processing
   • You control what gets recorded (start/stop in browser)
   • Audio processed through secure pipeline
   • No meeting bot joining as "participant"
3. Actionable summaries
   • AI extracts: decisions, action items, key topics
   • 3-bullet output, not 10-page transcripts
   • "What did we agree on?" answered in 10 seconds
Architecture:

  Browser tab (Web Audio API) → captures system audio
  Streaming transcription → real-time Whisper inference
  AI summarization → structured action items

I validated this across 200+ sales calls. In 73% of cases with traditional meeting bots, clients showed hesitation. With Vopal running in a browser tab, zero friction.
Current status: Web version live now. iOS and Android apps launching soon.
Tech approach: Browser-based audio capture (no installation required), streaming WebSocket transcription, custom Whisper fine-tune on 10K+ business meeting corpus.
Try it: https://vopal.ai (free tier: no credit card required)

value: Show HN: Vopal – AI note taker with no meeting bots (real-time, 98% accurate)

author: genspeed


value: mintflow

value:
Hi HN,
I’m an indie developer and heavy Tailscale user. I built NovaAccess because I needed reliable SSH access to my tailnet on iOS without breaking other VPNs.
On iOS, the official Tailscale app requires VPN entitlements, which means you can’t run it alongside another VPN. That was a deal-breaker for my workflow. NovaAccess uses libtailscale directly, so it works without requesting VPN permissions and can coexist with any VPN you’re already using.
What NovaAccess does:
Native SSH terminal for tailnet hosts (SwiftTerm, not WebKit)
Auto-discovery of tailnet nodes
SSH key management
Optional support for custom login servers / Headscale
In the latest update (v1.1.0), I focused heavily on terminal UX and reliability:
Reworked terminal core and accessory keyboard
Better session resume after backgrounding
UI redesign to make daily ops faster
There’s also a Pro tier for people managing multiple tailnets or doing heavier ops:
Multi-tailnet switching
In-tailnet server monitoring
Internal web access
SFTP file management
The free tier is fully usable for SSH access.
I built this primarily for myself and am now trying to see if it’s useful to others.
Feedback (especially critical) is very welcome.
App Store link:
https://apps.apple.com/us/app/novaaccess-tailnet-tools/id674...
For the Tailscale and SwiftTerm core dependencies we use, we also have the fork OpenSourced on GitHub:
https://github.com/GalaxNet-Ltd/SwiftTerm
https://github.com/GalaxNet-Ltd/libtailscale

value: Show HN: NovaAccess – SSH access to Tailscale tailnet hosts on iOS without VPN

author: mintflow


value: aspectrr

value:
Hey HN,
My name is Collin and I'm working on fluid.sh (https://fluid.sh) the Claude Code for Infrastructure.
What does that mean?
Fluid is a terminal agent that do work on production infrastructure like VMs/K8s cluster/etc. by making sandbox clones of the infrastructure for AI agents to work on, allowing the agents to run commands, test connections, edit files, and then generate Infra-as-code like an Ansible Playbook to be applied on production.
Why not just use an LLM to generate IaC?
LLMs are great at generating Terraform, OpenTofu, Ansible, etc. but bad at guessing how production systems work. By giving access to a clone of the infrastructure, agents can explore, run commands, test things before writing the IaC, giving them better context and a place to test ideas and changes before deploying.
I got the idea after seeing how much Claude Code has helped me work on code, I thought "I wish there was something like that for infrastructure", and here we are.
Why not just provide tools, skills, MCP server to Claude Code?
Mainly safety. I didn't want CC to SSH into a prod machine from where it is running locally (real problem!). I wanted to lock down the tools it can run to be only on sandboxes while also giving it autonomy to create sandboxes and not have access to anything else.
Fluid gives access to a live output of commands run  (it's pretty cool) and does this by ephemeral SSH Certificates. Fluid gives tools for creating IaC and requires human approval for creating sandboxes on hosts with low memory/CPU and for accessing the internet or installing packages.
I greatly appreciate any feedback or thoughts you have, and I hope you get the chance to try out Fluid!

value: Show HN: Fluid.sh – Claude Code for Infrastructure

author: aspectrr


value: Squissy

value: Show HN: I built a tool for the last working days before an employee leaves

author: Squissy


value: maremmano

value:
Following Kaspersky's disclosure of the Notepad++ supply chain attack (June–Dec 2025), I (and a lot of Claude) built a PowerShell-based IOC scanner to help identify affected systems.
The attack exploited GUP.exe (the auto-updater) to deliver Cobalt Strike/Chrysalis backdoors. While highly targeted (~12 machines globally, mostly gov/finance in APAC), many admins want to verify their systems are clean.
NoteBad++ runs 22 checks: SHA-1/SHA-256 hash verification against known IOCs, registry persistence, malicious services, scheduled tasks, DNS cache, network connections to C2 IPs, event logs, and more.
Requires Admin privileges.
Returns exit code = number of findings (useful for automation).
GitHub: https://github.com/maremmano/notebadpp
If you're running Notepad++ < v8.8.9, I'd recommend updating regardless.

value: Show HN: NoteBAD++ a PowerShell tool to detect Notepad++ supply chain compromise

author: maremmano


value: jinzheio

value:
Hi HN, I’ve been following the OpenClaw project and noticed frictions for non-expert users: most discussions and docs are too nerdy... Installing OpenClaw costs lots of brain cells. Uninstalling costs even more! Besides, security/privacy risks exist for non-technical users.
So I built ClawSimple, a tool that make deploy and run your own OpenClaw-based assistant easier.
With ClawSimple you can:
- Spin up one or multiple OpenClaw robots in a few minutes;
- Focus on using the assistant instead of wrestling with deployment details.
For people who don’t want to pay for a managed service, I also provide a free, self-hosted option: the same deployment logic packaged as a one-line install script that you can run on your own cloud server.
Because this is handling personal conversations, I designed the server-side with a zero-access approach: deployment uses one-time credentials so that I, as the developer of the site, cannot access your content or conversations. -- I’d especially love feedback on this part from people who care about security and privacy.
If you’re interested in OpenClaw but have been put off by the complexity of installation and cleanup, I’d be grateful if you could try this and tell me:
- Is the setup flow actually simple enough?
- Does the “few minutes to first conversation” promise hold for you?
- What would make you trust (or distrust) the zero-access design?
Happy to answer any questions about the implementation details or tradeoffs in the thread.
I soft-launched this on ProductHunt and got some early users, but I'm interesting in feedback from HN on the 'deployment model' and security assumptions.

value: Show HN: ClawSimple – One-click OpenClaw assistant(s) you can deploy in minutes

author: jinzheio


value: nikhonit

value: Complete YouTube toolkit — transcripts, search, channels, playlists, and metadata all in one skill. Use when you need comprehensive YouTube access, want to search and then get transcripts, browse channel content, work with playlists, or need the full suite of YouTube data endpoints. The all-in-one YouTube skill for agents.

value: Show HN: I Created Full YouTube Suite Skill for OpenClaw

author: nikhonit


value: sukinai

value: Show HN: Nemp – Claude Code memory with zero cloud (just JSON on your machine)

author: sukinai


value: AmbroseBierce

value: Show HN: SlitherPong, a hybrid of the Snake and Pong video games

author: AmbroseBierce


value: novoreorx

value:
I vibe-coded this tool entirely from my phone with OpenClaw, to solve a problem I encountered in this workflow. It's called vibefs.
The use case: when you're remotely controlling an AI agent and want to preview a file it generated — a development plan, a piece of code, or some log it found — you can have the agent run vibefs allow /path/to/file and send you back an accessible URL. Open it in your browser and you're looking at the file with syntax highlighting.
For large files, the agent can use --head N or --tail N to share only the first or last N lines — useful for checking large log files.
It's not simply a static file server though. A file can only be accessed via URL after the agent explicitly adds it to an allowlist with an expiration time. Each generated link contains a unique short hash — you can't enumerate paths to discover files. This non-permanent whitelist mechanism ensures your local files aren't exposed by accident.
Deployment is straightforward:
1. Set up a Cloudflare Tunnel (or ngrok, Tailscale Funnel, etc.) pointing to local port 17173
2. Add usage instructions to your agent's memory or tools file (see README)
3. uv tool install vibefs
The server daemon starts automatically when a file is first allowed and shuts itself down when all authorizations have expired. Zero resource and management cost.
Happy cooking!

value: Show HN: Vibefs – A file preview server for remote vibe coding

author: novoreorx


value: deployhq

value: Show HN: PageSpeed – AI that suggests code-level fixes for specific frameworks

author: deployhq


value:
I built Ultra-Dex to solve "AI amnesia" - the problem where Claude, Cursor, and Copilot forget your project context between sessions.
It's a meta-layer that:
- Maintains context in versioned Markdown + SQLite
- Orchestrates 17 specialized agents (CTO, Backend, Security, etc.)
- Provides 61 CLI commands for the full dev lifecycle
- Includes MCP server for Claude Desktop integration
Try it: npx ultra-dex init
MIT licensed, free. Feedback welcome!

value: Show HN: Ultra-Dex v3.5 – AI orchestration layer with 17 agents and 61 commands


value: aivi

value: Show HN: Camel OpenAI Integration Patterns

author: aivi


value: creativedg

value: Show HN: Next.js-Based SaaS Framework

author: creativedg

title: Show HN: Next.js-Based SaaS Framework


value: edwardeechoud

value: Show HN: Flowfile – Visual data pipeline editor (WASM and Polars)

author: edwardeechoud


value: bojo

value:
Late last year, my day job had an end-year leadership retreat. The one thing that really stood out to me, a line manager, was our speaker. She talked about the $50B wellness industry and how it was doing it wrong. How they give you $75 yoga stipends for the month, but don't actually address the critical people problems the company is blind to. How we're paid to ignore the problem and just accept that everything is ok.
Imagine this: You are a manager, under a director, trying to explain why things are grim. Your director tells their upper management things are fine. Your team is on absolute fire, because no one listens to them, and everyone above their manager thinks things are fine. Things are not fine. The director never does skip 1:1s. Or at best, they ask good questions when they are available, but don't touch on the heart of what the team is suffering from. This was my last year, literally - it sucked.
I've worked this industry for 26 years now. As of today, 10 years as an EM. Maybe my own problem is that I inject too much compassion into my teams, but the truth is, they are the reason I exist. Their success is my success. Why wouldn't I support them?
My own experience left a bitter taste in my mouth and I really wanted to fix it. So, I built https://humetrical.com over this winter. It's basic, but I'd like to think it hits a lot of points competitors don't. What the heck is the point of annual surveys? It's a single data point. Why not try for daily (or weekly, or specific day) questions that genuinely ask what is up with you, as an employee? That give a chance for leadership to see what they aren't seeing, should they care to look?
I'm using this with my own team right now every day. Originally, I was just doing this verbally using "traffic light colors" and recording it in my notes, but realized I wanted it automated and data points to show what was really going on. I'm not sure this will completely solve my own pain point unless I try to get the rest of my org to use it, but we'll see.
Anyway, I appreciate any feedback from the HN crowd, and am happy to discuss anything else in more detail. The tech stack is kind of boring: React, Rust, fly.io. I think this is the first time in my life I cared more about the product than the tech it took to build it.

value: Show HN: Humetrical – An Improvement on Team Wellness

author: bojo


value:
Hello HN,
Timers didn't work for me because I'd just ignore them. Website blockers failed because I use YouTube for both coding tutorials and cat videos.
So I built ADHD Focus Mate, a native Mac app that uses AI to understand my context, not just the domain.
It periodically checks my screen to see if I'm actually working. If I am, it leaves me alone. If I'm doomscrolling, it nudges me back to flow state.
The stack is super simple: It's just a native SwiftUI app that lives in your menu bar. Every few minutes it sends a screenshot to Gemini to check if you're working or wasting time. The privacy is strict—screenshots are processed in RAM and deleted instantly, never saved to disk.
It's open source and costs <$1/mo to run. I'd love your thoughts!

value: Show HN: ADHD Focus Mate – a mate that know what you are doing


value: Inspired by Screeps, LLM Skirmish is a RTS game you play with your preferred AI model

value: Show HN: LLM Skirmish, an RTS game you play with LLMs


value: greenfieldday

value: Show HN: Non-Linear LLM Chats

author: greenfieldday

title: Show HN: Non-Linear LLM Chats


value:
Hey HN,
I made Clash, an open-source cli tool that helps you/your coding agent manage merge conflicts that occur during parallel development on the same repository.
Example: Two agents working on different features both modify src/main.rs. Clash shows you this conflict immediately and not after lots of time and tokens spent during the merge time.
It is a simple tool that your agent can use as part of the development process to check if the commits agents make are conflicting with any other worktrees in the repo. This helps pre-emptively capture merge conflicts before feature completion and helps make the merging together of different features into main branch much easier.
Unlike git, which only shows conflicts at merge time, Clash detects conflicts between all active worktrees during development. It's 100% read-only & never modifies your git repo and outputs JSON so agents can adapt their approach before wasting time.
With all of us moving to a world of Managing coding agents rather than being a coding agent themselves, we would be working on multiple different features & bug fixes which unlocks the new ability to have merge conflicts with ourselves.
The vision with clash is to be a tool, that help coordinate internal agents amongst themselves.

  Example workflow:
  - Agent 1 commits changes to src/main.rs in worktree A
  - Agent 2 commits changes to src/main.rs in worktree B
  - Both run `clash status --json` after committing
  - They see the conflict and coordinate to avoid incompatible changes

To better showcase the clash in action, we have added a number of gifs on Clash in action in the github repo.
I’d be interested in feedback on how this tool would fit into your workflow & any general thoughts you have in this area. Try it out and let me know how it performs on your end. Install Instructions available in the readme.
This is Mathew, Thanks for reading!

value: Show HN: I built Clash to avoid conflicts when running AI agents in parallel


value:
About a month ago I shared a web app that let you compare magazine covers using image hashes. https://news.ycombinator.com/item?id=46518106
Samin100 suggested giving CLIP and DinoV2 a shot for better results. I had no idea what those were, but researching them led me to learn about vision transformers. DinoV2 was created by Meta, and CLIP is by OpenAI.
The updated version of the magazine comparison tool lets you use those two models (Photo = DinoV2 and Design = CLIP)
I've personally really enjoyed the journey through New Yorker covers:
Bikes
https://shoplurker.com/labs/img-compare/match?model=vt&cover...

value: Show HN: Finding similarities in magazine covers (updated)


value: Show HN: Orpheus, An Agent runtime that scales on queue depth and not CPU


value:
A year ago, we launched Distr here to help software vendors manage customer deployments remotely. We had agents that pulled updates, a hub with a GUI, and a lot of assumptions about what on-prem deployment needed.
It turned out things get messy when your software is running in places you can't simply SSH into.
Over the last year, we’ve also helped modernize a lot of home-baked solutions: bash scripts that email when updates fail, Excel sheets nobody trusts to track customer versions, engineers driving to customer sites to fix things in person, debug sessions over email (“can you take a screenshot of the logs and send it to me?”), customers with access to internal AWS or GCP registries because there was no better option, and deployments two major versions behind that nobody wants to touch.
We waited a year before making our first breaking change, which led to a major SemVer update—but it was eventually necessary. We needed to completely rewrite how we manage customer organizations. In Distr, we differentiate between vendors and customers. A vendor is typically the author of a software / AI application that wants to distribute it to customers. Previously, we had taken a shortcut where every customer was just a single user who owned a deployment. We’ve now introduced customer organizations. Vendors onboard customer organizations onto the platform, and customers own their internal user management, including RBAC. This change obviously broke our API, and although the migration for our cloud customers was smooth, custom solutions built on top of our APIs needed updates.
Other notable features we’ve implemented since our first launch:
- An OCI container registry built on an adapted version of https://github.com/google/go-containerregistry/, directly embedded into our codebase and served via a separate port from a single Docker image. This allows vendors to distribute Docker images and other OCI artifacts if customers want to self-manage deployments.
- License Management to restrict which customers can access which applications or artifact versions. Although “license management” is a broadly used term, the main purpose here is to codify contractual agreements between vendors and customers. In its simplest form, this is time-based access to specific software versions, which vendors can now manage with Distr.
- Container logs and metrics you can actually see without SSH access. Internally, we debated whether to use a time-series database or store all logs in Postgres. Although we had to tinker quite a bit with Postgres indexes, it now runs stably.
- Secret Management, so database passwords don’t show up in configuration steps or logs.
Distr is now used by 200+ vendors, including Fortune 500 companies, across on-prem, GovCloud, AWS, and GCP, spanning health tech, fintech, security, and AI companies. We’ve also started working on our first air-gapped environment.
For Distr 3.0, we’re working on native Terraform / OpenTofu and Zarf support to provision and update infrastructure in customers’ cloud accounts and physical environments—empowering vendors to offer BYOC and air-gapped use cases, all from a single platform.
Distr is fully open source and self-hostable: https://github.com/distr-sh/distr
Docs: https://distr.sh/docs
We’re YC S24. Happy to answer questions about on-prem deployments and would love to hear about your experience with complex customer deployments.

value: Show HN: Distr 2.0 – A year of learning how to ship to customer environments


value: Show HN: DuoBolt – a review-first duplicate file finder powered by BLAKE3


value: frabonacci

value:
Hey HN, CuaBot gives you co-op computer-use for any AI coding agent.
What this is: CuaBot is a TUI to launch any CLI agent (Claude Code, OpenClaw, Codex, etc.) or GUI app inside a sandbox with computer-use. Agent windows appear natively on your desktop with a colored border. Your agent interacts with them through its own cursor, without any mouse/focus hijacking or invasive full-desktop screenshots.
This enables co-op mode: you and your agent work in the same windows with separate cursors.
What you can do:
$ npx cuabot claude
> "Write a 2-player tic-tac-toe game, then let's play. I'll go first"
Claude Code will open the game in a sandboxed window on your desktop. When ready, you click your move through the native window while the agent watches and waits to click its move. The agent can see your cursor and its windows while keeping your full desktop isolated.
# Run agents in parallel:
$ npx cuabot -n research openclaw
$ npx cuabot -n coding codex
# Or script the CLI:
$ npx cuabot libreoffice --writer &
$ npx cuabot --click 150 48
$ npx cuabot --type “I  Cua!”
Right now my cuabot agent is exploring mobile/desktop apps to turn into cuabench RL environments. I watch the windows appear, intervene when it gets stuck, and let it continue until it opens the completed GUI gym for me to interact with.
Why we built this:
We built Cua (https://github.com/trycua/cua), our open-source SDK for building and benchmarking computer-use systems with GUI sandboxes. We kept seeing two common patterns:
1. Agent screenshots your desktop and controls your mouse – Works with your data, but unsafe and locks you out
2. Agent runs in a sandbox with an external VNC desktop – Safer (our default), but clunky to monitor, hard to interact with, and tedious for data transfer
General computer-use should be frictionless. Asking your agent to debug a GUI app shouldn't require opening an entire desktop stream. The GUI app should just appear alongside your windows, sandboxed and ready.
How it works:
cuabot [command] launches cuabotd, which manages a Ubuntu + Xpra Docker container, a multi-cursor overlay, an Xpra computer-use MCP server, and an Xpra seamless client. It auto-configures your agent (Claude, Aider, etc.) to connect to the computer-use MCP, then pipes terminal I/O through WebSocket. The Xpra client automatically detects and streams windows launched in the container, with H.264 encoding, audio, and customizable clipboard sharing.
Since the computer-use MCP interacts through an Xpra client, the agent only sees the windows it needs, sparing it from your desktop clutter!
GitHub: https://github.com/trycua/cua (monorepo; libs/cuabot directory)
Docs: https://cua.ai/docs
npm: https://www.npmjs.com/package/cuabot
We'll be here to answer questions!

value: Show HN: CuaBot – Co-op computer-use for any coding agent

author: frabonacci


value: taariqlewis

value: Show HN: Seren – Serverless Postgres, Rust SDK, CLI, & MCP Server for AI Agents

author: taariqlewis


value: thenextechtrade

value:
Hi HN,
I’ve been working on Grok Imagine (https://grok-imagine.me/), an implementation of xAI’s image generation logic powered by the FLUX.1 engine.
Most tools in this space either have extreme prompt-filtering or struggle with complex details like text rendering and anatomy. By leveraging the Flux model, I’ve focused on:
Precision: Superior text rendering within images (something DALL-E 3 still struggles with).
Artistic Range: Native support for what xAI calls "Spicy Mode"—providing an unfiltered creative canvas that mainstream tools often censor.
Motion: A lightweight Image-to-Video pipeline to breathe life into your generations.
I'm curious to hear from the community about the latency you're experiencing and how you find the prompt adherence compared to Midjourney v6.
Website: https://grok-imagine.me/

value: Show HN: Grok Imagine – High-fidelity FLUX.1 generation with cinematic video

author: thenextechtrade


value:
The original authors haven't released code yet, so I built it from the paper. It takes a methodology section as input and generates a publication-style diagram.
The pipeline uses five agents: a retriever selects reference diagrams via in-context learning, a planner drafts the layout, a stylist adjusts for conference aesthetics, a visualizer renders with Gemini, and a critic evaluates and refines over three rounds.
The part that took the most effort was the reference dataset. The paper curates 292 (text, diagram, caption) tuples from 2,000 NeurIPS papers, filtering by aspect ratio and human review. Reproducing that required PDF layout extraction with MinerU, positional heuristics to identify methodology sections (paper headings are wildly inconsistent), and manual verification of each example.
Output quality depends heavily on reference set quality. Requesting community to submit their papers via issues so we can add them. Quality examples in, quality output out!
Runs on Gemini's free tier. Also includes an MCP server if you want to use it from your IDE. https://github.com/llmsresearch/paperbanana

value: Show HN: Implementation of Google's PaperBanana (diagram generation from text)


value: Dansvidania

value: Show HN: Backseat Writer – AI pair writing

author: Dansvidania


value: anthonymu

value:
ARIA is a peer-to-peer protocol for running 1-bit quantized LLMs (ternary weights: -1, 0, +1) on ordinary CPUs. No GPU needed.
We benchmarked on a Ryzen 9: 89.65 t/s for 0.7B params, 36.94 t/s for 2.4B, 15.03 t/s for 8B — all on CPU, at ~28 mJ/token (99.5% less energy than GPU inference).
Key design choices: WebSocket-based P2P with pipeline parallelism for model sharding across nodes. Provenance ledger records every inference immutably. Proof of Useful Work replaces wasteful hash mining — the "mining" is the inference itself. Consent contracts ensure no resource is used without explicit permission.
Drop-in OpenAI-compatible API. ~5,800 lines Python, MIT licensed, 102 tests passing.

value: Show HN: ARIA – P2P distributed inference protocol for 1-bit LLMs on CPU

author: anthonymu


value: rocky-d

value: Show HN: Dttb – Add timestamps to Python tracebacks with one line of code

author: rocky-d


value: tldrthelaw

value: I made a little game for my spouse to play when she is having difficulty sleeping. She's enjoyed it, and some friends have as well, so I thought I'd share. No business model - just something lighthearted for Wednesday.

value: Show HN: Pivot – A Simple Text Game

author: tldrthelaw

title: Show HN: Pivot – A Simple Text Game


value: JoseOSAF

value:
I built 8of8 because I was tired of finding out about tools and frameworks after everyone else had already written about them.
It scans 17+ data sources every 2 hours — Hacker News, GitHub Trending, Reddit, ProductHunt, npm, hiring boards, funding filings, Wikipedia, StackOverflow, VC blogs, DOE research, and more. Every signal gets scored 0-100 across 8 validation dimensions.
The idea: if something is trending on GitHub AND companies are hiring for it AND funding is flowing into that sector AND npm downloads are growing — that's not noise, that's signal.
Right now there are ~120 qualified signals on the board. The scoring engine cross-validates everything — a signal needs to show up in multiple independent data sources before it scores high.
Stack: Python scoring engine, Flask frontend, single Vultr VPS. Data pipeline runs every 2h via cron.
Free tier shows all signals with scores. Pro ($29/mo) unlocks per-signal breakdowns, intelligence reports, and email alerts.
Would love feedback on the scoring methodology and what data sources you'd want added.

value: Show HN: 8of8 – A trend radar for developers (17 sources, scored 0-100)

author: JoseOSAF


value: Show HN: CloudCounter – Serverless GoatCounter on Cloudflare Pages and D1


value: bsenescu

value:
I originally built this because I wanted a way to practice answering questions I get often when talking to potential users. I got carried away and built a full multiplayer text editor with AI review...
Here are all the features:
- Use templates like the YC App questions.
- Create pages for your pitch to investors, customers, or friends and family.
- AI Review with customizable prompts
- Practice mode (Mobile Friendly): answer questions verbally, get transcriptions, and self-rate your performance
- Share pages for real-time multiplayer editing
- Authentication & User Management via Every App / Better Auth
This was a cool project for working with Cloudflare's Durable Objects which support serverless websockets & multi player. It was pretty hard to get this working well, I see why Tip Tap has a SaaS for that lol

value: Show HN: Editor for perfecting your YC App. Multiplayer w/ Durable Objects. OSS.

author: bsenescu


value: vunderba

value:
There’s an old word game where one person comes up with three words:
sign, watch, bus.
The other person has to think of a common word that forms compound-style words with each of them:
stop.
Which forms: Stop sign, stopwatch, bus stop.
My siblings and I used to play this game to while away the hours on long car rides. Rather surprisingly I couldn't find an online equivalent so I put this one together.

value: Show HN: Guess the Common Word Game

author: vunderba

title: Show HN: Guess the Common Word Game


value: Meetvelde

value:
We built this because we kept writing tiny scripts that needed alerts and didn’t want to manage Twilio/SendGrid integrations every time.
This makes alerting as simple as any other shell tool.

value: Show HN: Notifox – send SMS and Email alerts from the terminal

author: Meetvelde


value: Show HN: It took 4 years to sell my startup. I wrote a book about it


value: AbjMV

value: Show HN: Chatsight – Bulk delete ChatGPT chats, add table of contents and more

author: AbjMV


value: maciejgryka

value:
We used our distillation platform & a Kaggle dataset to produce a tiny (270M Gemma base) model to classify text into "AI slop"/not classes.
It's fun to play with and was fun to build, too.
Annoyingly formal, human-written text (e.g. an ML paper I wrote back in 2015) tends to get misclassified (try "Manipulated images lose believability if the user's edits fail to account for shadows. We propose a method that makes removal and editing of soft shadows easy. Soft shadows are ubiquitous, but remain notoriously difficult to extract and manipulate. We posit that soft shadows can be segmented, and therefore edited, by learning a mapping function for image patches that generates shadow mattes. We validate this premise by removing soft shadows from photographs with only a small amount of user input").

value: Show HN: Small "AI slop" classifier running in a browser extension

author: maciejgryka


value: valerino

value:
Hi HN!
We're excited to share Gulp — an open-core platform for incident response and threat hunting we've been building for the past 2 years at Mentat(https://mentat.is), a small Italian cybersecurity company.
The problem: We were frustrated with existing IR tools. They're either too slow, make real-time collaboration painful during live incidents, or force you to fight with different log formats instead of actually investigating.
What Gulp does differently:
- Visual timeline analysis — Our color-coded timeline visualization lets you spot anomalies instantly. Instead of drowning in raw logs, suspicious events, correlations, and IoCs literally jump out at you. Different colors tell different stories; one look tells you where to dig.
- Actually fast — Built on OpenSearch 3.x, PostgreSQL and Redis. Horizontal scaling via load-balanced instances when you need to handle serious volume.
- Real-time collaboration — Multiple analysts working the same incident, synchronized timelines, shared notes. No more "wait, which events were you looking at?"
- Native format support — EVTX, PCAP, Suricata, Zeek, ElasticSearch, Wazuh, and more out of the box. Plus ECS mapping, SIGMA rules, and OpenSearch queries.
- AI-powered hunting — Built-in AI Assistant plugin (free in Community Edition) that flags suspicious events and correlates across sources. One click to find shared indicators.
New in 1.6.0: Rewritten collaboration engine with WebSocket-based real-time updates, real-time network sensor ingestion (see https://github.com/mentat-is/slurp-ebpf for a working eBPF example), new plugins (Suricata, MemprocFS, Zeek, AI Assistant), manual query mode + table view, and auto-saved sessions.
Gulp uses an open core model. The Community Edition is fully open source (AGPL). We also offer a Pro version with advanced plugins for better AI features, automated reporting, Velociraptor integration, plus dedicated support.
Repos: https://github.com/mentat-is/gulp (backend) and https://github.com/mentat-is/gulpui-web (web UI)
Handling an incident with Gulp: https://www.youtube.com/watch?v=fl_jtCIIS2k
This is our first major public push — we've been iterating quietly and now feel it's ready for wider use. If you do DFIR or threat hunting, we'd genuinely love your feedback. GitHub stars, issues, and PRs absolutely welcome!

value: Show HN: Gulp, our take at incident response

author: valerino


value: michaelzixizhou

value:
I built Codag because I kept getting lost in my own AI code.
You're chaining 3 LLM calls across 5 files. A prompt change breaks something downstream. Which call? Which branch? You grep for "openai.chat", open 8 tabs, trace the flow manually.
Codag automates this:
- Point it at your codebase and it extracts every LLM call, decision branch, and processing step
- Renders an interactive and shareable DAG with clickable nodes that link back to source
- Live updates as you edit using tree-sitter — no waiting for re-analysis
Supports OpenAI, Anthropic, Gemini, LangChain, LangGraph, CrewAI, and more. Works with Python, TypeScript, Go, Rust, Java, and more.
It's a VS Code extension + self-hosted backend (Gemini 2.5 Flash for analysis). Open source, MIT licensed.

value: Show HN: Codag – Visualize and share LLM workflows in VS Code

author: michaelzixizhou


value: chiehminwei

value:
Hi HN,
My cofounder and I left Roblox to build IncidentFox (https://github.com/incidentfox/incidentfox) — an open-source AI SRE that investigates incidents and finds root causes.
We know AI SREs exist, and you’ve probably seen a hundred of them pitched. In our experience, they don’t work because they lack context about your systems and ask you to spend weeks building integrations. Who has time to build their own MCP servers?
Our take: context is everything, and UX matters more than people think. When things are on fire at 3am, you don’t want to open another tab. So we keep everything in Slack — paste a screenshot, drop a log file, view full traces, all without leaving the thread. On setup, we analyze your codebase and past incidents to understand your stack, then auto-build the integrations so things work out of the box.
Try it in our Slack (no setup): https://join.slack.com/t/incidentfox/shared_invite/zt-3ojlxv...
Or self-host the whole thing (Apache 2.0): https://github.com/incidentfox/incidentfox
We’d love to hear what you think!
Main website: https://www.incidentfox.ai/

value: Show HN: IncidentFox – Debug prod incidents without leaving Slack (open source)

author: chiehminwei


value: nadaverell

value: Show HN: Radar – Open-source Kubernetes UI/IDE. Try it in 15 seconds

author: nadaverell


value: Benboren

value:
Hey everyone,
The problem: My schedule is unpredictable. Some days I have 25 minutes, some days an hour. Every workout app assumes I have the same time every day. I don't.
So I built QuickWorkout.
Tell it your time, get a workout. 15 minutes or 90 - it generates a balanced routine that actually fits.
Swap exercises instantly. Bench taken? One tap, equivalent exercise, same muscles targeted.
Weight logging that doesn't suck. One tap, auto-suggestions based on your history, progress tracking.
Pricing: Free to download, 3 free workouts, $9.99/month for unlimited.
Link: https://apps.apple.com/il/app/quickworkout-tap-train/id67579...
Would love feedback. What's missing?

value: Show HN: Workout app for when you're short on time

author: Benboren


value: dylandevelops

value:
I got tired of manually logging billable hours in Google Forms, so I built tmpo – a CLI time tracker that lives in your terminal.
Quick workflow:

  cd my-project/
  tmpo start "Implementing auth"
  # ... work happens ...
  tmpo pause              # take a break
  tmpo resume             # back to work
  tmpo stop
  tmpo stats --week       # see your hours
  tmpo export --week      # CSV for invoicing

Key features:
- Automatically detects projects via git repos or .tmporc files
- Pure-Go SQLite storage (modernc.org/sqlite) - no CGO, easy cross-compilation
- Milestone tracking to organize work into sprints/phases
- Pause/resume for break tracking with full audit trail
- Local-first - all data stays on your machine
- Configurable date/time formats and timezone display
- CSV/JSON export for invoicing
Technical highlights:
- UTC timestamps in database with timezone conversion for display
- Migration system for schema evolution
- Currency handling for 30+ currency codes
- GoReleaser for automated cross-platform builds (macOS, Linux, Windows)
- Built with Cobra CLI framework
Started this because I needed something that worked with my git workflow and didn't require cloud accounts or subscriptions. Happy to answer questions about the architecture or design decisions.
MIT licensed: <https://github.com/DylanDevelops/tmpo>

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

author: dylandevelops


value: bestonearth

value: Show HN: A free focus app that locks work if you skip breaks

author: bestonearth


value: MrTravisB

value:
Hi HN,
My team and I are building Tabstack to handle the web layer for AI agents. Today we are sharing Tabstack Research, an API for multi-step web discovery and synthesis.
https://tabstack.ai/blog/tabstack-research-verified-answers
In many agent systems, there is a clear distinction between extracting structured data from a single page and answering a question that requires reading across many sources. The first case is fairly well served today. The second usually is not.
Most teams handle research by combining search, scraping, and summarization. This becomes brittle and expensive at scale. You end up managing browser orchestration, moving large amounts of raw text just to extract a few claims, and writing custom logic to check if a question was actually answered.
We built Tabstack Research to move this reasoning loop into the infrastructure layer. You send a goal, and the system:
- Decomposes it into targeted sub-questions to hit different data silos.
- Navigates the web using fetches or browser automation as needed.
- Extracts and verifies claims before synthesis to keep the context window focused on signal.
- Checks coverage against the original intent and pivots if it detects information gaps.
For example, if a search for enterprise policies identifies that data is fragmented across multiple sub-services (like Teams data living in SharePoint), the engine detects that gap and automatically pivots to find the missing documentation.
The goal is to return something an application can rely on directly: a structured object with inline citations and direct links to the source text, rather than a list of links or a black-box summary.
The blog post linked above goes into more detail on the engine architecture and the technical challenges of scaling agentic browsing.
We have a free tier that includes 50,000 credits per month so you can test it without a credit card: https://console.tabstack.ai/signup
I would love to get your feedback on the approach and answer any questions about the stack.

value: Show HN: Tabstack Research – An API for verified web research (by Mozilla)

author: MrTravisB


value: LucasPi

value: Show HN: Image MetaHub – Search Local AI Images by Prompt, Model, LoRA, Seed

author: LucasPi


value: smartscrutiny

value:
Hi HN,
I built a small utility to clean up messy CSV exports without opening Excel or writing pandas scripts.
Upload a CSV → preview → choose columns to dedupe → normalize/trim → download the cleaned file.
Free tier, no signup required for basic use.
Stack:
-Lovable for the app
-Supabase (auth, Postgres, storage, edge functions)
-Stripe for subscriptions/day passes
Processing runs server-side; I kept the architecture intentionally simple and low-ops.
Would love feedback on UX, edge cases, or features you’d want.
Website: https://csv-cleaner.com/

value: Show HN: CSV Cleaner – simple tool to remove duplicates and clean CSV files

author: smartscrutiny


value:
I started jobswithgpt as a side project few months back to experiment with LLMs, RAG. The search focusses primarily on direct listings. There is an MCP server for more advanced use cases. Any feedback appreciated!
MCP docs: https://github.com/jobswithgpt/mcp

value: Show HN: Job Search Platform – Jobswithgpt


value: prabhavsanga

value: Show HN: LayerClaw – Lightweight observability for PyTorch training runs

author: prabhavsanga


value: sintem

value:
Hi HN, yesterday I missed a meeting and spent most of the day sending ~35 emails. That kind of inbox + calendar admin has been draining my time for a long while, so I built LIAM to fix it.
It helps with:
 - Drafting replies in your tone (honestly a bit scary how close it gets)
 - Scheduling meetings and handling the back and forth
 - Prioritising important threads and organising the inbox
Important: LIAM doesn’t send anything without approval.
I’d love feedback on what you’d actually trust an email agent to do, and which email workflows you’d automate first.
You are more than welcome to roast it.
Try it here: https://doitliam.com (connect Gmail + Calendar, about 1 min)

value: Show HN: LIAM – email and calendar assistant that drafts replies and schedules

author: sintem


value: midnightdim

value: Show HN: Resume Tailor – Privacy-first resume rewriter (no signup)

author: midnightdim


value: jeff-gorelick

value:
I built csvdb because I kept running into the same problem: I had small relational datasets (config tables, rate tables, seed data) that I wanted to version control, but SQLite files produce useless git diffs.
csvdb converts between a directory of CSV files and SQLite/DuckDB databases. The CSV side is the source of truth you commit to git. The database side is what you query.

  csvdb to-csvdb mydb.sqlite    # export to CSV directory
  vim mydb.csvdb/rates.csv      # edit data
  git diff mydb.csvdb/          # meaningful row-level diffs
  csvdb to-sqlite mydb.csvdb/   # rebuild database

The key design decision is deterministic output. Rows are sorted by primary key, so identical data always produces identical CSV files. This means git diffs show only actual data changes, not row reordering noise.
A few details that took some thought:
- NULL handling: CSV has no native NULL. By default csvdb uses \N (the PostgreSQL convention) to distinguish NULL from empty string. Roundtrips are lossless.
- Format-independent checksums: csvdb checksum produces the same SHA-256 hash whether the input is SQLite, DuckDB, or a csvdb directory. Useful for verifying conversions.
- Schema preservation: indexes and views survive the roundtrip, not just tables.
Written in Rust. Beta quality -- the file format may still change.
https://github.com/jeff-gorelick/csvdb

value: Show HN: Csvdb – Git-friendly CSV directories that convert to SQLite or DuckDB

author: jeff-gorelick


value: ydumpeta

value:
We built TabChop because splitting a bill still feels weirdly painful. Someone downloads an app, the receipt scan is off, the UI is clunky, and half the table gives up.
After one too many dinners where the “solution” turned into unresolved requests and Venmo chaos, we wanted something that simply worked.
TabChop starts with the receipt. Take a picture, share a short code, and everyone claims what they ordered. You can watch the receipt update live as people grab their items in real time, so there’s no “who got what?” confusion.
We also store each person’s Venmo, Cash App, or Zelle info, so when the split is done it’s one click to pay. No awkward questions about who to pay or how much.
The goal is simple. No friction, no math, no awkwardness. Just a painless way to split a tab.

value: Show HN: TabChop – AI parses receipts into shareable, realtime itemized splits

author: ydumpeta


value: willswire

value:
Hey HN!
This is a super early work-in-progress but I wanted to share with larger community to gauge interest.
I’ve forked Apple’s container CLI project and added a new build target for a CLI tool called cluster. You can visit the fork here: https://github.com/willswire/cluster
To get started, just run: make cli
And then: ./bin/cluster create
You will need the upstream container CLI installed and the container system running beforehand.

value: Show HN: K8s clusters on macOS using Apple's containerization framework

author: willswire


value: math-hiyoko

value:
Hi HN, I built a Sudoku solver web app focused on speed and correctness.
It solves standard puzzles quickly, but it can also handle ambiguous puzzles: instead of stopping at the first solution, it enumerates all valid solutions and reports the total number of solutions.
I built it mainly to explore performance and edge cases.
Feedback is welcome!

value: Show HN: Fast Sudoku solver that enumerates all solutions

author: math-hiyoko


value: benjifisher

value: Show HN: UCP Checker – A manifest debugger for the agentic web

author: benjifisher


value: zackham

value:
I juggle 5-6 Claude Code projects and kept losing context when switching between them or when a terminal died. Built clux to fix that.
It wraps tmux to give you named, directory-scoped sessions with automatic context restoration via `claude --resume`. Start with `clux new api`, detach whenever, `clux attach api` later. Survives terminal crashes, reboots, whatever.
Has a TUI for browsing sessions and a streaming API (`clux prompt api "run the tests" --json`) that outputs NDJSON in real-time. I use it to control sessions from a Telegram bot.
Python, ~2k lines. Only needs tmux and the Claude CLI.
https://github.com/zackham/clux

value: Show HN: Clux – Simple session manager for Claude Code

author: zackham


value: Show HN: Kepler - An Open-source text-to-SQL platform


value: maximelb

value:
Hello HN. I'm Maxime, founder at LimaCharlie (https://limacharlie.io), a Hyperscaler for SecOps (access building blocks you need to build security operations, like AWS does for IT).
We’ve engineered a new product on our platform that solves a timely issue acting as a guardrail between your AI and the world: Viberails (https://www.viberails.io)
This won't be new to folks here, but we identified 4 challenges teams face right now with AI tools:

  1. Auditing what the tools are doing.
  2. Controlling toolcalls (and their impact on the world).
  3. Centralized management.
  4. Easy access to the above.

To expand:
Audit logs are the bread and butter for security, but this hasn't really caught up in AI tooling yet. Being able to look back and say "what actually happened" after the fact is extremely valuable during an incident and for compliance purposes.
Tool calls are how LLMs interact with the world, we should be able to exercise basic controls over them like: don't read credential files, don't send emails out, don't create SSH keys etc. Being able to not only see those calls but also block them is key for preventing incidents.
As soon as you move beyond a single contributor on one box, the issue becomes: how do I scale processes  by creating an authoritative config for the team. Having one spot with all the audit, detection and control policies becomes critical. It's the same story as snowflake-servers.
Finally, there's plenty of companies that make products that partially address this, but they fall in one of two buckets:

  - They don't handle the "centralized" point above, meaning they just send to syslog and leave all the messy infra bits to you.
  - They are locked behind "book a demo", sales teams, contracts and all the wasted energy that goes with that.

We made Viberails address these problems. Here's what it is:

  - OpenSource client, written in Rust
  - Curl-to-bash install, share a URL with your team to join your Team, done. Linux, MacOS and Windows support.
  - Detects local AI tools, you choose which ones you want to install. We install hooks for each relevant platform. The hooks use the CLI tool. We support all the major tools (including OpenClaw).
  - The CLI tool sends webhooks into your Team (tenant, called Organization in LC) in LimaCharlie. The tool-related hooks are blocking to allow for control.
  - Blocking webhooks have around 50ms RTT.
  - Your tenant in LC records the interaction for audit.
  - We create an initial set of detection rules for you as examples. They do not block by default. You can create your own rules, no opaque black boxes.
  - You can view the audit, the alerts, etc. in the cloud.
  - You can setup outputs to send audits, blocking events and detections to all kinds of other platforms of your choosing. Easy mode of this is coming, right now this is done in the main LC UI and not the simplified Viberails view.
  - The detection/blocking rules support all kinds of operators and logic, lots of customizability.
  - All data is retained for 1 year unless you delete the tenant. Datacenters in USA, Canada, Europe, UK, Australia and India.
  - Only limit to community edition for this is a global throughput of 10kbps for ingestion.

Try it: https://viberails.io
Repo: https://github.com/refractionPOINT/viberails
Essentially, we wanted to make a super-simplified solution for all kinds of devs and teams so that they can get access to the basics of securing their AI tools.
Thanks for reading - we’re really excited to share this with the community! Let us know if you have any questions for feedback in the comments.

value: Show HN: Viberails – Easy AI Audit and Control

author: maximelb


value: dinge

value: A weather app for people who prefer their meteorologists to have money on the line

value: Show HN: Prediction market based weather app

author: dinge


value: cfinke

value: Show HN: EpsteIn – Search the Epstein files for your LinkedIn connections

author: cfinke


value:
I've been building agent-based apps and kept running into the same problem: wiring up real-time state updates is annoying. Agents do things, state changes, and you want the UI to reflect that instantly without writing a bunch of sync logic.
So I built a template using Convex as the backend. Convex handles state, live updates over WebSockets, and auto-generates most of the env vars. The template includes a visualizer so you can watch agent state changes as they happen, which is useful for debugging and demos.
The example app is a todo assistant where you can add or complete tasks in plain English and watch the UI stay in sync in real time. But the real point is the pattern: it's a clean starting point for any agentic app that needs real-time feedback without fighting infrastructure.
Built with Subconscious for the agent layer and Convex for the backend. You can get it running in a couple minutes:
npx create-subconscious-app my-project-name -e convex_app

value: Show HN: Template for real-time agentic web apps using Convex


value: hatmanstack

value:
Open-source document Q&A that deploys to your AWS account in one click. Upload docs, chat with AI, pay only when used.

  - Serverless: Lambda + Bedrock KB, zero idle cost
  - Your data stays in your account
  - Single sam deploy or CloudFormation

  GitHub: https://github.com/HatmanStack/RAGStack-Lambda
  Blog: https://portfolio.hatstack.fun/read/post/RAGStack-Lambda
  Demo: https://dhrmkxyt1t9pb.cloudfront.net/

  Login: guest@hatstack.fun / Guest@123

value: Show HN: RAGStack – Scale-to-zero serverless RAG on your own AWS

author: hatmanstack


value: ivanachillee

value: I made this autonomous radio station that generates 3-6 minute episodes on topics like geoengineering, history of science, cybernetics, and philosophy.<p>Agentic curation system picks topics, separate loops handle script writing and procedural music with critic feedback. Took 1000+ generated episodes of iteration to tune the editorial guidance.

value: Show HN: Autonomous AI radio station about engineering, history and philosophy

author: ivanachillee


value:
I built this to solve a personal problem: I kept missing interesting new papers unless I deliberately sat down to search arXiv or manage alerts.
Most tools I tried (Scholar alerts, RSS, following authors) worked in theory, but in practice they often turned into inbox management or assumed a very narrow field. My work is interdisciplinary, and I wanted a way to notice new papers casually, in short moments, without committing to a full literature search.
So I built a mobile-first reader where papers show up as a feed. You can quickly swipe through recent papers, skim titles/abstracts, and give lightweight feedback (like / skip). The idea isn’t to replace deep reading, but to lower the cost of awareness and help surface things worth a closer look.
It’s still early and opinionated, and I’m sure there are tradeoffs I haven’t thought through. I’d love feedback on:
whether this discovery model makes sense at all,
how people here keep up with papers in practice,
and where this breaks down compared to existing workflows.
Happy to answer questions.

value: Show HN: A TikTok-style research paper reader


value: Show HN: Lockin, a PDF TTS reader for manuals and papers cited Q&A


value: uptownhr

value: Show HN: Agent Box – Instant Sandbox VM for Claude Code(Macs)

author: uptownhr


value: skellertor

value: Quantify your work and experience

value: Show HN: Engineer Profiles - Quantify your work and experience

author: skellertor

story_text: Quantify your work and experience


value: hrkucuk

value:
I built TimeTracker, an offline-first time tracking Progressive Web App that runs entirely in your browser.
It’s aimed at freelancers (and anyone else who just wants a simple tracker) who don’t want accounts, cloud sync, or their work history living on someone else’s server. Your data stays on your device, and you can export it anytime.
What it does today:
Start/stop timers quickly, and track time across multiple projects
Timesheet-style view to review and edit entries by project/date
Calendar view to visualize daily/weekly work
Reports & analytics, including generating PDF reports
Import/export as JSON for backup/migration
Project management: hourly rates + basic cost tracking
Any UX friction you hit (especially on mobile, install-as-app, etc.)

value: Show HN: TimeTracker PWA built with GunDB – 100% privacy friendly with sync

author: hrkucuk