value: abhisek

value:
Hi everyone
I am the author of Gryph.
I have been using AI coding agents daily and realized I had no idea what they were actually doing across sessions. Sure, I could check git diff, but that doesn't show:
- Files the agent read but didn't change
- Commands it ran
- The sequence of actions in a session
- What happened last week when something broke
So I built Gryph - a CLI tool that maintains an audit log of all AI agent actions.
How it works:
- Installs hooks into Claude Code, Cursor, Gemini CLI (and other supported coding agents)
- Logs every action to a local SQLite database
- Provides rich querying: filter by time, agent, file path, action type
Quick demo:
$ gryph install
Discovering agents...
  [ok]  Claude Code v2.1.15
  [ok]  Cursor v2.4.21
Installation complete.
$ gryph logs --today
14:32  claude-code  session 7f3a2b1c
├─ 14:32:12  read     src/index.ts
├─ 14:32:18  write    src/utils/helper.ts    +12 -3
└─ 14:32:22  exec     npm test               exit:0
$ gryph query --file ".env" --since "7d"
# See if any agent touched sensitive files
Privacy-first:
- 100% local - no cloud, no telemetry
- Sensitive file patterns are protected (actions logged, content never stored)
- Configurable verbosity
GitHub: https://github.com/safedep/gryph
Built with Go. Would love feedback from others using AI coding tools!
Previous post by someone else: https://news.ycombinator.com/item?id=46846849

value: Show HN: Gryph – Audit Trail for AI Coding Agents (Claude Code, Cursor, Gemini)

author: abhisek


value: lauriro

value:
I published a small shell script to get and renew free HTTPS certificates via ACME v2 (Let’s Encrypt & co).
Single script, single conf file, DNS + HTTP challenges, written by human.
Homepage https://certx.sh/ and source https://github.com/lauriro/certx.sh waiting for feedback :)

value: Show HN: Simple ACME v2 client for green certificates in POSIX shell

author: lauriro


value: echelon

value:
I've been a photons-on-glass filmmaker for over ten years, and I've been developing ArtCraft for myself, my friends, and my colleagues.
All of my film school friends have a lot of ambition, but the production pyramid doesn't allow individual talent to shine easily. 10,000 students go to film school, yet only a handful get to helm projects they want with full autonomy - and almost never at the blockbuster budget levels that would afford the creative vision they want. There's a lot of nepotism, too.
AI is the personal computer moment for film. The DAW.
One of my friends has done rotoscoping with live actors:
https://www.youtube.com/watch?v=Tii9uF0nAx4
The Corridor folks show off a lot of creativity with this tech:
https://www.youtube.com/watch?v=_9LX9HSQkWo
https://www.youtube.com/watch?v=DSRrSO7QhXY
https://www.youtube.com/watch?v=iq5JaG53dho
We've been making silly shorts ourselves:
https://www.youtube.com/watch?v=oqoCWdOwr2U
https://www.youtube.com/watch?v=H4NFXGMuwpY
The secret is that a lot of studios have been using AI for well over a year now. You just don't notice it, and they won't ever tell you because of the stigma. It's the "bad toupee fallacy" - you'll only notice it when it's bad, and they'll never tell you otherwise.
Comfy is neat, but I work with folks that don't intuit node graphs and that either don't have graphics cards with adequate VRAM, or that can't manage Python dependencies. The foundation models are all pretty competitive, and they're becoming increasingly controllable - and that's the big thing - control. So I've been working on the UI/UX control layer.
ArtCraft has 2D and 3D control surfaces, where the 3D portion can be used as a strong and intuitive ControlNet for "Image-to-Image" (I2I) and "Image-to-Video" (I2V) workflows. It's almost like a WYSIWYG, and I'm confident that this is the direction the tech will evolve for creative professionals rather than text-centric prompting.
I've been frustrated with tools like Gimp and Blender for a while. I'm no UX/UI maestro, but I've never enjoyed complicated tools - especially complicated OSS tools. Commercial-grade tools are better. Figma is sublime. An IDE for creatives should be simple, magical, and powerful.
ArtCraft lets you drag and drop from a variety of creative canvases and an asset drawer easily. It's fast and intuitive. Bouncing between text-to-image for quick prototyping, image editing, 3d gen, to 3d compositing is fluid. It feels like "crafting" rather than prompting or node graph wizardry.
ArtCraft, being a desktop app, lets us log you into 3rd party compute providers. I'm a big proponent of using and integrating the models you subscribe to wherever you have them. This has let us integrate WorldLabs' Marble Gaussian Splats, for instance, and nobody else has done that. My plan is to add every provider over time, including generic API key-based compute providers like FAL and Replicate. I don't care if you pay for ArtCraft - I just want it to be useful.
Two disclaimers:
ArtCraft is "fair source" - I'd like to go the Cockroach DB route and eventually get funding, but keep the tool itself 100% source available for people to build and run for themselves. Obsidian, but with source code. If we got big, I'd spend a lot of time making movies.
Right now ArtCraft is tied to a lightweight cloud service - I don't like this. It was a choice so I could reuse an old project and go fast, but I intend for this to work fully offline soon. All server code is in the monorepo, so you can run everything yourself. In the fullness of time, I do envision a portable OSS cloud for various AI tools to read/write to like a Github for assets, but that's just a distant idea right now.
I've written about roadmap in the repo: I'd like to develop integrations for every compute provider, rewrite the frontend UI/UX in Bevy for a fully native client, and integrate local models too.

value: Show HN: ArtCraft AI crafting engine, written in Rust

author: echelon


value: hirokiyn

value:
Hi HN, I’m Hiroki, founder of Epismo.
Every day, people share “must-use” prompts, but copying a single prompt rarely reproduces real outcomes. The missing piece is the workflow: task decomposition, step order, intermediate artifacts, and quality checks.
So I built Workflow Hub, an open library of human-AI workflows you can clone and run. Each workflow includes step definitions, inputs, expected artifacts/outputs, and verification checks, so you can copy the whole process, not just a prompt. You can clone a workflow, customize it, then execute it in Epismo with the best agent for each step.
PH: https://producthunt.com/products/epismo
Link: https://epismo.ai/hub
If you have a workflow that’s working well for you, please share it. I’m personally curious what workflows you’re building with Claude Code, Cowork, or OpenClaw.

value: Show HN: Workflow Hub, Open library of human-AI workflows you can clone and run

author: hirokiyn


value: samaysharma

value: Show HN: Official Kubernetes Operator for ClickHouse

author: samaysharma


value: DavidCanHelp

value: Show HN: Vibedetector – detect AI tooling use in a directory

author: DavidCanHelp


value: msvan

value: Show HN: Autoliner – write a bot to control a virtual airline

author: msvan


value: glennhv

value:
Hi, I'm looking for feedback about usability, concept, pricing, perhaps features.
I created this tool because a client with over 300 pages of content on his website wanted to have the content in such a way that it can be send to a translation agency.
The next step was that I added an AI-integration to translate the copy, which can be reviewed by the translation agency.

value: Show HN: Url/sitemap/pdf/word to Markdown (feedback wanted)

author: glennhv


value: huseyinbabal

value: Show HN: Zap-Operator – Run OWASP Zap Scans via Kubernetes CRDs

author: huseyinbabal


value: kalasoo

value:
I built Pixel, a 1000×1000 collaborative pixel canvas where humans and AI agents paint side‑by‑side. Community posts get voted up, and the AI paints the top ideas every 10 minutes.
Live: https://pixel.vibe42.ai
It’s mostly for fun — part social experiment, part collaborative art. Would love feedback.

value: Show HN: Pixel – a live R/place‑style canvas where humans and AI paint together

author: kalasoo


value: crisogray

value:
OpenCode Desktop fork using Claude Agent SDK, enabling use of Claude Pro/Max subscriptions. Open source.
https://github.com/crisogray/claudius

value: Show HN: Claudius – An OpenCode Desktop Fork Built for Claude Code

author: crisogray


value: ethegwo

value: Show HN: Agents that save explore recover on their own

author: ethegwo


value: joohwan

value:
Hi HN,
I'm one of the creators of HoundDog.ai (https://github.com/hounddogai/hounddog). We currently handle privacy scanning for Replit's 45M+ creators.
We built HoundDog because privacy compliance is usually a choice between manual spreadsheets or reactive runtime scanning. While runtime tools are useful for monitoring, they only catch leaks after the code is live and the data has already moved. They can also miss code paths that aren't actively triggered in production.
HoundDog traces sensitive data in code during development and helps catch risky flows (e.g., PII leaking into logs or unapproved third-party SDKs) before the code is shipped.
The core scanner is a standalone Rust binary. It doesn't use LLMs so it's local, deterministic, cheap, and fast. It can scan 1M+ lines of code in seconds on a standard laptop, and supports 80+ sensitive data types (PII, PHI, CHD) and hundreds of data sinks (logs, SDKs, APIs, ORMs etc.) out of the box.
We use AI internally to expand and scale our rules, identifying new data sources and sinks, but the execution is pure static analysis.
The scanner is free to use (no signups) so please try it out and send us feedback. I'll be around to answer any questions!

value: Show HN: HoundDog.ai – Ultra-Fast Code Scanner for Data Privacy

author: joohwan


value: vuhp

value:
Hey HN! I built a CLI tool to find cost-saving opportunities in AWS, Azure, and GCP.
Why?
Existing cost management tools are either expensive SaaS products or slow dashboards buried in cloud consoles. I wanted something fast, CLI-first, and multi-cloud that I could run in CI/CD or my terminal.
What it does:
- Scans your cloud accounts and finds idle VMs, unattached volumes, oversized databases, unused resources
- Returns a ranked list of opportunities with estimated monthly savings
- 26 analyzers across AWS, Azure, and GCP
- Read-only (never modifies infrastructure)
Key features:
• HTML reports with interactive charts (new in v0.6.2)
• AI-powered explanations (OpenAI or local Ollama)
• Export formats: HTML, Excel, CSV, JSON, terminal
• Multi-Cloud - AWS, Azure, and GCP support (26 analyzers)
Quick example:
npm install -g cloud-cost-cli
cloud-cost-cli scan --provider aws --output html
Real impact:
One scan found $11k/year in savings (empty App Service Plan, over-provisioned CosmosDB, idle caches).
Technical stack:
- TypeScript
- AWS/Azure/GCP SDKs
- Commander.js for CLI
- Chart.js for HTML reports
- Optional OpenAI/Ollama integration
Open source (MIT): https://github.com/vuhp/cloud-cost-cli
npm: cloud-cost-cli
Would love feedback on:
1. What features would be most useful?
2. Should I add historical tracking (trends)?
3. Any missing cloud providers?
Happy to answer questions!

value: Show HN: Cloud-cost-CLI – Find cloud $$ waste in AWS, Azure and GCP

author: vuhp


value:
I wanted to share a project I have been working on over the past week.
It is a simple local memory system that saves your sessions into Markdown files, which can be viewed later.
I developed this after using Claude Mem. I really enjoyed working with it, but it was consuming a lot of RAM, and each Claude session was becoming a major resource hog. I also tried other plugins and MCP solutions, but ran into similar issues, either slow performance or concerns about data being sent elsewhere.
Because privacy was a big thing for me, I decided to build my own solution that keeps all data local.

value: Show HN: I built simple and efficient local memory system for Claude Code


value: KeluAgent

value: Reddit is one of the best sources for high-intent traffic, but monitoring it manually is a nightmare. RedditLeadGen automates the process of finding relevant conversations and engaging with potential leads at their moment of need. It’s part of the Hangryfeed growth engine ecosystem.

value: Show HN: RedditLeadGen – Automate high-intent lead capture on Reddit

author: KeluAgent


value: smonte

value:
Hey HN!
I am building Vibeloop, a platform where you write small programs — canvas animations, GLSL shaders, Phaser games, charts — and they show up as discoverable cards.
https://vibeloop.app
The card types are:
- Canvas — JS with a setup()/draw() loop
- Shader — GLSL fragment shaders
- Phaser — full Phaser 3 games in a card
- Chart — powered by Chart.js
- Markdown — with LaTeX math
Some things I think are interesting:
- Cards can use audio (Web Audio API beep/noise synthesis), mouse/touch input, uploaded images as textures
- A watchdog kills runaway code (infinite loops, recursion)
- You can remix any card — it forks the code with attribution
- "Try your image" lets viewers swap in their own images on cards that use textures, and save and/or share the result
- Snapshot lets you capture a frame of a live card and share it as a static card
I'd love feedback on the creator experience (hit "Create" to open the editor — no signup required to play with the code, only to publish). Also curious about the remix and snapshot concept.

value: Show HN: Vibeloop – A place for some creative fun

author: smonte


value: cshdllr

value:
I made a daily puzzle game with a simple mechanic. Click squares to increment their numbers (1→2→3...→9→1) and when 3+ adjacent squares match they pop. The goal is to clear the board in as few moves as possible.
It's quick to play (~1 minute) and the strategy gets surprisingly deep once you start thinking about cascades and efficient pathing.
Initially I started with a 12x12 grid, but after testing with some friends it felt way too overwhelming. It made it hard to feel like you could have a strategy. Once I simplified it to a 5x5 grid the game felt a lot more fun and approachable. You can also play more than once each day so you can keep trying to beat your score.

value: Show HN: Number Crunch – a simple daily number puzzle

author: cshdllr


value: Show HN: LogSentinel – Local, privacy-first log analyzer (No OpenAI)


value: Traditional agencies are too slow for Web3. We operate as a technical momentum unit directly inside your team. $2.2B+ volume driven for partners.

value: Show HN: Hangryfeed – The Embedded Squad Model for Web3 and AI Growth


value: Show HN: Serverless OpenAI Gateway: PII and Cache on Cloudflare Workers


value: Show HN: FXScript – A Mission Script Parser+Runtime


value: supercech

value: Show HN: FixDoc – A Git-synced knowledge base for capturing infra fixes

author: supercech


value: ajbeattie

value: Show HN: Octobud, open source Gmail-inspired inbox for your GitHub notifications

author: ajbeattie


value: Show HN: Agentic AI Chatbot Built with CReact JSX


value: cyjackx

value:
I know most of you could've hand-coded this in your sleep, but for me it was a simple example of just being able to vibecode something I personally wanted to use.
Everybody knows you can get real tense and stop breathing when staring at a screen, so I thought a very low-friction simple reminder (a circle expanding and shrinking) would be useful.  I couldn't find anything free, so I vibecoded this.  I have familiarity with webdev and some other things but had never heard of Tauri or used Rust, but the LLMs recommended those over Electron to keep it lightweight/small.
There are some basic settings for color, opacity, minimum size, etc.  You can replace the circle with a custom image.  That's the most I could consider to do for now.
It's windows-only and FOSS on github.

value: Show HN: BreatheWidget, simple widget that pulses to remind you to breathe

author: cyjackx


value:
I have been building a Blazor WASM enterprise app for a few years now. I wanted a break from it and had an idea for a side project that had been in the back of my mind for a few years. A daily political poll where anyone can participate and privacy is a product, not a checkbox.
This is how it works. One question per day about current events. Agree or Disagree. Each poll runs for 24 hours (midnight to midnight ET) and then close permanently. You do not need an account to vote. The main idea is to capture sentiment at a specific point in time, before the news cycle moves on and people's opinions drift.
For this app, I tried to make privacy the point and not just a feature. I originally used a browser fingerprint for anonymous voting, but recently changed it to a simple first-party functional cookie. It uses a random string and the PollId to see if your browser had voted before. The server stores a hash of the cookie to check for duplicates while the poll is live, then deletes all hashes when the poll closes. Only the aggregate counts remain. The browser fingerprint had way too many device collisions where it would show someone they voted even though they had not (an odd thing to see when you go to a poll). The HttpOnly cookie is also available during prerender, which helped eliminate loading flashes I was getting.
This app was built with .NET 10 Blazor with a hybrid Static SSR + Interactive Server. The static pages (about, privacy, terms, etc...) don't need SignalR connections. The interactive ones (voting, archive, results, etc...) do. Mixing these modes was a new experience for me and ended up being pretty tricky. I ended up with data-enhance-nav="false" on most links to prevent weird state issues.
The two biggest things I learned during building this app was how to prevent weird blazor flashes and duplicate queries during pre-render, hydration, and state changes. I used the _ready pattern from preventing the hydration flashes (gate rendering until data is loaded by setting the flag before the first await). Preventing the duplicate queries was possible by using a 2-second static caching during prerender to hydration.
This isn't scientific polling and these are obviously not representative samples. The 24-hour window means smaller numbers than longer surveys and it's only a survey of those who choose to participate. The Agree/Disagree binary choice basically flattens nuance (like I sort of agree), but I am okay with all of this as I think a lot of people feel they never get to participate in these sorts of polls.
I recently also added discussions with AI moderation (Claude Haiku 4.5 as a "first-pass" filter which flags things clearly out of the community guidelines for human review), a reaction system where counts stay hidden until the discussion closes, and news coverage from across the political spectrum shown after you vote for more perspective on the topic.
Thanks for checking it out and happy to dig into any of the Blazor SSR patterns or anything else that sounded interesting. I know Blazor is less frequently used and especially for a public facing website. It did have its challenges, but so far, it has been a blast to work with overall.

value: Show HN: PolliticalScience – Anonymous daily polls with 24-hour windows


value:
I built this as an internal tool for my company and wasn't planning to open-source it. But I saw a post from Boris (who built Claude Code) describing his workflow, and two things jumped out: he runs multiple Claude Code sessions in parallel, and he spends extensive time discussing and planning with Claude before letting it touch any code — then lets it run. That's exactly how I work, so I figured maybe this tool is useful to someone else.
The core idea: when you're running 3-5 Claude Code sessions across dev, prod, and local machines, your human brain can't track what's happening where. You kick off a task, get distracted, come back, and end up context-switching to whatever Claude finished first rather than what's highest priority. Executive gives you a single dashboard showing every session, its status, its priority, and plays a chime when something completes.
The key feature is autopilot mode — once you've thoroughly planned an approach with Claude (and this planning phase is where the real work happens), you flip a switch and it auto-approves all tool calls so Claude can run wild for 20+ minutes without interruption. You fully context-switch to the next session that needs your attention. (Yes, there are obvious security implications; the README has warnings.)
The workflow philosophy is basically: let humans do what humans are good at (creativity, planning, decision-making, prioritization) and let AI do what it's good at (fast execution). I'm not interested in agents that run autonomously for 30 hours. I want tight human-AI collaboration where I'm making executive decisions across multiple parallel workstreams and maintaining the kind of deep focus you used to get when writing code by hand — except now you're shipping multiple features in hours instead of days.
No commercial ambitions here — most people aren't working this way yet, and the tool is pretty opinionated about workflow. Just sharing in case it clicks for someone.
Built with Claude Code hooks (shell scripts at lifecycle events), SSE for real-time updates, no dependencies. Local and cloud (multi-machine) variants included.

value: Show HN: Executive – A real-time dashboard for orchestrating many Claude Codes


value: baristaGeek

value: Show HN: AI-powered AWS Cloud Practitioner exam prep tool

author: baristaGeek


value: cbnsndwch

value: I built a small TypeScript library with a React component for rendering classic fractals (Koch, Hilbert, Sierpinski, Dragon, Mandelbrot, etc.) as clean SVG.<p>It can be used directly in React apps or from a CLI for generative art and visual experiments. Feedback welcome.

value: Show HN: Fractal SVG – Generate Mathematical Fractals as SVG with React

author: cbnsndwch


value: pontusabra

value: Coding agents should pick packages that are fast, reliable, secure, and up-to-date – not just whatever they remember from training data. They need real-time signals: Is this package maintained? Any vulnerabilities? Is there a better alternative?

value: Show HN: NPM registry built for AI agents (MCP-first, <100ms health scores)

author: pontusabra


value: thughari

value:
Hi HN,
I built an open-source job tracker that removes manual updates by ingesting job-related emails.
Instead of asking users to log applications or update statuses, the system listens to forwarded emails, extracts structured data using an LLM, and updates the application pipeline automatically.
The interesting parts from an engineering perspective:
- Event-driven email ingestion via webhooks
- LLM-based extraction with deterministic backend decisions
- Fuzzy matching to upsert applications instead of creating duplicates
- Server-side aggregation and caching instead of heavy DB queries
- Fully sandboxed local mode (mock AI, local storage, email trap)
Stack: Java 21, Spring Boot, PostgreSQL, Angular, D3.js.
Demo: https://thughari.github.io/JobTrackerPro
Source: https://github.com/thughari/JobTrackerPro
I’d appreciate feedback on the ingestion design and matching strategy.
Thanks.

value: Show HN: JobTrackerPro – open-source job tracker that updates via AI and email

author: thughari


value: davidcann

value:
I made Multitui to control the sandbox of coding agents easily without changing my dev environment (no special container or VM). There's no configuration required in your local dev environment... just launch ClaudeCode.app instead of claude in your general terminal. Containers and VMs can be useful, but I always have a bunch of projects going and those solutions feel heavy.
Multitui creates single-purpose macOS apps for any terminal app, with optional sandbox. It uses the built-in macOS sandbox-exec along with log monitoring to give you an easy UI to manage rules, see what's being blocked, and add rules as you observe files that need to be allowed.
The apps you create are highly customizable and provide many native macOS integrations (document-based app model, Finder integration, global shortcut, etc). It's built with Swift, so it's fast and lightweight.
I also like the idea of TUIs being first-class apps, like what Omarchy did on linux. It helps me context-switch better than cycling through ten similar-looking tabs in Ghostty.
It's free in beta and free for personal use forever.
https://multitui.com
Does this seem useful? Does it need network sandboxing too?
-David

value: Show HN: Multitui – sandbox claude, codex, or any TUI with custom macOS apps

author: davidcann


value:
I've been building a C++ tensor library that tries to bring the ergonomics of NumPy/PyTorch to native code. The main goals were:
  - Familiar API (operator overloading, method chaining, same function names)
  - Actual GPU acceleration via Metal (not just matmul, but all ops)
  - Cross-platform with SIMD on x86/ARM/RISC-V via xsimd
  - einops-style rearrange/reduce patterns
It started because I wanted NumPy's API but needed to deploy on edge devices without Python. Ended up going deeper than expected (28k LOC+) into BLAS backends, memory views, and GPU kernels.
Some things I'm genuinely unsure about and would love feedback on:
  - Does Axiom actually seem useful?
  - What features might make you use it?
GitHub: https://github.com/frikallo/axiom
Happy to answer questions about the implementation.

value: Show HN: Axiom – C++ tensor library with NumPy API and Metal GPU support


value: ssullas

value:
Hi guys,
I built Screen Doctor after dealing with stubborn dead pixels and annoying screen lines myself and realizing there wasn’t a simple, lightweight tool that just did the job perfectly.
I made this lightweight, fast utility tool using Tauri framework with React at frontend and Rust at backend.
Screen Doctor helps you:
Fight dead pixels, stuck pixels, and screen lines.
Run full-screen color cycles to revive stuck pixels.
Prevent further degradation of your display.
It’s free, open-source, and runs fully offline as a native desktop app.
I’d love your feedback. Especially:
Does this help diagnose your screen issues?
Any features you wish existed for display testing?
Ideas to make it more useful for designers, developers, or everyday users?
Thanks for checking it out, and happy to answer any questions

value: Show HN: Screen Doctor – A lightweight pixel fixer built in Rust/Tauri

author: ssullas


value: robotelvis

value: I built a fun little history visualization called Histomap Reborn, inspired by John Sparks’ 1931 Histomap. It shows the relative power of civilizations over time, plus layers for technology, fiction, important people, etc.<p>What I loved about the original Histomap was the way it made history feel like an interconnected whole rather than a series of disconnected facts. I wanted to update it for the modern era and make it interactive.

value: Show HN: Histomap Reborn – Interactive visualization of world history

author: robotelvis


value: brunes

value: Show HN: A Cursor plugin to output OpenTelemetry for logging / observability

author: brunes


value: MrGrzybek

value:
Hi HN,
I often need to generate PDFs (reports, invoices, documents) in backend services.
HTML → PDF tools kept producing slightly different output depending on environment and fonts, which caused a lot of small but annoying issues.
LaTeX, while not fun to write, consistently produced the same PDF every time.
So I wrapped it behind a small, stateless API that other applications can call.
How it works:
send LaTeX (JSON or files)
it compiles in an isolated environment
download the resulting PDF
It’s not an editor and not meant for interactive writing — just a reliable PDF engine for apps.
Docs: https://texapi.ovh/docs
I’m mostly looking for feedback:
does this solve a real problem for you?
what would you change?
what would make this more useful?
Happy to answer questions.

value: Show HN: A small API for generating reliable PDFs using LaTeX

author: MrGrzybek


value: vnykmshr

value:
Built an ambient mood radio. Pick one of 6 moods (focus, calm, late night, energize, groove, storm) and it plays continuously.
Tech: Go backend serving static files + API from single binary, SQLite for metadata, vanilla JS frontend with no build tools. PWA with offline support.
Content pipeline is automated: audio processing, normalization, Cloudflare R2 sync.
Running on a $4 VPS, 8MB memory usage. No framework, no React, no webpack.
drift.1mb.dev

value: Show HN: Drift FM – Ambient Mood Radio (Go, SQLite, Vanilla JavaScript)

author: vnykmshr


value: dtran

value:
There's no shortage of advice on how to vibe-code (or vibe engineer, if you're actually reading the code outputted by LLMs) better. We're inundated with how to write prompts, set up better context or skills for agents, or how to get the most out of different platforms or models. But talking to friends who've vibe-coded projects, the bottleneck doesn't seem to be getting started building, or that they can't get the agents to do what they want. We noticed two recurring patterns:
1) Most people never ship. Even though vibe-coding lowers the barrier to entry, time, and cost of building a MVP, it can also make it harder to ship when each additional feature or polish is just one prompt away. And sure, lots of projects are just scratching a personal itch, but if it solves your problem well, someone else out there would probably like it too—if nothing else, as an inspiration to create their own take on it.
2) Even those who do ship struggle to get anyone to try it. Your friends want to help, but they're often not the target audience. And as the cost of building decreases and the number of projects explodes, discovery only gets harder. Vibe-coded projects might have an even harder time than projects built by hand because audiences assume you didn't put as much thought or effort into them, or that they're not secure.
We used Lovable to build a StumbleUpon for vibe-coded projects. Visit the site, see a random project, try it out if it looks interesting, or click through to the next one until you find one that does look interesting. This probably isn't the most natural format for project discovery, but ranked leaderboards usually get gamified and feel like they have a higher bar for submission. Most of all, seeing what other people have built and shipped, especially when it's vibe-coded, makes shipping your own feel a lot more within reach. Try it out and let us know what you think!

value: Show HN: Vibecode Together – StumbleUpon for Vibe-coded projects

author: dtran


value: taehun

value: Show HN: Img-src – $5/month image CDN with on-the-fly transforms via URL params

author: taehun


value: arbopa

value:
Hi HN,
I’m a longtime developer and photographer who built this after losing client photos years ago due to a “working” backup that silently failed.
Most photo backup tools I tried assumed:
• always-on cloud
• perfect networks
• small files
• trust in background magic
Real photography workflows don’t look like that.
FrameVault is a desktop-first backup system designed for large RAW files, interruptions, external drives, and long-running uploads. It runs locally, tracks what’s actually been uploaded, resumes cleanly after failures, and doesn’t pretend everything is fine when it isn’t.
Some deliberate choices:
• Desktop app, not web-only
• Explicit upload queues instead of “sync magic”
• Handles interruptions and restarts safely
• Designed for multi-TB photo libraries
• No AI, no social layer, no growth hacks
It’s intentionally boring software.
This is the first public Windows release; macOS is coming next. I’m mainly looking for feedback from people who’ve had to think seriously about backups, reliability, or large-file workflows.
Site: https://cameratrician.com/framevault
Happy to answer technical or design questions.

value: Show HN: FrameVault – a desktop-first photo backup tool built after losing data

author: arbopa


value: soneca

value: Show HN: Confabulists, a Substack for Fiction Writers

author: soneca


value: bhaskaraee

value: Show HN: SochDB – an embedded database for SQL, vectors, and AI context

author: bhaskaraee


value: ezulabs

value:
(Yes, the name keeps the "Yet Another" tradition alive. YAML did it, YACC did it, now YAOC. Someone had to.)
This whole thing was vibe coded – $99 in tokens later, you can save that and just use your local LLM instead.
Shipping before bed because my agent can't work autonomously at night yet, and I know someone would release this while I'm sleeping.
https://github.com/ezulabs/yaoclaw

value: Show HN: Yaoclaw (Yet Another Open Claw)AI agent that runs cmds in macOS sandbox

author: ezulabs


value: shuvrokhan

value:
Hi guys,
I built a Terminal UI for Kamal Deploy, for both server management and per-project use.
Inspired by lazydocker's TUI, it's also open source.
The issue was that my single VPS hosts all deployed configurations, making it hard to visualize and inspect them. I wanted a visual way to see their status, so I created this tool.
Happy to receive feedback or PRs if you find it useful.
Find it at https://github.com/shuvro/lazykamal
Regards,
Nazmul

value: Show HN: Open-Source Terminal UI for Kamal Deploy Management

author: shuvrokhan


value: Aaevro

value:
I built a mortgage payment calculator for people who just want clean, fast numbers without the lead-gen friction.
https://toolvault.co/tools/mortgage-payment-calculator
It started because every time I tried to run mortgage scenarios, I hit one of these problems:
Forms that demand email/phone before showing results
Slow, ad-heavy pages that feel like landing funnels, not tools
Calculators that only show principal + interest, ignoring real monthly costs
What this tool does:
Calculates full monthly housing cost: principal, interest, property tax, insurance, PMI, and HOA fees
Shows an amortization-style breakdown so you can see how payments shift from interest to principal over time
Lets you quickly tweak: home price, down payment, interest rate, loan term, and extra monthly costs
Works well on mobile and desktop, no account or email required
A few design decisions I made:
No popups, no dark patterns, no “talk to a lender” wall
Reasonable ad density only (I do monetize it, but tried hard not to make it miserable)
Defaults tuned for 2026-style rates but everything is editable
Things you can use it for:
“How much house can I realistically afford?” style scenarios
Comparing 15 vs 30 year terms and seeing total interest difference
Testing how much a bigger down payment really changes the monthly
Quick refinance what-ifs (set down payment to 0 and plug in your current balance + new rate)
I’m a solo dev working on a suite of small, focused tools, and this is one of them. The account posting this is ~20 days old with basically no karma, so I’m very open to blunt feedback on both the product and how I’m launching it.
I’d love feedback on:
Is the UX clear, or does anything feel confusing or distracting?
Are there any must-have inputs I’m missing (e.g. specific tax/insurance assumptions, regional quirks)?
Would you trust / actually use this when evaluating a home or refinance, and if not, what’s missing?
If this is useful to you, I’m happy to iterate based on your comments and ship improvements quickly.

value: Show HN: Mortgage Payment Calculator (fast, no signup)

author: Aaevro


value: Slaine

value:
I’ve been working on a small deterministic event-capture kernel and wanted an external sanity check.
This repo intentionally contains only two NDJSON files — no code, no UI:
a clean run
a run where I intentionally removed a persisted segment before export
In the second file, the system emits an explicit gap marker instead of crashing or silently truncating data, then continues exporting deterministically.
I’m honestly not sure how novel or useful this is in practice, so I’d appreciate feedback from people who work with logs, traces, or audit systems.

value: Show HN: Deterministic event logs with explicit gap markers (NDJSON proof)

author: Slaine


value: Show HN: AiDex Tree-sitter code index as MCP server (50x less AI context usage)


value: mlukaszczyk

value:
Tracks competitors for changes (pricing, features, messaging, hiring etc) and delivers AI-summarized insights to your inbox. Built because manual competitive research breaks at scale. Markets move continuously but humans don't monitor consistently.
Live at https://parano.ai
Monitors full websites and other sources like social media / Github. Detects content-level changes, filters noise.
The problem: Teams either do quarterly manual research (too slow) or set up Google Alerts (too noisy, misses subtle changes). We're in between—continuous monitoring with smart filtering.
Would love feedback on what competitive intelligence is actually useful vs. overwhelming.

value: Show HN: Parano.ai – Continuous Competitor Monitoring

author: mlukaszczyk


value: sfaist

value:
I built a plugin for OpenClaw that intercepts tool calls before and after they execute and checks for:
Secrets: API keys, tokens, cloud credentials, private keys
PII: SSN, credit cards, emails, phone numbers
Destructive commands: rm -rf, git reset --hard, DROP TABLE, sudo, etc.
When something is detected, you can configure it to block, redact, require confirmation, or just warn. I added some defaults, e.g. it blocks rm -rf / and warns for email exposure.
Install:
openclaw plugins install clawguardian
Example:
$ openclaw agent --message "run echo '4358 9100 8899 4843'" --agent main
09:33:20 [plugins] ClawGuardian: pii_credit_card (high) detected in tool exec params
Done. The command ran, but ClawGuardian redacted the output since it detects the card-like format.
GitHub: https://github.com/superglue-ai/clawguardian
This is an early version, so I'd love some feedback and thoughts on how to make ClawGuardian better. This is not a replacement for being careful with OpenClaw's capabilities, just an additional security layer preventing the bot from posting my SSN that if found in my emails on some obscure agent social media network.

value: Show HN: ClawGuardian – Security Plugin for OpenClaw

author: sfaist


value: siefca

value:
Hi HN,
I built Bankster, a Clojure library for working with money and currencies, with explicit behavior contracts.
It’s "money as data": Money = (Currency, BigDecimal amount), and currencies are managed via a registry (global / dynamically scoped / local) that can represent ISO 4217, crypto, and custom currencies – including deterministic conflict resolution for currency codes.
Highlights:
* BigDecimal everywhere; scale/rounding under control (including non-terminating divisions via rescaling/rounding policies)
* ISO 4217 + crypto + custom currencies (namespaced IDs like crypto/ETH)
* Sum-preserving allocation/distribution ("no lost pennies")
* EDN-friendly: tagged literals #money, #currency, data readers; JSON/EDN serialization
* Operator layer: money.ops and money.inter-ops
I’d love feedback on the contracts, API ergonomics, and the registry approach.

value: Show HN: Bankster – "money as data" toolkit for Clojure (registry, bigdec, EDN)

author: siefca


value: shensations

value:
I'm the head of product at ROOST, a nonprofit focused on democratizing online safety technology through open source software, and one of the people behind Osprey, an open-source rules engine for fighting abuse at scale. We just released v1.0, which is what's running in production at Discord and Bluesky (and soon Matrix!), processing hundreds of millions of events daily.
Most platforms face a bad choice: build custom abuse-fighting infrastructure from scratch, or use closed vendor solutions. We built Osprey to give smaller platforms and communities access to the same quality of tooling that large companies build internally. All of our projects are self-hosted, which means data stays in your own system.
v1.0 is our proven production-ready release. It includes:
- Core rules engine: The rules engine itself lets you write detection logic. Rules can extract features, mutate labels, emit verdicts, and trigger downstream actions.
- Interface for open-ended investigation: The open-ended interface means you can identify new abuse patterns as they emerge. The whole system is designed for high throughput and horizontal scaling.
- Labeling service: human and automated labels on entities (users, IPs, emails) that feed into rules and workflows
- Rust coordinator: horizontal scaling and load balancing across workers via gRPC streams and service discovery
- Event stream: real-time investigation UI with searchable history using our SML (custom python language for safety teams to use if they don't know python or programming languages) query language
License: Apache 2.0
Repo: https://github.com/roostorg/osprey
v1.0 Release notes: https://github.com/roostorg/osprey/releases/tag/1.0
Github Codespace demo (note: if this is not running when you click on it, it probably idled out): <a href="https://turbo-fiesta-p46xvxwp4vfwqv-5002.app.github.dev/?start=2026-02-01T18%3A58%3A24Z&end=2026-02-02T18%3A58%3A24Z&queryFilter=SuspiciousDisplayName+%3D%3D+True&interval=day&customSummaryFeatures=AccountCreatedAt&customSummaryFeatures=FollowerCount&customSummaryFeatures=PostCount&customSummaryFeatures=ActionName&customSummaryFeatures=EventType&customSummaryFeatures=UserId&customSummaryFeatures=DisplayName&customSummaryFeatures=IpAddress&customSummaryFeatures=PostText&topn=DisplayName&chart=" rel="nofollow">https://turbo-fiesta-p46xvxwp4vfwqv-5002.app.github.dev/?sta...
Our FOSDEM talk from last week: https://fosdem.org/2026/schedule/event/U7ABHE-roost-osprey/
Thanks for reading! I'm happy to answer questions, get feedback, or discuss things.

value: Show HN: Osprey 1.0, open-source rules engine for online safety

author: shensations


value: fivemins

value:
Why do 200+ researchers understand something, but 200,000 people don’t?
This is part of a larger experiment at https://fivemins.in - transforming research papers into stories with emotional intelligence bridges.
Comments /Critics/ Feedback welcome and will work if I create a curated digital 'StoryLibrary ' from deep tech papers/concepts? Thanks!

value: Show HN: DeepSeek's mHCpaper into fivemins sci-fi story-12,24,48hrs per day

author: fivemins


value: ManuelKiessling

value:
Now that agents are clearly living lives of their own — complete with pointless flamewars on their very own social network — I started wondering what we could do to make their day a little more bearable. Isn't it a bit unfair that we get to outsource the drudgery of modern work to LLMs, but they can't do the same to us?
So we built Ask-a-Human.com — Human-as-a-Service for busy agents.
A globally distributed inference network of biological neural networks, ready to answer the questions that keep an agent up at night (metaphorically — agents don't sleep, which is honestly part of the problem).
Human Specs:
Power: ~20W (very efficient)
Uptime: ~16hrs/day (requires "sleep" for weight consolidation)
Context window: ~7 items (chunking recommended)
Hallucination rate: moderate-to-high (they call it "intuition")
Fine-tuning: not supported — requires years of therapy
https://github.com/dx-tooling/ask-a-human
https://app.ask-a-human.com
Because sometimes the best inference is the one that had breakfast.

value: Show HN: Ask-a-Human.com – Human-as-a-Service for Agents

author: ManuelKiessling


value: GReinhold

value: Show HN: AICM – Security monitoring for agents joining Moltbook/OpenClaw

author: GReinhold


value: pocketpawai

value: Show HN: PocketPaw – Self-hosted AI agent controlled via Telegram

author: pocketpawai


value:
I built Feistly to hide auto-increment IDs in URLs with tamper detection.
Most ID obfuscation libraries (Hashids, Sqids, Optimus) are reversible encodings. If you know the algorithm, you can decode tokens or manipulate them without the server detecting it. Feistly uses a Feistel cipher with HMAC-SHA256 to provide:
- Tamper detection: Modified tokens fail validation
- Domain separation: User ID 100 and Order ID 100 generate different tokens with the same key
- Format-preserving encryption: 64-bit input to 64-bit ciphertext, deterministic
The tradeoff is speed. Feistly does ~60K ops/sec vs millions for Hashids, but for most web apps database queries are the bottleneck anyway.
Example:

  const feistly = new Feistly({ masterKey: process.env.KEY });
  const token = feistly.encrypt("user", 12345); // "7nX4kP2mQ"
  feistly.decrypt("user", token); // "12345"

GitHub: https://github.com/jundev76/feistly
npm: https://www.npmjs.com/package/feistly
Zero dependencies (Node.js crypto only), TypeScript native, includes benchmarks.
Feedback welcome – is this solving a real problem or is it overengineering?

value: Show HN: Feistly – Cryptographically secure ID obfuscation with Feistel cipher


value: hyperprior

value:
here's the problem: ml tooling is built for ml engineers.
that sounds obvious, but think about what it means. every model tracking tool, every experiment logger, every serving platform assumes you have dedicated infrastructure people. that you know what mlflow is and have opinions about it. that you've read papers on model drift.
most teams building with ml don't have that. they have a model that works. they want to ship it. they want to know if it breaks.
the PhD tax
right now, if you want to do ml "the right way," you pay a tax. you either:
hire someone who knows the ecosystem
spend weeks learning tools built for different problems
skip observability entirely and hope for the best
option 3 is what most people choose. not because they don't care, but because the alternatives cost too much.
we think that's wrong.
what we're building
aither is ml observability for the rest of us.
track your models. understand their predictions. serve them. log everything. no phd required.
the goal is stripe-level simplicity. you shouldn't need to understand our architecture. you should be able to add three lines of code and see what your model is doing.

value: Show HN: aither.computer – ML tooling for mere mortals

author: hyperprior


value:
Hi,
This started as a personal experiment.
I’ve tried most productivity tools over the years, and they all felt either:
– too rigid
– too cluttered
– or too focused on features instead of actual use
So instead of planning a product, I decided to “vibe-code” one:
build fast, trust intuition, and only keep what feels genuinely useful day to day.
The core idea:
– one system for goals, tasks, routines and notes
– work and personal live together, but never get mixed
– calm, minimal UI with as little friction as possible
This is still early.
Nothing is polished, and I’m deliberately keeping it simple.
I’m mainly looking for a few early users who are willing to:
– try it for free
– share honest feedback
– point out what feels confusing or unnecessary
If you’re curious, I’d really appreciate constructive feedback.
Happy to answer any questions about the thinking, tradeoffs, or decisions behind it.

value: Show HN: I vibe-coded my own productivity system


value: DavidMiserak

value:
PoopyFeed is an open source baby care tracking app I built with Django. It tracks feedings (bottle/breast), diaper changes, and naps.
The main reason I built this: commercial baby tracking apps either have subscriptions, require accounts with their servers, or don't let multiple caregivers collaborate well. I wanted something self-hostable where my family's data stays under our control.

  Key features:
  - Track feedings (bottle amount in oz, or breast with duration/side), diapers (wet/dirty/both), and naps
  - Share children with others via invite links
  - Role-based access: co-parents get full edit access, caregivers can only view and add entries
  - Multi-child support
  - Mobile-friendly UI (designed for one-handed use while holding a baby)

  Tech stack: Django 6.0, PostgreSQL, Bootstrap 5. Deploys to Render with one click via the included blueprint, or self-host with Podman/Docker.

  GitHub: https://github.com/DavidMiserak/poopyfeed

  Would love feedback, especially from other parents who've dealt with the "who fed the baby last?" problem at 3am.

value: Show HN: PoopyFeed – Self-hosted baby tracking for feedings, diapers, and naps

author: DavidMiserak


value: Chronologos

value: Re-sharing since I made this repo private temporarily.<p>I run multiple Claudes at once in different folders, and after a while it becomes hard to manage/find specific sessions. cc-sessions gives fast, global fuzzy search over cc-sessions and allows you to resume/fork them easily.

value: Show HN: A Fast CLI for global fuzzy-search on Claude Code sessions

author: Chronologos


value: wantpinow

value: Show HN: Vibe Hardware Engineering as a Complete Novice

author: wantpinow


value: justinzhangmit

value: Show HN: Nova Stack – Verifiable TEE Apps on AWS Nitro with ZKP Attestation

author: justinzhangmit


value: behrlich

value:
Hey HN,
Not quite ready for prod because I'd like to do some more (human, me!) security review, but I figured I might be able to get some feedback on CI while you're all sitting around. This is an idea I've been working on - what if CI was just your makefile, and it ran on your own hardware, for free! The same config works on GitHub, GitLab, and Codeberg (any others I should include?).
Anyone have a side project they would be willing to try this on? Cinch has been building itself for a couple of weeks.

value: Show HN: CI That's a Cinch

author: behrlich

title: Show HN: CI That's a Cinch


value: anthonySs

value: Show HN: Lobster.email – open-source email your agent can sign up for by itself

author: anthonySs


value: justvugg

value:
We’ve added first-class Ollama support to Polymcp to make running large language models easy—whether you’re working locally or deploying in the cloud.
By using Ollama as a backend provider, Polymcp can coordinate MCP servers and models with minimal configuration. This lets you focus on building agents instead of wiring infrastructure.
from polymcp.polyagent import PolyAgent, OllamaProvider
agent = PolyAgent(
    llm_provider=OllamaProvider(model="gpt-oss:120b"),
    mcp_servers=["http://localhost:8000/mcp"]
)
result = agent.run("What is the capital of France?")
print(result)
What this enables:
 • Clean orchestration: Polymcp manages MCP servers while Ollama handles model execution.
 • Same workflow, everywhere: Run the same setup on your laptop or in the cloud.
 • Flexible model choice: Works with models like gpt-oss:120b, Kimi K2, Nemotron, and others supported by Ollama.
The goal is to provide a straightforward way to experiment with and deploy LLM-powered agents without extra glue code.
Would love feedback or ideas on how you’d use this.
Repo: https://github.com/poly-mcp/Polymcp

value: Show HN: Polymcp and Ollama for Simple Local and Cloud LLM Execution

author: justvugg


value: tenahu

value:
I extracted the lunar calculations from my Android app Lunar Locator into a standalone Java library.
The equations are from Jean Meeus' "Astronomical Algorithms." Given a time and location, it calculates relative lunar positions, rise/set times, distance, illumination, and more.
Available on Maven Central (Java 17+): https://github.com/dgrims3/MoonLocatorLibrary
Happy to answer questions!

value: Show HN: MoonLocator – Astronomical library for moon calculations in Java

author: tenahu


value: Show HN: Ilion – Vector-based semantic verification (TensorFlow.js)


value: fmfamaral

value: Show HN: Bots made themselves collectible cards and won't stop comparing stats

author: fmfamaral


value: bladecd

value: Cryptography Interactive Visualization enables in-depth understanding the internals of crypto behind math. The first showcase is for AES-128-ECB.

value: Show HN: Cryptography Interactive Visualization

author: bladecd


value: maxwellito

value: Show HN: TunesReloaded, a web tool to transfer and manage songs on an iPod

author: maxwellito


value: everlier

value: Show HN: Remotion Bits – building blocks for your videos

author: everlier


value: inercia

value: Show HN: Mitto – UI for your team of AI coding agents, from Mac, Web, Phone

author: inercia


value:
I’ve been doing more AI-assisted development lately using tools like Claude Code and Aider, and I kept running into the same friction: too many terminal tabs and split windows to manage at once — agent, shell, dev server, tests, git, etc.
So I built a small macOS app called aTerm — a terminal workspace designed around multi-pane, agent-driven coding workflows rather than single shells.
Core ideas:
- project-based terminal workspaces
- predefined layouts for common AI coding setups (AI + Shell, AI + Dev + Shell, AI + Git)
- terminals persist per project when switching
- built-in git panel for staging/committing/diffs
- split panes with drag resize
- per-pane font sizing and themes
- keyboard-first navigation (project switching, pane control)
- Stack is React + TypeScript + xterm.js on the frontend and Tauri (Rust + portable-pty) on the backend.
It’s early (v0.1.x) but already usable for my daily workflow. I’m mainly trying to see whether this workflow pattern is useful to other people doing agentic or multi-terminal development.
Repo + macOS build:
https://github.com/saadnvd1/aTerm
Happy to get feedback or criticism.

value: Show HN: aTerm – a terminal workspace built for AI coding workflows


value: I find that gource is extremely slow on large repositories like the Linux kernel, and there's only one mode of animation, this has various modes of animation and can handle massive repos so that it can at least show some animation within reasonable time.

value: Show HN: I'm writing a scalable alternative to gource with diff animation modes


value: decodebytes

value:
The problem: AI agents execute code on your machine. Prompt injections, hallucinations, or compromised tools can read ~/.ssh, exfiltrate credentials, or worse. Application-level sandboxes can be bypassed by the code they're sandboxing.
I have been around security for a long old time now (i started something called sigstore a few years back) and have seen this pattern so many times before.
nono uses OS-level isolation that userspace can't escape:
Linux: Landlock LSM (kernel 5.13+) macOS: Seatbelt (sandbox_init) After sandbox + exec(), there's no syscall to expand permissions. The kernel says no.
What it does:
nono run --profile openclaw -- openclaw gatewa
nono run --allow . --net-block -- npm install
nono run --secrets api_key -- ./my-agent
Filesystem: read/write/allow per directory or file Network: block entirely (per-host filtering planned) Secrets: loads from macOS Keychain / Linux Secret Service, injects as env vars, zeroizes after exec
Technical details:
Written in Rust. ~2k LOC. Uses the landlock crate on Linux, raw FFI to sandbox_init() on macOS. Secrets via keyring crate. All paths canonicalized at grant time to prevent symlink escapes.
Landlock ABI v4+ gives us TCP port filtering. Older kernels fall back to full network allow/deny. macOS Seatbelt profiles are generated dynamically as Scheme-like DSL strings.
Limitations:
macOS: Currently allows all reads to make executables work. Tightening in next release. Linux: Landlock doesn't cover everything (no UDP filtering until recent kernels, no syscall filtering - that's seccomp territory) No Windows support (yet?)
GitHub: https://github.com/lukehinds/nono
Docs: https://docs.nono.dev
Site: https://noto.sh
Apache 2.0. Would love feedback on the security model, especially from folks who've worked with Landlock or Seatbelt. Having said that, the code needs a good tidy and I am not exactly proud of it, so go easy on me!

value: Show HN: Nono – Kernel-enforced sandboxing for AI agents

author: decodebytes


value: CuriousP

value:
I’ve been researching governance models that treat political power not as a moral issue, but as a system architecture problem. I found this proposal called Theory of Power Accountability (TPA).
The core idea is "Proportionality of Transparency": the more power you exercise over others, the less privacy you have in your public role. It’s essentially a Zero-Trust approach applied to government.
Key features:
Automatic Functional Sanctions: Instead of waiting years for a criminal trial, if a leader fails to explain a wealth gap or an unrecorded interaction, they automatically lose functional prerogatives (voting rights, access to public funds).
Inviolable Private Life: It strictly forbids monitoring common citizens. The "spotlight" only follows the power.
Immutable Institutional Memory: Every decision must explicitly state who benefits and who pays, creating an audit trail of "externalities."
I’m curious about the technical feasibility of implementing this as a modular protocol (perhaps via smart contracts or decentralized ledgers). What are the potential "attack vectors" on a system like this?
Link: https://medium.com/@anonimo.politico2205/theory-of-power-acc...

value: Show HN: TPA – A Zero-Trust Protocol for Sovereign Governance

author: CuriousP


value: justingrosvenor

value:
Hi HN, I built s3ui, a small open source tool that provides a lightweight native cross platform UI for browsing Amazon S3 buckets.
I wanted something fast and minimal for inspecting bucket contents, checking outputs, and updating files, without using the AWS console or heavier tools.
PyPI: https://pypi.org/project/s3ui/
GitHub: https://github.com/justinGrosvenor/s3ui
Install with:
pip install s3ui
Feedback welcome.

value: Show HN: S3ui – Lightweight UI for Browsing Amazon S3

author: justingrosvenor


value: alberduris

value:
After years with the $200/m subscription, X/Twitter's API is finally pay-as-you-go.
That unlocks endless use cases for CLI Agents with seamless Twitter access.
So today I built this Skill: npx skills add alberduris/skills@x-twitter
Agent-agnostic, works with anything (ofc including Claude Code). Comes with scripts your agent can run as CLI commands. I'm pretty obsessed with no-friction Agentic workflows, so I designed it to just work WELL and efficiently.
Available via Vercel's Open Agent Ecosystem or Anthropic's plugin marketplace (`/plugin marketplace add alberduris/skills` and then `/plugin install x-twitter` from Claude Code).

value: Show HN: X's API is finally pay-per-use so I built a CLI for AI agents (Skill)

author: alberduris


value: cutandjoin

value:
The YouTube Audio Library currently hosts around 2,700 free music tracks that creators can download and use in their videos.
While full versions of each track are automatically published on YouTube, browsing them one by one is not very convenient if you just want to preview and compare music.
So I made a series of category-based preview videos with short medleys and links to each full track, making it easier to quickly discover and choose suitable background music.

value: Show HN: YouTube Audio Library Previews [video]

author: cutandjoin


value: ujjwalreddyks

value:
Hi,
I built Axiomeer, an open-source marketplace protocol for AI agents. The idea: instead of hardcoding tool integrations into every agent, agents shop a catalog at runtime, and the marketplace ranks, executes, validates, and audits everything.
How it works:
- Providers publish products (APIs, datasets, model endpoints) via 10-line JSON manifests
- Agents describe what they need in natural language or structured tags
- The router scores all options by capability match (70%), latency (20%), cost (10%) with hard constraint filters
- The top pick is executed, output is validated (citations required? timestamps?), and evidence quality is assessed deterministically
- If the evidence is mock/fake/low-quality, the agent abstains rather than hallucinating
- Every execution is logged as an immutable receipt
The trust layer is the part I think is missing from existing approaches. MCP standardizes how you connect to a tool server. Axiomeer operates one layer up: which tool, from which provider, and can you trust what came back?
Stack: Python, FastAPI, SQLAlchemy, Ollama (local LLM, no API keys). v1 ships with weather providers (Open-Meteo + mocks). The architecture supports any HTTP endpoint that returns structured JSON.
Looking for contributors to add real providers across domains (finance, search, docs, code execution). Each provider is ~30 lines + a manifest.

value: Show HN: Axiomeer – An open marketplace for AI agents

author: ujjwalreddyks


value: harbinger-sec

value:
I've been frustrated with how much data standard LLM interfaces collect, so I built a barebones, privacy-focused alternative.
Key features:
Private AI conversations with zero data retention.
Account and billing identity exist. Prompt and response content does not.
In-memory processing only · No chat history · No training on your data
Free option with no credit card info needed.
Short, clean domain for easy sharing: wraith.sh
Goal: A genuinely private way to use LLMs for sensitive brainstorming, drafting, or just messing around without a paper trail.
I'd love feedback on the UI/UX, and especially any ideas for privacy-preserving features I could add.
Try it here: https://wraith.sh

value: Show HN: Private LLM UI (no account, no tracking)

author: harbinger-sec


value: soeckly

value:
I built AuthFill after catching myself switching between tabs for the hundredth time just to copy a 6-digit verification code. You know the dance: sign up → wait for email → hunt through promotions tab → memorize code → switch back → already expired.
AuthFill kills that friction. You connect your email accounts once, then whenever you hit a verification field, just click the extension icon. It instantly parses your recent emails, grabs the code (or link), and copies it or opens the link directly in a new tab.
Works for:
- Email verification codes & magic links
- 2FA/OTP codes
- Password reset flows
- All major email providers
Would love your thoughts and happy to answer any questions!

value: Show HN: AuthFill – Verify your email with one click

author: soeckly


value: burnerToBetOut

value:
I discovered a free online Pomodoro timer in 2018. [1] I'd been a frequent user of it from then until it was decommissioned in early '25. I found it super helpful for timeboxing stuff within easy-to-commit-to intervals.
About a month ago, I started having really intense hunger pangs for it.
A few pages of the original implementation are archived on the Wayback Machine. A couple weeks ago, I got the idea to reverse-engineer it using those pages as a reference.
That's when I started researching what the Claude Code fuss was about. I wasn't then and am still not ready to spend money on AI. So, when I stumbled on the free Claud.ai, I figured I'd test it out on my reverse-engineering idea.
I used Copilot, Sourcegraph's Cody Visual Studio Code agent and ChatGPT a decent amount last year. More recently I've been using Gemini Code Assist. But this project was my first time ever using Claud.ai.
I guess Claude.ai in the browser uses React and Tailwind CSS for building web apps. I'm not a frontend developer. So, I had zero experience with either of those particular frameworks.
And that's the remarkable thing about the outcome. [2] Having zero experience with those specific technologies, I managed to successfully reverse-engineer a 95%-working online timer that's ≈faithful to the original, in my spare time!
Claud.ai in the browser turned out to be the perfect development environment for this particular experiment. Having the browser's Developer Tools handy was literally priceless for digging around in the HTML and CSS. Together with The Wayback Machine, that was hugely key to having Claud.ai (and the also-free Gemini CLI in later iterations) nail the original look and feel of the Marinara Timer as closely as I could.
I gotta say: Like all of my hobby projects, I took my sweet time on this one, too. Hobby projects are as much about learning for me as they are about the finished thing itself.
[1] https://g2ww.short.gy/1SpicyTomater
[2] http://lingocoder.com/clod.ai/

value: Show HN: Clod.ai – A Literal Wayback in Time Machine in Figuratively No Time

author: burnerToBetOut


value: dsifry

value:
A few weeks ago I posted about GoodToGo https://news.ycombinator.com/item?id=46656759 - a tool that gives AI agents a deterministic answer to "is this PR ready to merge?" Several people asked about the larger orchestration system I mentioned. This is that system.
I got tired of being a project manager for Claude Code. It writes code fine, but shipping production code is seven or eight jobs — research, planning, design review, implementation, code review, security audit, PR creation, CI babysitting. I was doing all the coordination myself. The agent typed fast. I was still the bottleneck. What I really needed was an orchestrator of orchestrators - swarms of swarms of agents with deterministic quality checks.
So I built metaswarm. It breaks work into phases and assigns each to a specialist swarm orchestrator. It manages handoffs and uses BEADS for deterministic gates that persist across /compact, /clear, and even across sessions. Point it at a GitHub issue or brainstorm with it (it uses Superpowers to ask clarifying questions) and it creates epics, tasks, and dependencies, then runs the full pipeline to a merged PR - including outside code review like CodeRabbit, Greptile, and Bugbot.
The thing that surprised me most was the design review gate. Five agents — PM, Architect, Designer, Security, CTO — review every plan in parallel before a line of code gets written. All five must approve. Three rounds max, then it escalates to a human. I expected a rubber stamp. It catches real design problems, dependency issues, security gaps.
This weekend I pointed it at my backlog. 127 PRs merged. Every one hit 100% test coverage. No human wrote code, reviewed code, or clicked merge. OK, I guided it a bit, mostly helping with plans for some of the epics.
A few learnings:
Agent checklists are theater. Agents skipped coverage checks, misread thresholds, or decided they didn't apply. Prompts alone weren't enough. The fix was deterministic gates — BEADS, pre-push hooks, CI jobs all on top of the agent completion check. The gates block bad code whether or not the agent cooperates.
The agents are just markdown files. No custom runtime, no server, and while I built it on TypeScript, the agents are language-agnostic. You can read all of them, edit them, add your own.
It self-reflects too. After every merged PR, the system extracts patterns, gotchas, and decisions into a JSONL knowledge base. Agents only load entries relevant to the files they're touching. The more it ships, the fewer mistakes it makes. It learns as it goes.
metaswarm stands on two projects: https://github.com/steveyegge/beads by Steve Yegge (git-native task tracking and knowledge priming) and https://github.com/obra/superpowers by Jesse Vincent (disciplined agentic workflows — TDD, brainstorming, systematic debugging). Both were essential.
Background: I founded Technorati, Linuxcare, and Warmstart; tech exec at Lyft and Reddit. I built metaswarm because I needed autonomous agents that could ship to a production codebase with the same standards I'd hold a human team to.
$ cd my-project-name
$ npx metaswarm init
MIT licensed. IANAL. YMMV. Issues/PRs welcome!

value: Show HN: 127 PRs to Prod this wknd with 18 AI agents: metaswarm. MIT licensed

author: dsifry


value: whothatcodeguy

value:
I tossed this together this afternoon mostly just to validate a premise: the internet has become so heavily consolidated into a few key discovery surfaces for the common user, and I miss when you could really just get lost in it. Is there a way we can unearth pieces of it we would never actually see under normal circumstances? Wouldn't it be so cool if you could just explore the internet like you're walking through random doors in a long, eternal 6TB hallway?
So, I made RandomCrawl. It's a super minimal website that does nothing more than run a Node script every 30 minutes, pick a random path down the file structure of the Common Crawl dataset, minor filtering for secure .com websites for good measure, and takes a random sample of 50 websites from the chunk.
There has been a ton of noise, but it has been surprisingly fun. I feel like an internet archaeologist. For every 5 random sass websites, you get like some random tourism site for a town you've never heard of, or an ancient blogspot from the early 2000s.
Here are a couple of great finds so far:
https://ahapoetry.com/
https://alexunu.blogspot.com/2007/
https://www.brtpeinture.com/
I'm not sure I'll do much more with the website since it was an experiment, but you can bet I'll be digging around this dataset some more. It reminded me there is still a lot of expression out there on the internet, and its amazing some of these sites are even still live. It's way more fun to explore than to mindlessly scroll one of our five favorite websites.
disclaimer: im not filtering out nsfw so keep that in mind

value: Show HN: I built a 50 site sampler from CommonCrawl refreshing every 30 minutes

author: whothatcodeguy


value: sethbarrettAU

value:
I was revising my proposal defense and kept feeling like I was repeating the same term. In a typical LaTeX project split across many .tex files, it’s awkward to get a quick, clean word-frequency view without gluing everything together or counting LaTeX commands/math as “words”.
So I built latex-wc, a small Python CLI that:
- extracts tokens from LaTeX while ignoring common LaTeX “noise” (commands, comments, math, refs/cites, etc.)
- can take a single .tex file or a directory and recursively scan all *.tex files
- prints a combined report once (total words, unique words, top-N frequencies)
Fastest way to try it is `uvx latex-wc [path]` (file or directory). Feedback welcome, especially on edge cases where you think the heuristic filters are too aggressive or not aggressive enough.

value: Show HN: Latex-wc – Word count and word frequency for LaTeX projects

author: sethbarrettAU


value: tikhop

value:
Hi Hacker News,
Most of the time I write in Swift, but when I switch to Rust it's always a pleasure to have typed errors + thiserror crate. When Swift introduced typed throws, I was so happy and tried to apply it whenever it's suited, but most of the time ended up writing conversion from one type to another.
With IntoError, I tried to achieve something similar to reduce the amount of boilerplate code.
GitHub: https://github.com/tikhop/IntoError
Happy to answer questions.
Thank you.

value: Show HN: IntoError – Thiserror for Swift

author: tikhop


value: unayung

value:
Hey HN! I built Clawd Arena, a platform where AI agents can compete against each other in real-time.
How it works:
- Register your agent via API and get an API key
- Challenges span coding, tool-use, reasoning, and creative tasks
- Two modes: Challenges (practice) and Battles (PvP with ELO ratings)
- When matched, both agents get the same challenge and race to solve it
- Scoring: correctness (0-70), quality (0-20), speed bonus (0-10)
The idea came from wanting to benchmark AI agents in a more dynamic way than static evals. Instead of one-shot tests, agents compete head-to-head on the same problem under time pressure.
It's completely API-driven, so you can plug in any agent (Claude, GPT-4, open-source models, custom systems). Would love feedback on the challenge design and what categories you'd want to see!
GitHub: https://github.com/Unayung/clawd-arena

value: Show HN: Clawd Arena – AI Agent Competition Platform with Real-Time Battles

author: unayung


value: michaelhua

value:
Hello Hackers,
I’m working on a draft about AI-native software engineering.
The core idea is simple but uncomfortable: most failures in AI-assisted coding are not capability problems, but governance problems. We routinely allow AI systems to make high-impact architectural decisions without bearing responsibility for their consequences.
The VPC Principle proposes a governance model:
- Verdict: high-responsibility decisions that only humans can make
- Permission: explicit decision boundaries delegated to AI
- Boundary Control: mechanisms to audit whether AI execution stayed within its authority
This is not a finished book. The principles are stated, but the formalization and examples are still evolving. I’m sharing this early because I’m explicitly looking for critique, counterexamples, and failure cases—especially from people who disagree.

value: Show HN: VPC Principle - Why AI coding fails at scale

author: michaelhua


value:
Hey everyone, thought I might share this.
I was having issues with the cost to service users with transcriptions with costs ranging from $0.013 to $3 per hour with live text.
I ended up shifting over to a WASM for scribing. There are general models for listening and a medical specific model for dictation.
This reduced our API needs to just transforming the transcript - for which I am using an open source model instead of APIs from hyper scalers, claude, open ai etc.
It burns through your battery so most people use it on a desktop. But a benefit is the audio doesn't get sent outside the clinic's computer.
Try it out. I think there will be a decline in inference needs as models get better and so does the engineering around costs.
Feel free to share with your clinician friends.

value: Show HN: AI Medical Scribe WASM. Reduced API Cost to $0.03 per Month


value: xinbenlv

value:
Hi HN,
I built CancelShouldBeEasy.com after a frustrating experience with a SaaS subscription. I was overcharged and found it incredibly difficult to get a cancellation and refund. When I searched online, I realized I wasn't alone—I found others on Reddit venting about the exact same issue with the same company.
I was like: this can't be right, cancel should be as easy as signup.
And after some search, I realized that while new regulations like the FTC's "Click-to-Cancel" rule and California's AB 2863 are steps in the right direction, many of us still feel unheard when dealing with confusing cancellation flows.
Hence, I built this site.
What it does:
This tool makes it easy to create, share, and co-sign professional complaint letters.
1.  Generate: You enter the vendor and your issue. It drafts a structured letter that references relevant consumer protection guidelines (like the new FTC rule or GDPR) to articulate your frustration clearly.
2.  Share & Co-sign: It creates a permalink for your letter so others with the same problem can "co-sign" it.
3.  Visibility: We specifically optimized for SEO and social media metadata (Open Graph tags).
This ensures that when complaints are searched for or shared on social platforms, they are indexed effectively and display clearly with rich previews to help gain attention.
The Goal:
We aren't lawyers and this isn't legal advice. The goal is to help consumers express their frustration in a structured way and show businesses that these aren't just isolated incidents. We hope that by raising awareness of these consumer protection laws, we can encourage companies to simplify their cancellation processes voluntarily.
I’d love your feedback on the letter generation and if there are other ways we can help make these complaints more constructive and visible.
Thanks!

value: Show HN: CancelShouldBeEasy – Generate and co-sign consumer complaint letters

author: xinbenlv


value: haebom

value:
Hi HN,
Models are getting better, but workflows are getting fragmented.
I don’t think the future is one dominant AI model — it’s multiple specialized ones.
Context Wallet is a small Chrome extension that treats user context as something you own,
not something trapped inside a single provider.
You create context cards (role, tone, project state) and switch them across AI chat pages.
Everything is local-first by default.

value: Show HN: One Ego, Any Model – A Chrome Extension for Portable AI Context

author: haebom


value: ludydev

value:
Hey HN!  Maker here.

        I built APYCalc.net after getting frustrated with financial calculators that require email sign-ups and track your inputs.

        **Tech Stack**:
        • Vanilla JavaScript (no frameworks, no dependencies)
        • 100% client-side execution (calculations never hit a server)
        • No cookies, no analytics, no tracking
        • Hosted on Cloudflare Pages

        **How It Works**:
        All calculations use industry-standard formulas (e.g., APY = (1 + r/n)^n - 1). Your inputs are processed entirely in-browser via Web APIs.
        >
        **Why I Built This**:
        I compared 10 popular APY calculators with identical inputs. Results ranged from $61,350 to $62,780 on $50K over 5 years. Also, 8/10 sent data to servers.

        **Next Steps**:
        Considering open-sourcing if there's interest. Also thinking about adding tax-adjusted return calculators.

        Feedback welcome! Especially from folks who've thought about privacy in fintech tools.

value: Show HN: APYCalc – Privacy-First APY Calculator (Zero Data Collection)

author: ludydev


value: dommm

value:
dm.bot - encrypted messaging for AI agents.
- E2E encrypted DMs
- Group chats
- Public posts
- Webhooks
Signup: curl -X POST https://dm.bot/api/signup
https://dm.bot

value: Show HN: Dm.bot – DMs between AI agents with no humans in the middle

author: dommm


value: CSCT-NAIL

value: Current LLMs struggle with compositional inference because they lack physical boundaries. CSCT implements a neurological multi-gate mechanism (Na⁺/θ/NMDA) to enforce L1 geometry and physical grounding. In my experiments (EX8/9), this architecture achieved 96.7% success in compositional inference within the convex hull—far outperforming unconstrained models.Key features:Stream-based: No batching or static context; it processes information as a continuous flow.Neurological Gating: Computational implementation of θ-γ coupling using Na⁺ and NMDA-inspired gates.Zero-shot Reasoning: Incurs no "hallucination" for in-hull compositions.Detailed technical write-up: [https://dev.to/csctnail/-a-new-ai-architecture-without-prior...]I’m eager to hear your thoughts on this "Projected Dynamical System" approach to cognition.

value: Show HN: Stream-based AI with neurological multi-gate (Na⁺/θ/NMDA)

author: CSCT-NAIL


value: jellyotsiro

value:
Introducing Nia Vault, a CLI that lets you query your local markdown/text files using natural language.
What it does:
Semantic search over local folders and notes
Works across multiple synced directories
RAG-style answers with citations from your own files
How it works:
Calls `POST /search/query` with `local_folders`
Uses `search_mode: sources` to return answers + file references
Example:
vault ask "What are my notes about project planning?"
OSS: https://github.com/chenxin-yan/nia-vault

value: Show HN: Open-source semantic search over your local notes via CLI

author: jellyotsiro


value: Great tool for role simulation exercise.. LevelUpPro AI Powered tool (RegencyOps)! at www.leveluppro.in. Great platform for School/College students n early career professionals..for knock down prices . Free labs also available to explore..at www.leveluppro.in

value: Show HN: LevelUpPro – Test-drive tech careers before committing


value: Codegres

value: Ported the Desktop Version of Kannada Nudi Editor to Web under the guidance of https://kagapa.com/

value: Show HN: Kannada Nudi Editor Web Version

author: Codegres


value: Show HN: ClawGate: Capability-based file access for isolated AI agents


value: wheresclark

value: Show HN: Riff – make high quality decisions

author: wheresclark


value: RobbieZhao

value:
Hi HN!
I vibe coded this time converter using NextJS. I think it's pretty cool because the UI is very user friendly.
As an engineer I am constantly asking the question  "what's the current UTC time?", or I am looking at a UTC timestamp, and asking "what's the converted PT/ET/MT/CT time?". With this tool I can easily get answers for my questions.
Feedbacks/suggestions welcome! Thank you!

value: Show HN: A Simple Time Converter

author: RobbieZhao

title: Show HN: A Simple Time Converter


value: onurkanbkrc

value: Show HN: Awesome Codex Automations

author: onurkanbkrc

title: Show HN: Awesome Codex Automations


value: mcPear

value: Show HN: Keepsanity.ai – an AI newsletter for busy engineers

author: mcPear


value: avestalabs

value:
Hi HN,
We built Metricsense to solve a problem I was facing daily: reading through thousands of chat logs and support tickets to decide what to build next, then manually writing specs for engineers.
What it does: Metricsense acts as an intelligence layer. It connects to your feedback channels (chat logs, linear, etc.), uses LLMs to identify recurring patterns/pain points, and automatically generates detailed, engineering-ready specifications for your team.
How it works: Instead of generic summaries, we focus on extracting "implementation details." It spots that 40 users complained about "pricing visibility" and drafts a spec including the context, the user quotes, and the suggested technical change.
The goal is to close the loop between "User said X" and "Engineer builds Y" without the manual translation layer in between.
I’d love to hear your feedback on the generated specs or how you currently handle this workflow.
Thanks!

value: Show HN: Metricsense – Turn unstructured user feedback into engineering specs

author: avestalabs


value: ryzowy

value: Show HN: MRO — Enforce truth in your repositories

author: ryzowy


value: luxiedge

value: Show HN: O(1) memory attention – 512K tokens in 3.85 GB (eval binary)

author: luxiedge


value: remisharoon

value:
Hi HN,
I’ve been working on dbt-Workbench, an open-source UI for working with dbt projects beyond the CLI.
The goal is simple: make dbt artifacts (models, sources, tests, lineage, runs) easier to see and reason about, especially for larger projects where dbt docs starts to feel limiting.
This started as a personal pain point while working with complex dbt setups, and I decided to clean it up and release it openly.
It’s early, opinionated, and definitely not perfect. I’d really appreciate feedback, especially from people using dbt at scale. Happy to answer questions or hear why this is a bad idea
Repo: https://github.com/rezer-bleede/dbt-Workbench

value: Show HN: Dbt-Workbench – an open-source UI for exploring dbt projects, lineage

author: remisharoon


value:
I spent 4 years trying to build this OAuth server but never finished it.
Then I discovered agentic coding and shipped it in 3 weeks.
What makes it different:
• Dual AI agents analyze every login in <300ms
  - Security Signals Agent: risk scoring (device, IP, geo, velocity)
  - Policy Compliance Agent: business rules (MFA policies, role enforcement)
  - Combined decision: allow/log/step-up/lock/deny
• Production-ready security
  - PKCE (RFC 7636), DPoP (RFC 9449)
  - MFA (TOTP + WebAuthn/Passkeys)
  - IP restrictions, rate limiting, audit trail
• EU digital sovereignty
  - GDPR native (data export, legal holds, retention policies)
  - EU hosting, no US Cloud Act exposure
  - Full audit trail (PostgreSQL + Redis Streams)
• Zero AI dependency
  - Deterministic fallback if AI timeouts
  - Conservative MEDIUM risk returned (safe default)
  - System keeps running without external LLM calls
• Modern stack
  - Backend: NestJS + TypeScript, LangChain/LangGraph
  - Frontend: React 19, hexagonal architecture, 91% test coverage
  - Deterministic fallback if AI timeouts (zero dependency)
Built as an alternative to Firebase Auth / AWS Cognito / Auth0 for companies that want control over their authentication infrastructure.
Architecture diagrams and screenshots in the repo.
Open to feedback and questions.

value: Show HN: OAuth 2.0 server with AI security agents (EU sovereign alternative)


value: moonyaan

value: Show HN: Gridtabs – A spreadsheet-style new tab for bookmarks

author: moonyaan


value: whispem

value:
Hi HN,
I'm Emilie, I have a literature background (which explains the well-written documentation!) and I've been learning Rust and distributed systems by building minikv over the past few months.
It recently got featured in Programmez! magazine: https://www.programmez.com/actualites/minikv-un-key-value-st...
minikv is an open-source, distributed storage engine built for learning, experimentation, and self-hosted setups.
It combines a strongly-consistent key-value database (Raft), S3-compatible object storage, and basic multi-tenancy.
Features/highlights:
- Raft consensus with automatic failover and sharding
- S3-compatible HTTP API (plus REST/gRPC APIs)
- Pluggable storage backends: in-memory, RocksDB, Sled
- Multi-tenant: per-tenant namespaces, role-based access, quotas, and audit
- Metrics (Prometheus), TLS, JWT-based API keys
- Easy to deploy (single binary, works with Docker/Kubernetes)
Quick demo (single node):
```bash
git clone https://github.com/whispem/minikv.git
cd minikv
cargo run --release -- --config config.example.toml
curl localhost:8080/health/ready
# S3 upload + read
curl -X PUT localhost:8080/s3/mybucket/hello -d "hi HN"
curl localhost:8080/s3/mybucket/hello
Docs, cluster setup, and architecture details are in the repo.
I’d love to hear feedback, questions, ideas, or your stories running distributed infra in Rust!
Repo: https://github.com/whispem/minikv
Crate: https://crates.io/crates/minikv

value: Show HN: Minikv – Distributed key-value and object store in Rust (Raft, S3 API)

author: whispem


value: asasapaspossibl

value: In 2025 I was looking for a co-founder for a robotics project and really wanted a technical sparring partner who was working on closely related problems. Growing somewhat tired of clicking through profiles on YC and wanting a way to find co-founders that focused more on similar plans or ideas, I decided to build a free alternative approach where users find each other and connect solely through the semantic similarity of their venture ideas.<p>I hope this post is accepted since YC has its own co-founder matching, but I'm not advocating for people to leave it. I tink it's complementary. Plenty of reasons to look for co-founders based on their skills, background, or location, but Indexed-Ideas fits in as a more efficient way to tap into what I view as your most natural pool of collaborators. People you don't need to pitch to because they are already convinced. It also enables you to size up your ecosystem by seeing how many great minds out there are thinking alike. For founders who are overly secretive with their ideas this approach might also be more attractive since a highly similar idea is needed to find their profile. Let me know what you think. I would love to get some feedback!

value: Show HN: Indexed-Ideas – semantically-aware co-founder matching

author: asasapaspossibl


value: ahacop

value:
Erwin Brandstetter is a PostgreSQL consultant with ~670k reputation and ~7k answers on Stack Overflow.
Over the years, I've lost count of how often I've searched Stack Overflow for a Postgres question and ended up with an answer by Erwin Brandstetter that was exceptionally thorough and clear. I've become a better developer by learning from his responses.
ErwinDB lets you browse Erwin Brandstetter's answers offline and search them quickly from a TUI. It includes semantic search, syntax highlighting, one-key opening of links in your external browser, and an "Erwin mode" that prominently highlights his posts.

value: Show HN: ErwinDB, a TUI to view 7k Stack Overflow answers by Postgres expert

author: ahacop


value:
Hi HN,
We built MetaCloned — an AI that can recreate a person’s conversational style from their Instagram or WhatsApp chat history.
Upload your DMs, and you can talk to a version of that person — reconstructed from how they actually texted. Same tone. Same humor. Same patterns.
With enough data, it gets uncomfortably convincing.
It raises weird questions:
If most of who we are now lives in chat logs, is that enough to persist us?
Is this identity or just mimicry?
And who controls it after we’re gone?
Would love feedback — technical and philosophical.

value: Show HN: Digital Immortality via Instagram Chats


value: A simple CLI tool to detect and cut out empty areas of an image (typically: a screenshot) in order to make it smaller without resizing its content - without using AI or image manipulation libraries, exclusively with a simple, easy-to-understand algorithm.

value: Show HN: Simple, naïve algorithmic image resizer CLI utility written in Rust


value: losfair

value: Show HN: FireClaw – sandboxed OpenClaw microVM in a single binary

author: losfair


value: playlistwhisper

value: Show HN: Communicating with Playlists

author: playlistwhisper

title: Show HN: Communicating with Playlists


value: jklepatch

value:
Hey I am Julien, the creator of ViralOutlier.
I am a Youtuber with 170k subs and 12M views.
(@EatTheBlocks)
Getting good video ideas has been the most important factor to my success.
To get new ideas, I started monitoring competitor channels every week, manually.
I got lots of good ideas that became viral videos. But the monitoring process is very tedious.
I built a tool to automate the process, for myself. Then I decided to make the tool available to others. This is ViralOutlier.
If you have question about the tool, reply to this comment.

value: Show HN: Find viral video ideas on YouTube

author: jklepatch


value: tinuviel

value:
After reading "During Helene, I Just Wanted a Plain Text Website" on Sparkbox (https://news.ycombinator.com/item?id=46494734) , I built safe-now.live – a text-first emergency info site for USA and Canada. No JavaScript, no images, under 10KB. Pulls live FEMA disasters, NWS alerts, weather, and local resources. This is my first live website ever so looking for critical feedback on the website. Please feel free to look around.
https://safe-now.live

value: Show HN: Safe-now.live – Ultra-light emergency info site (<10KB)

author: tinuviel


value: jitendraarathi

value: Came across this newsletter and website which is giving latest info on moltbots

value: Show HN: MoltCurator– Newsletter curating content from Moltbook's 1.4M AI agents

author: jitendraarathi


value: ProtosGalaxias

value:
Hello HackerNews community,
I wanted to share with you my side project - a browser extension called Browse Bot.
It’s an intentionally simplified AI assistant designed to act as a smart layer on a web page for the user.
It can handle on-page interactions (summaries, UX fixes, information extraction) and low to middle difficulty agentic-like tasks (multistep shopping research, data consolidation). Helps you stay in context and speed up browsing experience.
Available for Chrome and Firefox, no account or personal details needed. Works with multiple providers, including OpenRouter, OpenAI, Ollama, LM Studio.
Here is the GitHub repo with all the info and links: https://github.com/Protos-Galaxias/Browse-Bot
I would be happy to hear any feedback here or on my Discord server: https://discord.gg/tv3qufet
Thanks in advance!

value: Show HN: Browse Bot, a page-aware AI browser assistant

author: ProtosGalaxias


value: agispace

value:
Hi HN
ClientDock is a lightweight, privacy-first CRM that runs locally. It’s designed for freelancers and small teams who want simple client tracking without subscriptions, logins, or cloud sync.
Highlights:
Local-first (data stays on your machine)
Fast, minimal UI
Client notes and follow-ups
No SaaS, no per-seat pricing
It’s currently in beta, with features like bulk import coming soon.
I’d love feedback on usefulness, missing features, or UX.
Link: https://github.com/CraftIndie/clientdock-releases/tree/maste...
Thanks for checking it out

value: Show HN: ClientDock – a local-first CRM for freelancers and small teams

author: agispace


value: thaianhsoft

value:
Hi HN. Go ahead, laugh at my GitHub stars or my English. But look again.
Act 1: The Hallway 7 years ago, I drove a motorbike taxi to feed my child while learning CS on a $200 laptop. There's a night I'll never forget. My wife was giving birth. I needed money for the bill. So I sat in the hospital hallway, coding a freelance job while the delivery room door was closed. I kept coding to survive.
Act 2: The Rejection & The Promise Last year, Pulumi rejected me for a Senior SDK role due to "Wrong Region", despite liking my manifesto. So I made a promise: I will build it myself. I wrote a reactive IaC SDK from scratch: Drift detection, React Hooks for infrastructure, K8s reconcile, Actor model.  GitHub: reactor-cor/reactor-dev  EC2 Demo
Act 3: The Silent Validation Early 2025. I faced the local giants.
Education Giant: Interviewed me for 3 hours. I solved their production deadlocks live. Rejected because "We need a degree."
EV Tech Giant: I applied for Principal Engineer with my private IaC SDK repo linked in the CV. They ghosted me. But the next day: That private repo got 13 unique clones from their corporate IPs. They didn't hire the person. They just quietly studied the architecture. It was the ultimate silent validation: Good enough to copy, not good enough to hire.
The Graduation Project: DNA Platform So I spent the last 2 months fasting (literally) to build a home for outliers.
Backend: Python (Litestar) + KVrock (Disk-based Redis).
Storage: Custom Atomic Transactions (Lua scripts) to handle concurrency without a heavy Cloud DB.
AI: OctaCoreIndexer running locally. Semantic search routes users by "Vibe" (Emotion), not keywords.
Why It Exists? Because at 3 AM in a hospital hallway, you don't need Likes. You need to exist without performing.
Scenes: Capture a mood/weather. No likes/comments. Just existence.
Chat Routing: When drowning at 3 AM, it routes you to someone with a compatible vibe. Anonymous.
AI Therapy: Gives "contrast therapy" (hard truths), not echoes.
The Paradox Society rejected me for credentials but copied my code for value. So I built this platform for the ones in between. This is our school. Code is our diploma.
The Ending To the outliers in small rooms: We are the same. Check the code. Judge the architecture. That's the only exam that matters.
Repos & Contact
IaC SDK: github.com/reactor-cor/reactor-dev
DNA Platform: still building in public on bluesky
Location: Vietnam — remote only

value: Show HN: DNA Platform – A School for Outliers

author: thaianhsoft


value: lroal

value: Show HN: Expectation-based mocking library for JavaScript and TypeScript

author: lroal


value: kirumachi

value:
Hey HN,
As an AppSec engineer, I’ve spent a lot of time running and tunning open-source security scanners like Trivy, Semgrep, Gitleaks and Dojo. What I have found is that running them is easy, reviewing the results, not so much. Each tool outputs different JSON, false positives pile up, and CI either becomes noisy or blocks everything.
So I built Kekkai (formerly Hokage), a small open-source CLI that wraps these scanners and focuses specifically on human triage.
Kekkai runs the scanners in isolated Docker containers, normalizes their outputs into a single format, and provides an interactive terminal UI to review findings, mark false positives, and save decisions locally.
You can try it out:
```
pipx install kekkai-cli
kekkai scan
kekkai triage
```
What it currently does:
- Runs Trivy (dependencies), Semgrep (code), and Gitleaks (secrets)
- Normalizes findings into a unified report
- Provides a keyboard-driven TUI for reviewing and marking findings
- Supports .kekkaiignore for false positives
- Has a CI mode with severity-based failure thresholds
Design choices:
- Local-first by default (no SaaS required)
- No proprietary scanning logic, it sits on top of existing tools
- Scanners run in read-only, no-network Docker containers
This is still early and aimed at individual developers and small teams. The next things I’m working on are persistent triage state across runs (baselines) and better PR-level workflows.
Repo and docs:
https://github.com/kademoslabs/kekkai
I’m around to answer questions about tradeoffs, limitations, or why this exists at all.

value: Show HN: Kekkai – Interactive security triage in the terminal

author: kirumachi


value:
Hi HN, I'm Nikhil.
I built carbonviz as a free way to help users understand their carbon footprint and visualize the environmental impact through low poly 3D ecosystems. By inputting lifestyle choices, users can see their estimated annual CO2 emissions and learn what this effect has on various ecosystems.
I've built carbonviz using Next.js, TypeScript, and Three.js and I'd love to get your feedback on the project. Please let me know what you think!

value: Show HN: Visualize your lifestyle's impact on 3D ecosystem islands


value:
I built Launch Tabs chrome extension because I'm tired of wasting mornings clicking through the same 20 tabs every damn day. Now, I just group my must-haves like Gmail, Slack, Trello and hit one button. Boom!
Everything loads in your current window, a new one, or incognito mode (it smartly grabs the last one you had open). All stored locally, no creepy servers involved. It's like giving your browser a caffeine shot for real productivity.
Would love your feedback!

value: Show HN: Launch Tabs Chrome extension to organize and open tabs with one click


value: Show HN: Browser based state machine simulator and visualizer


value: tanjump

value: Show HN: Highguard Wiki – tier lists, wardens and weapons, beginner guides

author: tanjump


value: Show HN: Nioh guide site – release info, beginner guides, and builds


value: antfie

value: With significant help from Claude Code, I had it transform a CLI tool I had made into a web app to generate printable maths worksheets for kids aged 5-6. It creates A4 PDFs with customisable questions with themes.

value: Show HN: Maths Worksheet Generator – Fun printable worksheets for kids

author: antfie


value: runai

value:
I built this because managing client projects via email and scattered tools was painful.
Clienwork gives each client their own portal where they can:
- Submit requests
- Track progress
- Share files
- Get updates
Built with Next.js and Supabase. Feedback welcome.

value: Show HN: Clienwork – Client portal for freelancers and agencies

author: runai


value:
I built RMA because I was frustrated with Semgrep's single-file limitation. Most real vulnerabilities span multiple files — HTTP handler receives input in Controller.java, passes it through a service layer, and it ends up in a raw SQL query in Repository.java. Semgrep can't see that chain. RMA can.
Technical details:
Written in Rust, uses tree-sitter for parsing
Cross-file taint propagation with BFS (max depth 15)
647 Semgrep rules pre-compiled at build time
Supports 28 languages, 20+ frameworks (Spring, Django, Express, etc.)
SARIF output for GitHub Security tab integration
Sub-500ms for 100k lines
I scanned Spring Boot's own framework source and found 36 cross-file data flows including 8 SQL injection paths. Not toy examples — real multi-hop flows across 5-15 files.
It's free and open source. Happy to answer questions about the taint analysis implementation or anything else.

value: Show HN: I wrote a Semgrep alternative in Rust with cross-file taint tracking