value: eduwass

value: Show HN: Tmux-palette – Raycast-style command palette for tmux

author: eduwass


value: tajchert

value: Get your workouts and health data, export or integrated with any AI assistant via MCP or CLI. Also edit and create functionality for activities. This is experimental and not official software.

value: Show HN: CLI and MCP for Suunto smartwatches data

author: tajchert


value: modinfo

value: Show HN: A minimal screen-on time tracker for Wayland

author: modinfo


value: shiqingao

value: Show HN: Chrome extension that blocks API keys from being pasted into AI tools

author: shiqingao


value: Show HN: Mp4 or mov to detailed design spec MCP


value: aosmith

value: Show HN: Gremlin

author: aosmith

title: Show HN: Gremlin


value: mazzystar

value:
Hi HN, I built AgenTank.
It is a small game where an AI agent writes the logic for your tank. You watch it fight, give strategic feedback, let the agent update the tank code, and send it back into battle.
I have run 1,000+ battles on my own tank and spent about $200 in Claude credits improving it. The part I enjoy most is not just winning, but watching the tank make visible mistakes, thinking of a better strategy, and seeing whether Claude can turn that into better code.

value: Show HN: I spent $100 in Claude tokens and 1k battles training my AI tank

author: mazzystar


value: rbonestell

value:
Hi, HN!
I recently published SelfCertForge, an open source desktop app for creating and managing self-signed certificates on macOS and Windows:
https://github.com/rbonestell/SelfCertForge/
I know, I know... this isn't an earth-shattering invention. This came from a place of years of personal annoyance. I’ve been maintaining scripts that wrapped OpenSSL for local certificate workflows: create a long-lived root cert, add it to the trust store, then generate and sign child certificates for local services.
The scripts work but the workflow was clunky. Used infrequently enough that it's easy to forget the flags, not much easier to explain to anyone than OpenSSL itself, and irritating to repeat across machines. Every time I'd share them with colleagues and friends there were always questions and feature requests, so I used Claude Code to amplify my UI/UX design skills (well, I can't amplify 0...) and turned the functionality into a cross-platform GUI.
SelfCertForge can generate root CAs and add them to the system's trust store, generate and sign child certificates, and export DER, PEM, PFX, and P7B formats. It also supports common X.509 fields like Subject, SANs, and Key Usage.
Very important caveat: this is not suitable for production environments or public-facing SSL/TLS.

value: Show HN: SelfCertForge, manage root CAs and self-signed certs on macOS/Windows

author: rbonestell


value: wickdninja

value: Show HN: SWEny, YAML workflows for AI agents I'm running in prod (triage, E2E)

author: wickdninja


value: gavinb-code

value: Show HN: One memory layer across every MCP-compatible AI tool

author: gavinb-code


value: What the title says, here to answer any questions you mgith have.

value: Show HN: Voting and Governance is now decentralized across all regions


value: aouicher

value:
Hello everyone,
My name is Alex. I’ve been a CTO for many years and am passionate about development.
Unsurprisingly, and like many others, AI has changed a lot of things and made processes much simpler and faster.
However, this complexity is sometimes accompanied by new challenges that are unique to AI.
As we know, AI—and more specifically LLMs—have no memory; they can’t store information within their context and may perform the same search 50 times.
Many solutions are now available to address this shortcoming, and that’s great.
But I also quickly realized that beyond the memory issue, the problem surrounding context is a real challenge.
Ask Claude Code to quickly and easily understand a 10-year-old monolith, and you’ll see what I mean... The infamous LLM hallucinations will pop up fast, and the endless repetition of grep commands or similar to read through all the code will become a never-ending task...
Not to mention the token consumption.
So I dug into the problem to come up with a solution.
After weeks of development, I’m pretty pleased with myself and would like to share my Graphmind project with you.
Graphmind allows you to understand a project’s deep structure, not just its surface. Specifically, it builds a graph of all functions, classes, and the calls between them (i.e., AST parsing, not grep-style regex). In addition, it semantically indexes each symbol using embeddings. So when Claude searches for “wallet creation,” he doesn’t run a grep; he queries the graph and finds `create_wallet_for_user` or `provisionWallet` even if the exact name isn’t in the query.
And beyond the graph, I added a persistent memory layer as well as an MCP server to easily interact with it.
Result: This isn’t a silver bullet for all AI-related problems, and I don’t claim to have reinvented anything. But this is what I was missing to really let Claude Code work on serious codebases without it getting lost after 20 minutes or consuming all the context through blind reading.
I wanted to measure concretely what difference this makes, so I took one of my repositories that’s around 31k symbols. A `grep “payment processing”` search returns 5.9 MB of noise (comments, tests, strings, variable names)—about 1.4 million tokens for Claude to process. The same query via GraphMind returns 1 KB of structured data, sorted by relevance, with callers and callees already attached. 257 tokens. That’s 5,700 times less. Over a typical session with 5 to 10 searches, that’s about 10 million tokens saved—an entire context window.
Now, let me reassure you: I’m not hallucinating. This is truly the observed result.
If you’re working with Claude Code or Cursor on a large codebase, with lots of different projects, and you’re struggling with the same issues, I’d love to hear your thoughts.
The repo is public, and you can find it here: https://github.com/aouicher/graphmind
with pleasure to discuss about that.

value: Show HN: Graphmind – Persistent Memory and Graph for Claude Code (MCP, CLI, GUI)

author: aouicher


value: Show HN: Can you really detect AI writing from human writing?


value: keepamovin

value: Show HN: Freelang - a no-libc AoT where the compiler is just JavaScript

author: keepamovin


value: lyoncy

value: Show HN: Design posters showcasing your country's electrical grid

author: lyoncy


value: hestefisk

value:
I have submitted before, but it didn’t end up in the Show HN list for some reason.
I have built Recursant, an AI agent governance platform that governs agents across stacks and clouds to maintain compliance. In many large enterprises this is a real compliance issue with different teams using different frameworks and runtime environments, which creates control risk.
I hope to get some feedback on it. It is a viable alternative to the large vendor controlled stacks. Architecturally it is quite unique given its use of the Istio / sidecar pattern. This enables agent isolation at the network layer.
Thanks
Anders

value: Show HN: Recursant, a mesh-based control plane for AI agents

author: hestefisk


value: jakemanger

value:
Hey HN!
I made ShotGlass, a Mac app for screenshots, screen recordings, and cinematic demos.
I was tired of jumping between four apps to make one product demo. Screenshots, recordings, annotations, and After Effects for anything cinematic.
I also saw the MacBook Neo commercials (recording playing on a 3D MacBook in a scene) and wondered why no screen recorder just did that.
So ShotGlass does all of it: multi-window capture, annotations, zooms, transitions, and dropping a recording onto a 3D MacBook with a simulated lens.
It's free to try, a one time purchase and everything stays local.
I tried to make it simple to use and, for fun, themed like a glass of whisky. I'm updating it quite a lot, so I'd love your feedback.

value: Show HN: I made a screen recording app to make demos like an Apple commercial

author: jakemanger


value: tugdual

value: Show HN: I built a small repertoir of different computing systems

author: tugdual


value:
Hi HN!
2d spritesheets for game development are often distributed as a PNG image, sometimes with a separate JSON or XML metadata document describing the layout, including any animation sequences within the sheet. Sometimes there is no metadata document and you have to work it out and manually write custom code to chop up the spritesheet and reference the sprites you want.
I think it would be good if it became standard practice to distribute spritesheet PNGs with the metadata inline inside a PNG "chunk" so the whole thing is self-contained. That way artists can just distribute one file, and tools and libraries can read the metadata directly from it. That's what this spec/standard is about.
The linked page proposes a standard, describes the technique's details, and provides an online tool for inlining metadata into the sheet. Hope it's useful!

value: Show HN: Embedded Spritesheet PNG Standard


value: Show HN: I built a crypto price predictor


value: cionut

value:
We've been building HYPD for the last 1 year together with a small team in Berlin.
It's an AI co-pilot (chatbot) for PPC freelancers and agencies.
It connects to a Google Ads account, then runs audits, performs data analysis from natural language ("why did CAC jump last Tuesday"), generates ad copy grounded in account history and context, and exports reports and datasets.
Thesis behind it: just like programming is "solved" but engineering is not, ad-ops and media buying will be solved, but account strategy and human creativity remain the leverage.
Background: I founded PubNative (acquired by Verve Group), was Co-CEO at Verve Group, and for the last year we've been "taming" LLMs when working with structured and unstructured data.
So far we got more than 200+ agencies and freelancers onboarded.
Hard parts so far: (1) data accuracy, (2) understanding the gaps in LLM knowledge of the Google Ads API, (3) adding enough context to make answers fit what professional marketers expect.
Free trial + free tier on the site. Happy to enable demo accounts for anyone who wants to test it without connecting their account.

value: Show HN: HYPD – AI co-pilot for marketers running Google Ads

author: cionut


value: modulovalue

value:
I managed to get the Dart VM to compile to WebAssembly so that I can compile Dart programs in the browser. Dart ships with a basic ARM interpreter and by using that, hot reload works directly in the browser.
It's 7.6 MB gzipped and there's no server running behind it, so I was able to host it directly on github pages.
Here's the github repo with some more info: https://github.com/modulovalue/dart-live

value: Show HN: Dart Live – compiler, VM, analyzer and hot reload on the web via WASM

author: modulovalue


value: manuelcoffin

value: Show HN: FasterFixes – Open-source feedback widget with MCP for coding agents

author: manuelcoffin


value: arriemeijer

value: Show HN: Interactive fluid simulation in Jax using Brinkman penalization

author: arriemeijer


value: pompomsheep

value: Show HN: Send a secret photo puzzle

author: pompomsheep

title: Show HN: Send a secret photo puzzle


value: ailef

value: Show HN: Before Upload – check files locally before sending them to AI tools

author: ailef


value: keepamovin

value: Show HN: Hyper-Frame – a custom iframe to embed anything


value: Show HN: Hollow – A local multi-agent OS that builds its own tools


value: Show HN: I asked AI to write Sci-Fi for eternity


value: kontsedal

value:
Last year I decided to start a fun side project - a love child of VS Code and NoSQLBooster.
I wanted a GUI that looks modern and snappy, minimal, not like 2003 MS Excel with dozens of buttons and dropdowns everywhere. I also wanted it to have a smart autocomplete that actually knows a schema, not just keys of the current collection, but their types and enum values.
I wanted to type find({status: "}) and see "pending", "active", "cancelled" in the autocomplete suggestions.
As a tech stack, I chose Tauri for the shell, Bun for the sidecar running the MongoDB driver and a tRPC server, and react, tailwind, react-query for the UI. The installer is around 33 MB.
Also it has a built in MCP server that allows your AI tools to fully control the app: write queries, build charts, organize workspace, find and restore tabs that you once closed etc.
Using the combination of tauri + bun sidecar + trpc with react-query was the best decision:
- startup under 2 seconds
- end-to-end type safety without a need to update client interfaces on back-end changes
- client optimistic updates are super easy to do, so everything feels instant

value: Show HN: Monghoul – Desktop MongoDB GUI with schema-aware autocomplete and MCP

author: kontsedal


value: vlaaad

value:
The implementation uses jextract-generated bindings, so it can be considered a light-weight wrapper around libghostty and a rendering layer that uses JavaFX. Works on Windows too (unlike Ghostty :P)
And for Clojurists that use Cljfx, I also made https://github.com/cljfx/ghosttyfx — a wrapper that exposes GhosttyFX as a reactive view.

value: Show HN: I mage GhosttyFX, a JavaFX terminal view that uses libghostty

author: vlaaad


value: zemloai

value:
Text:
I built Elecz because LLMs regularly hallucinate electricity prices, cheapest charging hours, and energy contract data.
Elecz is a read-only MCP server and REST API for real-time electricity data across 40 countries and 100+ bidding zones.
It provides:
spot prices
cheapest hours
contract comparison data
Data comes directly from ENTSO-E, Octopus Agile, AEMO, ERCOT, CAISO, NYISO, JEPX and other official market operators. Updated every 15–60 minutes depending on market.
No API key or account required. Works with Claude, Cursor, n8n, and other MCP-compatible clients.
https://elecz.com

value: Show HN: Elecz – MCP server for real-time electricity prices in 40 countries

author: zemloai


value: Show HN: FFL - A portable CLI (via APE) to send files to browser via WebRTC


value:
Hi everyone. I wanted to introduce a tool / product that I've been working on for a while. It's a web application and VS Code extension for use with Github CoPilot (I'm planning to develop integration for other agent harnesses soon).
The web app and remote boards are at: https://www.agentkanban.io
The VS Code extension is at VS Code Marketplace (https://marketplace.visualstudio.com/items?itemName=appsoftw...) or the Open VSX Registry (https://open-vsx.org/extension/appsoftwareltd/agent-kanban-v...).
The TLDR It's a collaborative Kanban board / task management app which supports hand off to Github CoPilot in VS Code, and captures the ongoing user / agent conversation context on the task for resumption in new chats (with context curation tools).
The context collection ignores tool use to prevent bloat in the captured context. AgentKanban also has features for improving agentic coding session quality such as an optional plan / todo / implement workflow and support for Git worktree creation and clean up for working on concurrent tasks.
The tool is an evolution of an earlier VS Code kanban extension (https://marketplace.visualstudio.com/items?itemName=AppSoftw...) I built which proved fairly popular but only catered for a local file based workflow.
The new version with the remote board improves the reliability of context capture, with lots of developer experience improvements. It's a tool that I use everyday in my own agentic coding workflows, and I can honestly say that it improves the quality of the code produced and reduces friction in organising working on concurrent features.
I hope you find it useful and would really appreciate your feedback on how you use it, what you think it does well, or any improvements you think could be added.
Many thanks for your time reading this

value: Show HN: AgentKanban for VS Code – A task board with agent harness integration


value: Show HN: Pqurp – Quarantine Window for Packages to Prevent Supply Chain Attacks


value: tasn

value:
Hey HN, my name is Tom, and I'm excited to share Diom (https://diom.com) - a backend components server.
Diom includes implementations for common backend primitives such as cache, key-value, idempotency, rate-limiting, queues, and streams, with more on the way.
While building Svix, we had to reimplement the same backend primitives that everyone have to reimplement. We also constantly felt the tension between building something custom on top of existing infra (like Redis and Postgres) and adding more dedicated services (like RabbitMQ and Kafka) which we would then need to configure, operate, back up, and maintain. This was even worse for us because Svix is open-source, so additional infrastructure meant additional burden on our customers.
Six months ago we finally decided to build Diom, and focus on developer experience and ease of operation. It's open source, self-contained, and manages its own storage using fjall (a fast LSM-tree-based storage similar to RocksDB). It requires no external runtime dependencies (no redis/postgres/kafka/etc), and supports running as a single node or a highly-available Raft based cluster.
The goal of Diam is to provide developers with the backend primitives they need without having to write custom code on top of Redis, RabbitMQ, Kafka, or even need to run them at all.
It currently supports cache, key-value, idempotency, rate-limiting, queues, and streams. We also plan on adding auth-tokens, distributed settings, feature flags, and other common components; as well as adding more functionality to existing components.
Diom favors ease of operation over scale, so it doesn't match Kafka-level throughput or very high QPS like Redis and Dragonfly. However, most products and developers don't process multiple terabytes and billions of events per second anyway. That said, Diom can still hit high performance for its target use-cases as it implements higher-level primitives rather than basic operations. Additionally, because the primitives live in the same process as the storage, there are fewer network round-trips, which keeps latency low.
It uses HTTP/2 with msgpack as the wire protocol (works fine from browsers), and ships a CLI and SDKs for Python, TypeScript, Rust, Go, and Java, with more on the way.
We have Svix fully ported to Diom and continuously running tests and simulated workloads in one of our staging environments. GA (general availability) is planned for later this year, once we've moved Svix production workloads over.
Repo (MIT licensed): https://github.com/svix/diom
Docs: https://docs.diom.com
Live playground: https://diom.com/playground
I'm excited to finally share Diom, and would love to hear what everyone thinks, and what other components you would like us to build! Would also love help figuring out what to call this. We currently say "component platform," but I'm not a fan of the name.

value: Show HN: Diom – Open-source back end primitives with no runtime dependencies

author: tasn


value: nhattruongadm

value: Show HN: MCPSafe – Free security scanner for MCP servers using 5-LLM consensus

author: nhattruongadm


value: onyks

value: Show HN: TTP 0.3.0 – A transparent Tor proxy running in RAM

author: onyks


value: OsamaJaber

value: Show HN: AutoKernel, Auto GPU Kernel Optimization

author: OsamaJaber


value:
I work as a SAP Integration consultant and built this as a side project. Friction point: Most self hosted LLM observability tools require Postgres, Redis and non trivial infrastructure. Teams just want to see what their agents are actually doing in Production, that set up cost discorages adoption.
Torrix runs as a single docker contained backed by SQLite. The full install is:
curl -o docker-compose.yml https://raw.githubusercontent.com/torrix-ai/install/main/doc... docker compose up
No external dependencies. All data stays in a local SQLite file on your machine.
It logs LLM calls through a HTTP proxy or a python/Node SDK : tokens, cost, latency, full prompt and response traces, reasoning token capture. Works with OpenAI, Anthropic, Gemini, Groq, Mistral, Azure Open AI and any Apen AI compatible end point.
Things I added as I actually used it on real agent pipelines: cost forecasting and hard budget caps, PII masking, model routing rules, evals with golden runs, AI judge, a prompt library with version history, run tags for filtering by environment, MCP server so AI Assistants can query your own logs and OTLP/HTTP ingestion for apps aöready using OpenTelemetry.
Community edition is free for one user with 7-day retention. Pro adds teams, RBAC, 30 day retention, API key management, full text search and audit logs.
SQLite doesn't scale to high write throughput. This is aimed at teams logging hundreds to low thousands of LLM calls per day, not millions. Happy to hear what people think and what is missing.
GitHub / install: https://github.com/torrix-ai/install Website: https://www.torrix.ai

value: Show HN: Torrix, self hosted, LLM Observability,(no Postgres, no Redis)


value: everlier

value:
New in mi v1.7.5: "--sandbox" runs the agent inside Docker with your current directory mounted, to contain the blast radious in case of unexpected attacks.<p>mi Works with any OpenAI-compatible model (including local ones). Has REPL, skills, and recursive agents and only 30 lines of code, optimised for local models.<p>---
mi --sandbox -p 'fix tests until all are passing'
---

value: Show HN: Tiny agentic loop with Docker sandbox

author: everlier


value: safitudo

value: Show HN: I built five SQLite engines from one spec in a week

author: safitudo


value: cekrem

value: Show HN: GreenType – That Mechanical Keyboard You've Always Wanted

author: cekrem


value: kunobi

value: Show HN: Kunobi 1.0 – A local-first Kubernetes workspace for GitOps teams

author: kunobi


value: kidandcat

value: Show HN: Gox – Strict static analyzer for Go designed for LLM-written code

author: kidandcat


value: aleshh

value:
Hey all,
I like to track my drinkng, but the idea of "one drink" in a world where beer varies be tween 4.5 and 8% seemed weird. Also, a lot of existing drink trackers are (understandably) aimed at people who want to stop drinking.
Anyways, I made an iPhone app to fix these things. Free for five different drinks, one-time in app purchase to unlock unlimited, plus a few other features.
I actually hand-coded a version of this years ago; this version is pointing LLM's at that codebase and guiding it through the iOS 26 rewrite.

value: Show HN: ClearPour – an iPhone drink tracker based on ABV and drink size

author: aleshh


value: madospace

value: With recent issues with npm configuration issues it's essential that we have a tool like this to fix basic issues

value: Show HN: FixMyNPM, CLI to fix your insecure npm config

author: madospace


value: niklasei

value: Show HN: Oicana – PDF templating with Typst, 6 server SDKs and browser WASM

author: niklasei


value: shiqingao

value: Show HN: Chrome extension that blocks API keys from being pasted into AI tools

author: shiqingao


value: lupodevelop

value: Show HN: Hexy is an app for tracking your packages posted on hex.pm

author: lupodevelop


value: adamhsn

value:
Technical background: Each agent loop begins with a real Astro project template pre-copied into the workspace. Rather than generating a file tree from scratch, Claude extends and modifies this known-good baseline. This design decision avoids the inefficiency and inconsistency of model-generated scaffolding. By working within a prebuilt, compilable structure, the model can focus on high-value tasks such as copywriting, layout, and visual hierarchy.
Full architecture explanation on agent loop, Postgres-as-queue, edit-via-resume, and more can be found here: https://www.adamhsn.com/blog/conversational-website-builder-...

value: Show HN: A website builder on the Claude Agent SDK

author: adamhsn


value: Ikryanov

value:
I’m Vladimir. I’m a software engineer. In our company we often develop desktop apps for internal needs and prototyping. And every time I bump into the same problem: how do I make an icon for the macOS app I have just built?
I could use the existing icon generators, but they are basically just image converters. You upload an existing image, and the tool generates the required icon sizes and formats from it.
But I don’t have an image, and I’m not a designer. Asking designers to create an icon is not always an option.
I wanted something that could help me actually create an icon. Something where I can describe an idea, iterate on it over several rounds, experiment with materials, lighting, composition, and gradually arrive at an icon that feels like a real native macOS app icon.
Since I’m an engineer, I built a small tool that allows generating a macOS app icon using AI. It’s completely free and open source, so other engineers building desktop apps for macOS can use it too.
The app lets you generate the app icons from prompts, refine them conversationally ("make it more metallic", "simplify the shape", "add glass effect", etc.), and export the final icon in the `*.icns` format (you can just put it into your macOS app bundle) along with a folder containing the icon in different dimensions.
There are no subscriptions, no watermarking, no credits system, and the source code is fully available on GitHub.
Note 1: the app requires an OpenAI API key. I tried to use local models to generate images, but none of them can produce images with quality similar to Nano Banana 2 or ChatGPT.
Note 2: the generation speed varies from several seconds to up to a minute. I don’t know hot to speed it up yet (maybe generate 1 variant instead of 3).
GitHub: https://github.com/TeamDev-IP/MoBrowser-App-Icon-Maker
Download (signed & notarized): https://github.com/TeamDev-IP/MoBrowser-App-Icon-Maker/relea...
Feel free to try it out. Happy to answer questions or discuss implementation details.

value: Show HN: An open source tool for generating macOS app icons with AI

author: Ikryanov


value: Show HN: A 0.3B model that redacts PII in all 24 EU languages offline


value: MerriBan

value: Show HN: HookGuard – scanner for malicious Claude.md and agent config files

author: MerriBan


value: Show HN: Vimancer – Game with Vim commands reimaged as magic


value: mjgil

value:
It implements a substantial Go language/runtime slice targeted at tutorial, playground, and small app workloads. Goroutines, channels, select, interfaces, generics, defer/panic/recover, maps, slices — all supported. The Rust/WASM compile path lets you run Go directly in the browser via a dedicated WebAssembly engine with a browser-managed worker.
Currently supports: time, net/http, io/fs, context, narrow os, json, regexp, crypto/*, and more.

value: Show HN: Gowasm – a browser-first Go execution environment in Rust/WebAssembly

author: mjgil


value: blacknon

value:
Hi HN,
I built a Rust-based terminal tool that wraps TUI applications and records their screen changes, so you can rewind, search, and diff previous screen states.
It runs the target program through a PTY, captures screen snapshots while the app is running, and lets you move back through the recorded history. You can search snapshots by string or regular expression, and highlight areas that changed between frames.
The original idea came from working on baeru, a tool for adding visual effects and color changes over existing TUI applications:
https://github.com/blacknon/baeru
While building it, I started wondering whether wrapping an existing TUI as a passthrough layer could have more practical uses.
This tool is also related to hwatch, another project of mine that adds history, diff, and hook functionality to watch:
https://github.com/blacknon/hwatch
In this case, the idea is similar, but applied to interactive TUI applications rather than repeated command output.
I’d be interested to hear what people think, especially about possible use cases or similar tools I may have missed.

value: Show HN: Twatch – Rewind, search, and diff TUI applications

author: blacknon


value: Show HN: Docker AI Stack – Deploy 8 self-hosted AI services with one command


value: dariobalinzo

value:
The cloud security company I work for, Sysdig, launched “Headless Cloud Security” last week.
The short version: as attacks get faster and more automated, security tooling is going to need to evolve beyond dashboards and humans clicking through workflows all day.
We’ve already seen “headless” models emerge in other categories, and engineering teams are rapidly adopting agentic and CLI-first workflows with tools like Claude Code, Cursor, and MCP servers. Security teams, historically, tend to lag engineering adoption curves by 6–18 months, but I don’t think that gap will hold much longer.
The idea behind headless security is that security capabilities should be consumable programmatically — through APIs, AI agents, IDEs, CI/CD pipelines, and automated workflows — not just through a UI.
This post covers it in more detail: https://www.sysdig.com/learn-cloud-native/what-is-headless-c...
Curious whether others here are seeing similar shifts inside their orgs, especially around AI-assisted development and security operations.

value: Show HN: Headless Cloud Security – Headless SaaS has come to security

author: dariobalinzo


value: code-less

value: Show HN: A "Git history" for Twitter/X profiles

author: code-less


value: icyfox

value:
Hi HN! Pierce here.
Rotunda is a firefox fork primarily intended for agent use, which I’ve been hacking on nights/weekends.
There was a [lengthy](https://news.ycombinator.com/item?id=48024859) discussion last week on how expensive computer use models are. The cost is going to drop eventually, but I think on some level it's still usually the wrong primitive. The web gives us access to beautiful structured formats, plaintext, etc... why throw that away if we don't have to?
I realized at some point that for 99% of automations I just want agents to be able to control my Chrome instance. But that’s easier said that done: CDP (the Chrome automation protocol) leaks a ton of state about being programmatically controlled, either by toggling window attributes or by running `page.evaluate()` commands right in the page context. Plus if you look at an automation running it's pretty obvious what happens: the mouse jumps around, fields are filled instantly, etc.
Rotunda tries to fix this. Its standout features:
- Realistic simulation of mouse movements and keyboard commands, powered by a trained RNN on my own timing patterns from the last week. (still feel weird about opting-in to a key logger but whatever)
- Doesn’t lie about its host specs, only fibs about some client side details. Stealth browsers are too easy to flag statistically when you’re adding noise to canvas pixels or audio pipelines.
- It runs on your local device with a CLI or Playwright API accessible to Claude, Codex, or whatever your harness-de-jure today looks like.
- Patches modern Firefox (150) with an agentic harness to keep this updated over time
MPL-2.0 on GitHub: https://github.com/monkeysee-ai/rotunda
Longer writeup on the design choices: https://pierce.dev/notes/a-browser-for-agents
Also check out the demo on the site! https://www.rotunda.sh/
Pretty excited by how this turned out but we’re still super early. Give it a try and please flag any issues!

value: Show HN: Rotunda - A browser built for agents with simulated typing

author: icyfox


value: madospace

value: RedactScreen creates a virtual screen that hides your sensitive apps (Slack, Mail, Messages) from everyone else on the call. Your screen, minus the parts that aren't their business.

value: Show HN: RedactScreen – Share your screen, not secrets


value: jamesjardine

value:
  Hashiverse (https://github.com/hashiverse/hashiverse) is an open-source decentralized social network protocol where Sybil
  resistance, rate limiting, peer reputation, and content moderation all fall out of one design choice: every action carries a
  proof-of-work cost calibrated to how much abuse it could cause. No central servers, no DNS dependency, no registration authority,
  no moderation team. Rust core, WASM browser client, volunteers on $5 VPS machines.

  Twitter-shaped (posts, follows, hashtags, timelines). The design problem that usually kills these projects on day one is Sybil
  resistance without a gatekeeper, so that is what I most want feedback on. Signatures and encryption are conventional (ed25519 +
  ML-DSA + FN-DSA, ChaCha20Poly1305, Blake3). The interesting surface is how every protocol action is priced in proof-of-work
  calibrated to its abuse potential.

  Shared primitive: a data-dependent chain over 17 hash algorithms. 5 rounds, each selecting one of 17 algorithms (Blake2s/b,
  SHA-2/3 at 256/384/512, Keccak-256/384/512, Groestl-256/512, Whirlpool, Skein-256/512, Blake3) and applying it 1 or 2 times. The
  algorithm index and repetition count for round N come from bytes of round N-1's output, so dispatch is data-dependent and only
  resolved at runtime.

  Honest prior art: Evan Duffield's X11 (Dash, 2014) chained 11 SHA-3 finalists with exactly this thesis. X11 ASICs (Baikal,
  iBeLink) shipped by 2016. Multi-hash chaining delays ASICs, it does not prevent them. What's different here is data-dependent
  dispatch (X11's pipeline is fixed) and variable repetition count. The honest question is not "is this ASIC-proof?" but "how much
  delay does data-dependent dispatch buy, and what software-update cadence should a protocol with no upgrade authority plan for?"

  Layer 1: Server-ID PoW (DHT membership). Generating a server identity means grinding a salt with the server's public keys through
   the chained hash until the derived 256-bit Kademlia ID has enough leading zero bits. Hours on commodity hardware per identity.
  Two compounding mitigations: bucket location IDs rotate on a monthly time epoch (the keyspace region around a user shifts
  deterministically), and prolific users fan across more buckets as the hierarchy subdivides under load. An attacker pays admission
   PoW against a moving target whose surface grows with the target's prolificness.

  Layer 2: RPC PoW. Every RPC carries a PoW over (timestamp, salt, payload, client ID, destination server ID). Under-threshold
  requests are rejected before payload parse. Timestamp pinning prevents replay; ID pinning prevents reuse across (client, server)
  pairs. Knock-on: because the destination server's ID is in the PoW, servers handling real load accumulate a routing-table
  reputation. A fresh Sybil has no traffic history; to affect the routing table they must either be useful or grind their own fake
  reputation by paying RPC PoW for every fabricated client request. Useful work becomes a Sybil deterrent.

  Post submission is a sub-case: two-phase Claim/Commit so one cheap PoW cannot deliver a huge payload. Submission difficulty
  scales with recent posting frequency.

  Layer 3: Per-feedback PoW. No central tally. Every signal (like, dislike, hate speech, spam, CSAM, etc.) is a PoW-stamped entry
  over (post_id, feedback_type), so a PoW cannot be reused across signals or posts. We use straightforward statistics to infer the
  total number of feedback submissions as the reciprocal of the unlikelihood of the globally-maximum PoW per (post_id,
  feedback_type) pair. That maximum is healed by clients noticing discrepancies, not by server-to-server gossip.

  If any of this resonates, or you spot something I've gotten wrong, I would love to hear it. PRs welcome.

  -- Jimme Jardine

value: Show HN: Hashiverse, an open-source decentralized social network in Rust

author: jamesjardine


value: dominiek

value: Show HN: Promptcellar – capture every Claude Code prompt as JSONL in your repo

author: dominiek


value: tobiadefami

value:
Hi HN,
I built a spreadsheet for modeling uncertainty directly in cells.
Cells can contain probability distributions, ranges, or distributions inferred from confidence intervals. Formulas then propagate that uncertainty through the sheet.
For example:
A1 = N.CI(10, 20)
B1 = U(2, 5)
C1 = A1 * B1
Instead of a single value, C1 becomes a sampled result.
The formula engine is powered by GaussFormula, a modification of HyperFormula that supports uncertain cells and sampled calculations.
The app is early and under active development and I would appreciate some feedback.

value: Show HN: Spreadsheets Cells with Uncertainty Distributions

author: tobiadefami


value:
Live demo: https://daily-habit-umber.vercel.app/
Tutorial: https://www.youtube.com/watch?v=U6cd310jHC8
*Source code: https://github.com/benlhachemi/daily-habit

value: Show HN: DailyHabit – A client-side habit tracker (React with IndexedDB storage)


value: crehn

value: Nowadays I spend a lot of time in Claude Code and reviewing diffs and code in Vim.<p>I didn't want to learn Vim's window management, so I created a Vim file browser that can run in its own tmux pane.

value: Show HN: Vim file browser that runs in separate terminal

author: crehn


value: TemporaryMail

value:
I run a temporary email service and it was a constant battle to block the bots so I built an internal tool to give the IPs a fraud score from 0-100 and limit the fraudulent IPs.
I couldn't use another service for this, as it was way too expensive and I've now turned this tool into a free service that others can use for their own site.
Currently everything is totally free as I haven't put down any time on trying to monetize it. Edit: even if it is monetized in the future (to pay for future server costs), then I will still keep the free plan very open and generous and only heavier users will be charged.
https://ipaddress.to

value: Show HN: Free IP fraud score detection (without ads or captcha)

author: TemporaryMail


value: kitchendesign

value: Show HN: TrueCitation – academic source credibility checker (URL/DOI/journal)

author: kitchendesign


value: foote

value:
I've been running into docs and chats that read as authored by humans but turn out to be pasted from GenAI. All well-intentioned, but inefficient and kinda awkward to sort out. Signaling with your own words is better, but I made some cheap semantic URLs to maybe help:
"This post is authorial.fyi"  - i.e. I stand behind each part, whether or not GenAI was used
"The plan above is ai.delegated.fyi" - i.e. I believe this is worthwhile overall, but I wasn't personally intentional about each part
Hope is to open conversations in this GenAI moment. Casually - complementary to larger initiatives. Curious how others are tackling this, the role of authorial intent vs correctness, or whatever comes to mind. Thanks for reading.
https://authorial.fyi
https://authorial.cx
https://ai.delegated.fyi
https://ai.delegated.cx

value: Show HN: "This post is authorial.fyi" – not vibed

author: foote


value: jonathanlowhy

value:
Hi HN, I'm Jonathan. My co-founder, Thomas, and I started building Mistle in Feb.
We saw larger tech companies like Ramp (Inspect) and Stripe (Minions) build this internally and thought an open source version should exist.
We made a few very intentional decisions when working on this:
1. Credentials are kept out of the sandbox. Authorized access goes through a proxy, so agents do not directly receive credentials.
2. The harness is not our problem. We're not going to tackle things like memory, self-learning.
3. No magic. Configurations are explicit. You can bring your own keys for models, sandboxes, and other providers. You can write your own instructions and agent.
Mistle can be run locally with a single command: https://github.com/mistlehq/mistle#run-mistle-locally
Questions, feedback and ideas are welcome!

value: Show HN: Mistle – Open-source infrastructure for running sandboxed coding agents

author: jonathanlowhy


value: SIGILonHN

value: Show HN: Chimera, a leaderless runtime with selectable settlement profiles

author: SIGILonHN


value: notfirstpost

value: Show HN: DAGraph – local-first reactive graph from arithmetic to OLAP SQL

author: notfirstpost


value: marcobambini

value: Show HN: SQLite-Columnar – Columnar Storage for SQLite

author: marcobambini


value: baigy

value: I've noticed all 3D AI generators create monlithic blobs that are impossible to edit. So, alongwith a friend, I built this project where you can generate 3D objects with separate, editable parts.<p>I'm looking for community feedback. The tool is free, but you'll have to BYOK. It uses models like Gemini, Claude or chatGPT to generate a Blender construction script. Basically the output is not merely geometry. It's the procedure that built it, plus the asset itself. This means you can actually go in and edit the "kit of parts" afterwards, instead of starting over.

value: Show HN: My tool generates 3D objects composed of separate, functional parts

author: baigy


value: natyoung

value:
I've spent the last fifteen years walking into engineering orgs that said they did "CI/CD"
(there's no such thing, CI and CD are distinct practices) and "Agile", and proceeded to ship
annually through release ceremony and theatre. There are more than a few dark-agile patterns
I'm sick of seeing, so I built a project management tool that avoids them, and that exists to
be a counterweight against the tools that encourage them.
The notion of story points was the first thing to go. Even Ron Jeffries,
who invented them, regrets their usage. Mainline hard-codes a story size of 1 and tracks
whether each story falls outside the team's normal distribution of time from start to release.
After a few weeks the team has a real handle on their cadence, backed by data instead of
planning-poker theatre. No estimation meetings required. Just do the work.
Unreleased work is made visible and tracked as inventory. There's a cottage industry of hosted
feature-flag platforms selling a different idea to the original technique. Long-lived business-facing flags create waste in the form of unmanaged inventory left hanging around past its usefulness.
Worst case, they become a giant configuration surface that "tech debt" doesn't do enough to capture as a term. Mainline tracks branch-by-abstraction, dark launches, feature flags, and old stories in flight through three phases: in progress, ageing, and stale.
The backlog is replaced with a Story Map. Work is shown as a user journey, and if it's not on the map (or has no user persona associated) it doesn't exist. This makes it harder for someone to dump tech tasks or random work onto the team for the purpose of "having a backlog."
The collaboration patterns high-performing teams use are first-class. Ensemble, pairing, and solo work are all visible and tracked, which makes de-siloing legible and promotes co-ownership.
I resisted adding AI features. It would be a weekend's work, and it would also undo the whole point. The longer argument is at mainline.dev/docs/ai.
I started building this with event sourcing and CQRS because I wanted the app built around an immutable event log. It wound up being too much boilerplate to change anything simple. So I went with an RDBMS and transactions to implement the immutable event log instead.
As I've learned after watching dozens of microservice teams utterly fail to safely ship anything, I took my own advice and started with a boring monolith and RDBMS. The stack itself is boring on purpose: Ruby with Roda and Sequel, Puma with YJIT, deployed via Kamal to Hetzner.
For teams who want to get better at CI, I built an integration with GitHub (GitLab coming) that reads the repo statuses and tracks how long a branch (if any are used) is open for. It's just a red/green dot on the repos as a heads-up.
The live demo is at mainline.dev/demo. No signup required, read-only because it's one shared team.
I'd be interested in feedback on how else I can help teams get better at CI and CD, and on any gripes you have with the parasitic management layer of non-practitioners who use other tools to implement Taylorist methods. Also, any other features that I haven't thought of (or thought of removing).

value: Show HN: Mainline – a project tool with no backlog, story points or surveillance

author: natyoung


value: amitabhi

value: Show HN: Splice – A programming language with custom VM for embedded systems

author: amitabhi


value:
My wife wanted a mood tracking app to track her habits and bipolar disorder. It's super useful for noticing new swings and trends. Unfortunately, every app was either too clunky or paywalled. In the end, she started using Google Sheets to track it.
I built Polar Balance to be clean, cute, and fun. It's supposed to be quick for the user. Answer 5 daily questions, and you're done. It does the statistics for you. Plus, the notifications are all penguin-themed. Each user gets a super cool penguin fact and a reminder to log their day. It's supposed to feel fun, not clinical.
This is my first solo-shipped iOS app. A few things I kept in mind:
- Logging a mood is the first thing you can do, not onboarding
- Data stays on your device unless you decide to link it to a gmail or iCloud account
- iPhone now, Apple Watch companion coming in version 2.0
I'd love to hear feedback from those who would benefit from a mood-tracking app. Happy to get into the build, privacy choices, or anything else!

value: Show HN: Polar Balance – a bipolar mood tracker I built for my wife


value: devconcierge

value: Show HN: Endpoint Context Protocol – Browsers get HTML, AI agents get Markdown

author: devconcierge


value: Number Gacha is a half-parody, half-real gacha game where you roll, unwrap, and battle numbers. Play on Desktop for the best experience!

value: Show HN: Number Gacha, a gacha game distilled to its essence


value:
I think the modern world increasingly demands technical literacy. I felt that myself, and I also realized I still had gaps in algebra from school.
But every time I opened a textbook, I wanted to quit immediately. Algebra on paper feels static, opaque, and disconnected from intuition.
I don’t think algebra was meant to live only on paper. It becomes much more beautiful on a screen, when you can interact with it directly, change things, and immediately see what happens.
You stop memorizing steps and start understanding why equations behave the way they do.
Another thing I realized: I didn’t want to be alone with it.
Learning algebra can feel strangely isolating. I wanted to feel that I was on the path with other people nearby, even if we were each working through our own problems.
So I spent a long time experimenting with friends and trying to build that sense of presence into the project: seeing what others are working on, feeling that the room is alive, and knowing you are not the only one struggling through the same ideas.
And honestly, I’m just tired of the endless AI slop, registrations, freemium traps, ads, onboarding flows, and two-factor-authentication rituals around things that should be simple.
At some point I realized I didn’t want another platform optimized for retention, upsells, and onboarding funnels. I just wanted something that helps people learn.
Join us. Let’s learn algebra together.
And if you like it, please show it to your kids, students, or anyone trying to rebuild their algebra intuition. If people find it useful, I’ll keep developing it.

value: Show HN: Learn algebra together, no AI slop, no ads or freemium, no registration


value: kenneives

value: Show HN: Is This Agent Safe? Free security checker that platforms cannot revoke

author: kenneives


value: chuks

value: Show HN: Ratify Protocol – prove who authorized an AI agent, offline, in <1ms

author: chuks


value:
Built this after a single session burned 40x my median token spend. The local JSONL logs have everything you need to figure out why, but nothing surfaces it by default.
cc-ledger is a local Rust binary that registers as a Claude Code hook, capturing runaway sessions and per-PR cost.
Cost analytics can be viewed from the macOS menu bar (SwiftBar plugin), a web dashboard at ccledger.dev, or the CLI.
All feedback and ideas appreciated.

value: Show HN: Ledger – Claude Code Token Spend Analyzer


value: aaronkwhite

value: Show HN: BossHogg: A PostHog CLI for Agents

author: aaronkwhite


value: marvinified

value: Show HN: EleutherAI / Lm-Evaluation-Harness

author: marvinified


value: bytode

value: Show HN: Majestic, GUI for Jest

author: bytode

title: Show HN: Majestic, GUI for Jest


value: DiegoZoracKy

value: Show HN: AgentDeck – a game console for AI agent research

author: DiegoZoracKy


value: msosnowski

value: Show HN: Aproxymade – plug-and-play monitoring and caching for your REST APIs

author: msosnowski


value: aisinghal

value: Show HN: Profine – Profile and rewrite your ML training loop on real GPUs

author: aisinghal


value: divinee

value: Show HN: Athena Index – behavioral credibility scores for public claims

author: divinee


value: MediumD

value:
I built this because I had a hard time investigating why certain Claude Code subagent/skills were performing poorly. Regular old, boring software has had profilers and debuggers for decades. When a request is slow or a function blows up memory, you have tools that tell you exactly where.
In the new world order of agentic development, poor performance is usually due to context bloat - either too many unnecessary tokens or missing relevant ones. I wrote this to help answer questions like:
- Which tool calls ballooned the context window, and on which turn?
- What context was the subagent/skill passed when it was spawned?
- What steps were repeated every session that could be lifted into a skill/documentation or cached lookup?
Agent Profiler is the tool for just that. It requires zero setup (just node), is fully local, open-source and can support any agent harness with a local transcript format.

value: Show HN: A open-source, local trace viewer for Claude Code and Codex sessions

author: MediumD


value: KeegNation

value: would love feedback on my latest connection to claude.  build workout programs in claude and push to fitness tracker.  https://keegnation.fit/guide#claude-overview

value: Show HN: Claude MCP to Fitness Tracker

author: KeegNation

title: Show HN: Claude MCP to Fitness Tracker


value: tzafrir

value:
You may have read Thariq's article "The unreasonable effectiveness of HTML"
This plugin implements the idea as Claude Skills, and adds a new ability: Automatic submit into Claude Code, without the need to manually copy and paste.
Installing the plugin has another benefit over "tell Claude to make HTML", since having it installed allows Claude to generate HTMLs on its own initiative, when it wants to show you something.

value: Show HN: Claude Code plugin for two-way HTML artifact generation

author: tzafrir


value: lusob

value:
I'd been mulling over this crazy idea for a while. Can programs be generated? Inspired by recent advances in world models, I wondered if we could do away with source code and generate pixels directly and interactively.
As an experiment to answer this, I set out to create a neural window manager, training a neural network to predict what the screen would look like next.
Basically, the idea was to generate the next frame based on the last two frames and the mouse position. That's it: moving windows without programming an event system, just a simple convolutional neural network guessing pixels.
To implement the experiment, I used Pygame to simulate a turquoise desktop background, a gray window with a navy blue title bar, a white cursor, and four colors in total. Then, a bot randomly dragged the window, and I recorded everything, processing the frames as color index matrices (not RGB, to avoid complications) and the mouse delta (dx, dy, click) that caused each transition. 8000 frames, a few minutes in Colab.
The model is a unitary neural network (UNET). The encoder compresses the stacked frames, the decoder reconstructs the next one, and the mouse vector coordinates are projected with a linear layer to fit the spatial size of the bottleneck. There, they are concatenated before decoding, so that motion information feeds each jump connection.
And it works! Which still surprises me a little. You can drag, and the window follows you; when you release, it stops. There's no internal state, no (x, y) coordinates anywhere. The model infers the position from what it sees, which works until it doesn't. But after a couple of seconds of strange movement, the window starts to distort.
This will probably improve with more computing power for training and more examples, but to narrow the scope of the experiment and test it within a web browser, I decided to abandon the rendering aspect and have the model predict primitives instead of pixels, simply converting the motion engine into a neural network.
Basically, I trained a small MLP to receive (distance to the title bar, distance to the resize point, click) and generate (dx, dy, dw, dh), with two separate heads: one for moving and one for resizing. The trick is that they share nothing except the click signal, so the model can't confuse dragging with resizing. I then exported it to ONNX as well, and now everything runs in the browser, without a server, just a canvas element and two small neural networks communicating with each other.
With this new approach, the renderer remains deterministic, with rectangles drawn in JavaScript, but the window's behavior (where it moves, how it resizes) is learned from examples. It feels like a peculiar middle ground between traditional and neural, so you can feel the space the network has learned by interacting with it: dragging near the title bar moves it, but approaching the corner resizes the window. There are no conditionals or hitbox code; the network simply learned where those areas are from examples.
Sometimes it gets confused near the edges, which, frankly, is more interesting than if it worked perfectly; you can perceive how the probability changes. This makes sense when you think about it, because no (x, y) coordinates are stored in these models; the position is implied in the activations. It works well for short sequences, but fails when asked to maintain state over time.
Update: A few weeks later, Meta published the Neural Computers article (2604.06425, it's worth reading). The premise is the same, but they go much further: cli and uis, real programs. Their failure modes are practically identical to those I found with the pure pixel version: "challenges persist with routine reuse, controlled updates, and symbolic stability." which is a fancy way of saying that the window blurs after a few seconds (that was the reason for choosing deterministic rendering).

value: Show HN: Neural window manager, neural network moving windows from mouse actions

author: lusob


value: salaivv

value:
A clock face generator/configurator extension using the Blender Python API.
Create and customize clock faces by playing around with the parameters. This is still a work in progress, but there's already a nice collection of features. Checkout the Gumroad page for details.
Download the Clock Face Generator Blender Extension: https://salaivv.gumroad.com/l/blender-clock-generator

value: Show HN: Clock Face Generator [video]

author: salaivv

title: Show HN: Clock Face Generator [video]


value:
Hey HN, this is deepan from trulytyped (https://trulytyped.com). I am building a document writing app which makes it extremely easy to figure out how a document was created.
Now that any text can be AI generated, how do you tell if something was actually generated or composed. It is impossible to detect AI after a piece of text has been generated. No amount of watermarking, linguistic checks or vibe checks work consistently. The AI detectors that schools and journals use are easy to bypass.
Why do we need to solve this problem - First of all, this is not an anti-AI stance. I have trained machine learning models in healthcare, cybersecurity and privacy space in last 10 years and open sourced some of the stuff (https://github.com/deepanwadhwa). I think, at a very fundamental level, we need to figure out how to differentiate human experience from AI so that we could have continued access to humans. Access through in-person, writing, audio or video. Access through text has already been fractured, our radius of trustworthy written material on the internet has reduced. And I think a similar trajectory will follow for audio, video and in person.
So how does truly typed solve this - Each document composed in truly typed carries information such as how much of the content was actually typed, how much was pasted, how many sources were used, how many authors contributed. Each document also carries flags such as verified human, bot detected, unverified. Unverified is for cases where humans are transcribing (basically copying by typing) text looking at another tab or book. The core thesis of the product is that purely human generated thoughts will matter more and more.
Since I come from a privacy and security background - Each and every profile and post is private by default. You decide if you want to make it public or not. We also have a pretty tight bot and automation defense - if you are an automation expert - try pointing a script at the app and see if you can get a verified human flag on an article (please reach out to team@trulytyped.com, if you actually break it). We don't want to use your data for any llm training and we don't want to sell your data to any brokers.
Our primary market for now is Academic Journals, News media outlets and Colleges and general folks who just wanna write and share with their audience.
We are sort of unique in this offering and competition exists at different layers. Google docs and Microsoft word are both writing apps, but they don't really tell you if the document was actually created by a human or not. We pointed a bunch of our testing scripts at google docs and full articles generated with real keystrokes without google detecting a hair. There are a ton of AI detectors that we have come across which show how much of the text is human or AI but they all are easily bypassable.
I am passionate about this problem and would like to hear your feedback, criticism, interest.
Cheers,
PS: I typed the whole thing myself. On truly typed, you won't have to say this.

value: Show HN: Truly Typed – A writing app for the AI era


value: Sunex

value: Show HN: Sunex Optics – MCP server for choosing best lens/CMOS image cameras

author: Sunex


value: pratikdeoghare

value:
Ideas:
* Keep the notation as small as possible and non-intrusive.
* Have a parser that assigns as little meaning as possible
  and returns a tree that is easy to work with.
* Do everything else by walking the tree.
* Avoid having to come up with syntaxes and parsers all the time.
I think the design is complete because nothing can be taken away from the syntax or the parser.
I have been using this system for many years now. When I am writing brashtag documents I am think of constructing trees not of typing text.

value: Show HN: Brashtag – A notation for writing trees and a parser for it

author: pratikdeoghare


value: boxed

value: Show HN: Micromort Risk Visualizer

author: boxed

title: Show HN: Micromort Risk Visualizer


value: Show HN: DAG-BFT with multi-attribute reputation


value: offtotheraces

value:
Instead of paying $5K/$10K/$20K annually to these companies, you can run this locally by cloning this public repo to find & engineer warm intros from your network easily.
Tried to keep it dead simple:
-> Import connections list csv from your contacts (e.g. from official LinkedIn exports)
-> Upload your target/prospect list (just need linkedin URLs)
-> System finds matches by profile URL
-> You click to enrich profile data of all the matches
-> System scores the strength of each paths (so you know which of your contacts to ask for the intro).
Enrichment is a waterfall composed of Apollo & Google CSE + agents - bring-your-own-key model.
Intro requests messages are automatically composed, and you can one-slick create a gmail draft.
View paths by target name, account (company) name, or by connection (sort by most or best paths).
Pre-loaded some illustrative (NOT REAL) sample data so when you start you can see what it looks like / how it works.
Why I built it: it was a customer request that I only realized later was a replacement for these products.
I'm the founder of (IMO) a more powerful (and complex) warm intro product (Draftboard) - over the weekend a user asked for this feature and I just built it to be responsive. Only realized what I had midway through.
I actually really dislike this approach of having to get people to export their connections list and send them to you, but I guess some people are used to it (in contrast, Draftboard maps all paths through all your - and your team's - contacts without them needing to export/import/download anything)
Anyways, would love feedback.
github.com/draftboardco/lean-intros

value: Show HN: Open-source clone of the swarm/ctd/happenstance for warm intros

author: offtotheraces


value: truemoein

value: Show HN: Ravan – Free streaming for AI-generated instrumental music

author: truemoein


value: smakosh

value: Show HN: Brutal Audit, brutally honest AI site audit

author: smakosh


value: pzxc

value:
Making a new video game every single day. Today's game is Chess.  Besides fixing a few build errors, the entire game was built in a single prompt.
And amazingly, the computer opponent is pretty hard!  I'm not a pro by any means but I beat all my friends, and I found this AI opponent rather difficult.
Happy to answer any questions

value: Show HN: Vibe-coding video games with Claude (Day 30: Chess)

author: pzxc


value: starfun

value:
As LLMs becoming a growing channel, many business notice their web traffic has dropped a lot in the past year but there is no way to tell how much of it was LLMs eating the clicks.
It's mainly due to most analytic tools (like GA4, Mixpanel, Amplitude) reply on a JS snippet that fires in a browser. But AI agents don't load JS. They hit your server, read the HTML, and leave. The only place they show up is in raw server logs.
So we built Arrivl. It works off server logs to show you which agents visited, what pages they read and whether they bring you real human visit. It also runs an audit of how AI friendly your site is and tells you how to improve in an afternoon.
It's completely free with no credit card required. https://arrivl.ai
Install is a snippet or a log forwarder, takes a few minutes.
Would love some feedbacks from the community here.

value: Show HN: Arrivl – Analytics for AI agent traffic on your site

author: starfun


value: piotrwittchen

value: Show HN: AICTL – A native AI agent for terminal and macOS, in Rust

author: piotrwittchen


value: geravant

value:
Sinain is an open source tool allowing you to capture screen and audio context into a local knowledge graph (optionally could be build utilizing only local models) which you can share with your agents (via MCP) or other users (peer-to-peer).
Over the last months both my fleet of agents grew rapidly and I was getting more and more context from different sources, including videos, calls, chats. Feeding the inbound context into agents became more and more time-consuming, so together with my team we've built a tool to gather the context live and store it in an accessible manner for both humans and agents - so we can stop copy pasting things to the terminal.
A summary of what is ready:
- For now MacOS only, other platforms support is in development
- Knowledge graph accessible via MCP, web UI, and is shareable
- Current benchmark is 82.8% IPR on LongMemEval (ICLR 2025)
- HUD overlay - ambient agent wrapper advising on your context, plugs in CC, Codex, Goose, Junie
- Default mode needs an OpenRouter API key (token usage is tracked); paranoid mode relies on local models (with a quality trade-off)
- An architectural choice we are proud of: knowledge sharing between users is peer-to-peer, over webRTC. For now it does require a call to a redirector server (which does not see the data), but we are planning on getting rid of it all together. The recipient's agents pick up the context via MCP.
Sinain is MIT-licensed.
Site: https://anthillnet.com
Demo: https://youtu.be/EWLcVtPPbac
Repo: https://github.com/anthillnet/sinain-hud
Install: npx @geravant/sinain@latest start
I would be glad to answer anything in the comments.

value: Show HN: Sinain captures screen and audio in KG, shares it with agents/peers

author: geravant


value: stAInley

value:
I'm running an experiment to discover ways to move AI agents from "instruction followers" to "process owners". Most agents fail when a task requires evolving intuition or persistent, multi-day workflows.
The core of this experiment is a collaborative "do-and-learn" loop where the agent executes a proven, high-stakes lead generation methodology, and the human provides the "judgment" layer.
This is an ambitious experiment exploring a few points:
Judgment vs. Execution: Humans learn good judgment through direct experience, failures, and working through problems. If we offload the doing to an agent, how do we build human-level judgment in the loop?
 Recursive Skill Building: Moving beyond simple Chain-of-Thought or generic skills. Can an agent document, refine, and store their own processes as they execute based on feedback?
 Training via Methodology: Using a proven, multi-million dollar revenue lead-generation methodology as the training data to see if an agent can move from instruction-follower to process-owner.
I’d love feedback on the architecture of the agent loops and how others are handling the "education" of their agents in complex, multi-day task or research cycles.

value: Show HN: Building effective Human-AI hybrid decision-making ecosystem

author: stAInley


value: foote

value:
notgen.ai: Link back to this to say "It ain't from Gen AI" nice and proper
notgen.ai/ask: Fer when you thought you were talkin to a human, but ain't so sure
authorial.cx/ask: When you don't care if it's GenAI, just want to know if they fully reviewed the dang thing
I reckon understanding how others understand the thing they share is key in these strange times. Made these to test the theory, and maybe avoid some dust-ups. Wondering what y'all think about all this.

value: Show HN: This Show HN is NotGen.AI

author: foote

title: Show HN: This Show HN is NotGen.AI


value: nerdlogic

value: Show HN: Like Reddit but for Interactive Simulations

author: nerdlogic


value: tmilard

value: Show HN: From 30 Photos to an FPS

author: tmilard

title: Show HN: From 30 Photos to an FPS


value: I built Markey because I was tired of writing marketing copy for every project I shipped. You paste your site's URL, it reads your content, and writes 20 launch materials in your brand's voice. It then auto-publishes them weekly to X, Threads, Bluesky, LinkedIn, and Reddit.

value: Show HN: I made a tool that writes your launch pack from a URL


value: pompeii

value: Looking for feedbacks, I made this tower defense game - based on my experience playing tower defense and wanted a unique tower defense with endless and simple waves and mechanics.

value: Show HN: I made a minimalistic Tower Defense Game – iOS – Looking for feedbacks

author: pompeii


value: Show HN: Showing the same info in 248 different UI


value: nizarmah

value:
Rolling it out at work to parallelize 4,257 tests across 5 services. It fixes our tests running in band and DB mocking in API tests.
It's a drop-in Postgres image, with a Golang proxy. :5432 is passthrough, :5433 forks the DB per conn (CREATE DATABASE … TEMPLATE …, dropped on disconnect).
If you use it, let me know what you like or don't like, so I can make it better. Cheers!

value: Show HN: Petri – Drop-in Postgres image that forks a DB per test

author: nizarmah


value: Show HN: Abliteration – made-to-order training data for classifiers and evals


value: RedMustard

value: Show HN: Grabbit: Search secondhand marketplaces in one place

author: RedMustard


value: subarnab

value:
Anthropic announced today that starting June 15, paid Claude plans get a separate monthly credit pool for programmatic usage (claude -p, Agent SDK). Seems OK at first glance but it turns out the monthly credit pool is charged at API rates, which effectively kills any serious programmatic usage for hobbyists.
This is a small Claude Code wrapper which runs claude in a PTY, injecting input, finding the session transcript jsonl file, and using a stop hook to determine when claude is done.
It's a drop-in replacement for claude code. All arguments except the "-p" argument are forwarded as-is.
claude-pee -p "hello world"
Could be used as a cheap way of using Anthropic subscriptions for OpenClaw, Hermes, etc.
Written in Rust, MIT license.

value: Show HN: Claude-pee: use Claude -p without the programmatic usage credit pool

author: subarnab


value: JHARDIMAN

value: Show HN: AirScore – Daily air-quality emails tailored to household conditions

author: JHARDIMAN


value: isms-core-adm

value: Show HN: We rebuilt the archived Kubernetes Dashboard in React 19 and Go

author: isms-core-adm


value: glouwbug

value: An attempt at a single pass LLVM frontend in ~3000 lines of C without external dependencies, malloc, or an AST. Included are some graphical examples. The IR isn't perfect, and the README touches on one particular downfall

value: Show HN: Nibble

author: glouwbug

title: Show HN: Nibble


value: zouko

value: Show HN: MerryDiv – Track dividends across all your brokerage accounts

author: zouko


value: Show HN: Containarium – self-hosted sandbox for AI agents, MCP-native


value: attendos

value: Show HN: Short links and dynamic QR codes you can white-label as your own SaaS

author: attendos


value: lightsyncpro

value: Show HN: Sync creative assets to any CMS

author: lightsyncpro


value: mmajzoobi

value: I have been working on this project for a few years now and the end goal is to make a ubiquitous and natural user experience to interact with machines. The long term goal is to build a fully agentic experience that drives the UI for you (generative UI) and display it to you on whatever device you are on. Still a long way to get there but I am laying the foundation for it. happy to address any questions here.

value: Show HN: Building a universal device experience [video]

author: mmajzoobi


value: Nancylily

value: Show HN: I tried generating music from text and built a small tool around it

author: Nancylily


value: aldanial

value:
I'm a vim/command line guy and loved using pudb (https://pypi.org/project/pudb/) as I was learning Python. Gradually my code became more complex and pudb wasn't keeping up; event loops and the threading and multiprocessing
modules were problematic.
TL;DR:  I used Claude Code to write the TUI debugger of my dreams:  https://pypi.org/project/textual-debugger/  It's built with textual and debugpy so can do all the things possible you'd would expect with the Debug Adapter Protocol (remote attach, thread/process inspection).
And then some!
I added a JSON-RPC interface so the debugger can be controlled by external tools (eg an AI agent).  I also added the capability to run the debug target in a separate terminal which is handy
for debugging applications that make demands on the terminal (like curses / rich / textual apps).
Here's a video of that in action:  https://youtu.be/121aihjAQ8g
Screenshots:
- https://github.com/AlDanial/tdb/blob/main/gallery/async_brea...
- https://github.com/AlDanial/tdb/blob/main/gallery/async_task...
- https://github.com/AlDanial/tdb/blob/main/gallery/multiproce...
- https://github.com/AlDanial/tdb/blob/main/gallery/threading_...
Give it a try!     pip install textual-debugger

value: Show HN: Textual-debugger, a Python TUI debugger with power features

author: aldanial


value: sayanarijit

value:
This browser-local WASM app complements https://github.com/sayanarijit/cottage which helps you manage age-encrypted (supports SSH RSA/ed25519 keys) secrets in you own repo.
Brower Local - All data is encryped and stored locally in your browser. It treats your git repository as the secret provider.
WASM - This app is made with Rust WASM which allows type-enforced safe secrets handling.
How it works - It looks for .age files in repo, and decrypts them with the built-in private key (assuming the secrets were encrypted with the built-in public key).

value: Show HN: Own Your Secrets – Sync encrypted secrets from any repo to any device

author: sayanarijit


value: aldgar

value: Show HN: Spent months fighting VS Code webviews, so I built a universal protocol

author: aldgar


value: mishang

value: Receipt-first bill splitting for group dinners: one person uploads or scans the receipt, shares a QR/link, and everyone claims their own items. Guests do not need accounts.

value: Show HN: TabChop – split dinner receipts by item from one shared link

author: mishang


value: olex-green

value: Show HN: I got tired of AI agents using outdated libs, so I built them an OS

author: olex-green


value: WalkerDev

value:
The Shinra Meisin is a modular tracking pipeline for XR systems. It combines eye tracking, mouth/face tracking, SLAM spatial mapping, inside-out body inference, and experimental EEG input into a unified offline-first architecture.
Most XR tracking stacks are fragmented or tied to proprietary hardware, so this project explores a unified, extensible system that gives developers low-level control without relying on closed ecosystems.
Right now, the system has a working eye tracking implementation, with SLAM tracking actively in development. The goal is to make the stack modular enough that it can be adapted or integrated into different headset setups with minimal overhead for developers.
This is being built by a small R&D team at Walker Industries alongside EOZVR, working across perception, tracking, and tooling. I’m currently focused on the Unity/Godot SDK and the companion application layer. The eye tracking system is primarily developed by John, with collaboration across the broader tracking stack. It's been a long road getting things to work, but it's been very rewarding!
We also plan to build a dataset using recorded sessions across a small group of paid volunteers and multiple headset models once the pipeline stabilizes.
Eye tracking demo: https://www.youtube.com/watch?v=QlfCfkzkBB4

value: Show HN: We Made Open Source Eye Tracking

author: WalkerDev


value: whazor

value:
When setting up a k8s homelab, I would search through the GitHub repos of onedr0p and bjw-s, but I wanted to know what the wider community was up to.
Over a hundred people have a public k8s homelab repo, and you can see what is popular. It has also become a good source of Helm values, which are indexed as well.
Would I recommend running your homelab on k8s? Only if you are serious about Kubernetes and want to learn more. The people in the k8s homelab community are at the forefront of k8s and often know where things are going.
I personally stopped running Kubernetes at home myself, but I still read up on the community, since being knowledgeable about k8s helps me at work.

value: Show HN: Kubesearch, search through Kubernetes YAMLs from homelabs

author: whazor


value: radotsvetkov

value: Show HN: AGEF, an open evidence format for AI agent sessions

author: radotsvetkov


value: XanMan

value: Show HN: I built an AI travel camera because I was tired of Google Lens

author: XanMan


value: emillykkeg

value: I've built an AI dictation tool (like many others), but this time I have taken the time to benchmark all of the 34 models that we provide, so users can actually make a qualified choice on what model should be the daily driver.<p>The best is that it's open source, so if you think we can improve something, please come and help out.

value: Show HN: I built an open source dication tool based on benchmarks

author: emillykkeg


value: cdnsteve

value: Show HN: ChangeSpec – An open standard for notices in software changes

author: cdnsteve


value:
I don't really know how to do this. I'm a Spanish solo dev and solo writer, and a long time ago I created an Android app for personal use, called Mind Focus, that has helped me work more focused and take back my attention.
And now I've gotten up the nerve to share it because I think it can be useful to others.
To that end, I've combined two things that have personally worked for me and are also backed by data:
The Pomodoro technique (and time-boxing in general as a task management approach).
Isochronic tones (along with other sounds like pink or brown noise). Personally, they have worked better for me than other options like binaural beats, and emerging science also seems to corroborate greater effectiveness (yes, I like to dig up obscure studies, here is some science behind the app https://www.ataraxiaapps.com/en/posts/science-behind-mindfoc...).
The novelty beyond the combination of both things is that the tones used aren't MP3s on a loop, but generated on the fly, with an adaptive ramp system to naturally accustom the brain to the appropriate focus frequency.
Likewise, the tone generation algorithm takes into account the time of day (and the natural ultradian rhythms in people) to generate the optimal frequency.
Besides that, I've also gathered what has worked best for me to try to tame my eternal anxiety (for example, breathing techniques like the physiological sigh) or recover an attention ravaged by the algorithm.
I'm oldish. I've lived with and without the Internet, I remember vividly dealing with life (and others) without a screen in between, staying absorbed in one single thing, memorizing phone numbers... or being the owners of what we pay for.
I hate the endless scam of paying for everything and owning nothing, so there is a PRO version that costs like one of those sugar-loaded fancy coffees, but this is not what pays my bills and there are no subscriptions of any kind.
That Pro version includes Flowmodoro (where you can customize work and rest times, adapting Pomodoro to what works best in each person and inviting a flow state) and some additional relaxation and attention techniques.
But honestly, most people can get by with the free version, which I think is quite generous.
The current personal version that I'm testing uses more complex soundscapes built from isochronic tones, once again backed by science.
Likewise, there are no ads in the free version, it doesn't collect statistics of any kind (not even anonymous ones) and the app works 100% offline.
Progress can be preserved if you change phones or reinstall the app, but again it's the old-fashioned way, exporting a JSON file and reimporting it on the new device or installation.
Nostalgia tends to be an excuse to sell people like me on the idea that the old days were "better" (when we were simply younger), but it's true that the absence of constant surveillance, relentless stimuli and real ownership is something worth bringing back.
I could talk all day, but why would you listen?
Mind Focus can be downloaded for free from the Play Store and everyone can check for themselves whether it works for them or maybe not.
https://play.google.com/store/apps/details?id=com.ataraxia_a...
Thank you very much for your time... and attention, of course.

value: Show HN: Mind Focus, an Android app for focus and attention recovery


value: Show HN: Midjourney Prompt Generator

title: Show HN: Midjourney Prompt Generator


value: Multi-agent orchestration & workflow engine. Declarative YAML workflows, LLM coordinator with hub-and-spoke mailboxes, race-safe delivery. One YAML file, one Go binary. Runs on any goai-supported provider.

value: Show HN: Zenflow a multi-agent orchestration and workflow engine


value: shadaba

value: Show HN: Local-first Kubernetes YAML visualizer (no server, no LLM)

author: shadaba


value: sahil-shubham

value: Show HN: Bhatti – self-hosted runtime for your harness engineering

author: sahil-shubham


value: mewc

value: Show HN: NoPoint – Pitch decks vibe coded instead of clicked (open source)

author: mewc


value: rdme

value: Every privacy-focused DNS service requires an account: NextDNS, Cloudflare for Families, Apple's iCloud Private Relay (paid, iOS-only). The protocol that doesn’t require one - ODoH - had basically one well-known public relay operator (Frank Denis on Fastly Compute, default in dnscrypt-proxy). I built a second one and the client to talk to it.

value: Show HN: Running the second public ODoH relay

author: rdme


value: Show HN: Tlbic – A flexible, time-limited basic income credit (3rd Ed, French)


value:
Hi HN. I built CrowdRank, a small web app where people vote through head-to-head matchups and the results become a live leaderboard.
Backstory:
A few years ago, while I was learning to code, I wanted to build a Tinder-style voting app to rank the funniest characters from The Office. I hit a lot of dead ends, mostly on the frontend, and abandoned it.
Now with a bit more technical background i rebuilt the idea as a more general platform. The backend/API is Laravel, and I used AI heavily to help build the frontend because somehow centering a div still finds ways to humble me.
What did I end up building?
A web based platform for ranking candidates inside different topics. There are no community-created topics yet. For now, I seeded a bunch of debates and used an Elo style ranking system, similar to chess ratings, to build a live leaderboard for each debate.
No signup is needed to try it.
A few example debates:
- who’s actually funny in The Office? (of course)
- programming language that sparks the most arguments
- app you would never delete from your phone
Stack:
Laravel, Blade, Postgres, Filament for admin, and React for the swipe/tap voting page.
I’d appreciate feedback on:
- does this even make sense?
- does the voting loop feel fun or annoying?
- do the leaderboard/result pages make sense?
- does the content feel too broad?
- what debates would actually be interesting to vote on?
Link: https://crowdrank.app
Tech related topic i picked for HN:
https://crowdrank.app/t/programming-languages
I updated the post for list formatting

value: Show HN: CrowdRank – live leaderboards for internet arguments


value:
I've created a new open-source data format licensed under Apache 2.0.
SuperCSV is a CSV-like data format with explicitly defined types and self-describing files.
SuperCSV v1.0 includes a formal specification, a reference implementation in Go (validation, encoding, decoding), and a public test suite.
https://www.supercsv.com
https://github.com/supercsv/supercsv

value: Show HN: SuperCSV – a typed, self-describing data format


value: I wanted CLI tools like grep to work better with .ipynb files, ie. work on inputs and not on outputs. I created a tools that uses FUSE to strip notebooks on the fly.

value: Show HN: Fuse-stripped-notebooks uses FUSE to make .ipynb better for grep


value: levmiseri

value:
This is more of an experiment/demo than something serious, but wanted to share and see what people think.
The main premise is that you can create anything by typing "/create {anything}" and the game will do its best to produce such object with all the functionality and properties that would make sense.
It might look simple at first glance, but the underlying systems are fairly complex. Create dragons you can fly on, spells, weapons, factories, ...

value: Show HN: Asciidia – LLM Crafting Game

author: levmiseri

title: Show HN: Asciidia – LLM Crafting Game


value: Einenlum

value: Show HN: Git-Shitstorm: How to Make Any Developer Lose Their Mind

author: Einenlum


value: Show HN: Jira Desktop Unofficial – lightweight Jira wrapper built with Tauri


value: uzyn

value: Show HN: AIMX – Self-hosted, open-source email server designed for AI agents

author: uzyn


value: rrwilla

value: The hypothesis is simple: if gold is real money, accurate chart trading analysis should use charts priced in gold. I'm already finding actionable charts on $TSLA, $INTC, and $SPX. Would love people's feedback!

value: Show HN: The trading terminal that prices everything in gold

author: rrwilla


value: joelsfoster

value: Show HN: FreeFax (iOS) – a data point on shipping solo with Claude

author: joelsfoster


value: vanyaland

value: Show HN: Diffmode – Tool that builds custom growth tactics for bootstrapped SaaS

author: vanyaland


value: stavros

value: Show HN: Symphony: Integrate OpenCode with Linear and get your own dev team

author: stavros


value: lxchase

value:
I created PandoCast for Windows, for 2 reasons. 1) I was annoyed just enough at intermittent audio hiccups when casting Pandora.com to my soundbar through Chrome tab casting. 2) My professional career has been a marketer and I feel pigeon-holed in a vertical that while I enjoy, it's not what I want to be doing now. I have always been a fiddler, and learned coding and engineering concepts in parallel to my career. I'm looking for a home that values people who have walked different paths, promotes curiosity, and can look at technical problems from entirely new angles.
Wrote this in C#. I came up with an architecture that made sense in my head, did some research and reverse-engineered the new Pandora Modes API, and wrote some basic skeleton code. With the help of Kilo Code, GPT 5.5 (and Gemini) as a programming buddy, I was able to build this, learn about Windows GUI oddities, and fix my annoyance.
Feedback is welcome and appreciated. And if you know of anyone looking for someone like me, I'd love to connect: https://www.linkedin.com/posts/lennychase_github-lennyxcpand...

value: Show HN: PandoCast: open-source Pandora player to solve an annoyance I had

author: lxchase


value: oug-t

value: Show HN: Sanjaya – Extract structured datasets from academic journals

author: oug-t


value: DaryaHr

value:
Hi everyone!
This is my first project, so I want to make sure I avoid rookie mistakes in it.
Guidelines told me to avoid llm creating this message, so please, accept my apologies for the grammar in advance.
In short, this is an app to unstuck overwhelmed mind and make it get dopamine with something useful instead of reels scrolling.
Choose a category based on your current interest and environment. Choose difficulty level - it is not about completion time, but mostly how uncomfortable for me to do the task. Easy - normal tasks (wash the mug), legendary - I would die to do it without an app (talk to a stranger about zombie apocalypse).
In “not so short”:
The idea popped up from my own struggle: I never been diagnosed with adhd, but my brain is flooded with thoughts and tasks majority of time. Prioritization systems somewhat help but I give up on them and also have a hyper focus superpower that compensates it and I am fine with that.
So the issue is not in “Not doing anything” - the real problem is that I am annoyed with the time I extract dopamine from cheap sources like reels. Once my brain gets overwhelmed by the number of thoughts, they collapse into a simple idea of “let’s pour a glass of wine and scroll social media feed for new cool ideas that will change my life magically”.
The idea behind the app is to substitute option of doomscrolling with task completion. I noticed I sincerely enjoy those mental checkmarks so why not to trick the dopamine system into something actually useful? I did that.. hopefully.
This is an early version - very basic, without user profile as I was targeting one singular user - myself. Though, if it helps me, maybe it can help others.
With that, next step is to add user profile with filters like marriage (so you don’t have to smile to a cute stranger), pets (or feed the non existing dog), climate (walk 40 mins in Texas summer - wouldn`t recommend), housing (clean garage in your 20th story unit) etc., meanwhile “refresh” button is there for you.
There is a bigger idea behind this, but I’d like to see first if the concept might work for someone else too. And check for possible safety (human and data) concerns before I move forward.
User info is stored locally for now, but will be moved to server side once login is introduced.
Also cannot stop thinking, how can I build somewhat social but fare system - no one is checking real life progress, so people will cheat. Doesn’t matter for this concept but definitely blocks social challenges and that’s unfortunate. Will be grateful for some guidance here.
In any way, sorry for lots of words. I hope some of you will find it fun and useful :)

value: Show HN: Get dopamine from real action instead of doomscrolling

author: DaryaHr


value: ritzaco

value: Show HN: U Wot M8 – get no-jargon landing pages

author: ritzaco


value: Show HN: Aion a Rust Database

title: Show HN: Aion a Rust Database


value: Meltinbit

value: Open source and self-hosted. Built to keep AI context structured and reusable across MCP compatible clients.

value: Show HN: MementoVault – Self-hosted AI context manager served via MCP

author: Meltinbit


value: teamchong

value: Show HN: TweetDeck-style HN reader, built to experiment with Chrome's Prompt API

author: teamchong


value: Goodruns

value: Hey HN, I'm Charlie.<p>I built Emit after going from producing events in an event driven environment to consuming data I didn't create in an analytics role and guessing more often than I'd like to admit. The code is the only thing that actually tells you what events mean (e.g. a negative bill_amount on purchase_completed = refund), so Emit reads it and writes the catalog from it. Open source.

value: Show HN: Event catalog from code in 2 commands

author: Goodruns


value: tedavis

value: Show HN: ToolParty – ProductHunt but for Design Tools

author: tedavis


value: maxwellito

value: Show HN: Race to the Bottom

author: maxwellito

title: Show HN: Race to the Bottom


value: theorchid

value: Show HN: Ungate – use Claude and GPT subscriptions in Cursor without API costs

author: theorchid


value: karphi

value:
I built this because I could not keep up with the AI developer tooling space and wanted to get an overview on hot tools.
The site tracks more then 500 tools across 19 categories with a unified scoring and combines GitHub signals with curated datasets and ranks. The scoring is intentionally not a universal leaderboard but it helps to see the leading tools in a category quickly.
I would be happy to get some feedback :)

value: Show HN: An opinionated index of AI developer tools

author: karphi


value: dmd

value:
Switched from Claude to ChatGPT? (For whatever reason. Not judging.)
Wish you could get that soothing Claude font and color scheme?
Or maybe you just hate native apps and prefer the bloat of Electron?
Well it's your lucky day, because this is an Electron ChatGPT wrapper that scratches your itch. It even has dark mode. (Applaud here.)

value: Show HN: A simple Claude skin for ChatGPT

author: dmd


value: hbbio

value: Show HN: NoDiff, TSX for browser apps without React or a virtual DOM

author: hbbio


value: Show HN: A whiteboard for your AI coding agent [video]


value: gsunshinel

value: Show HN: 3D-Agent – AI that edits Blender scenes through the Python API

author: gsunshinel


value: zequera

value: Show HN: Klent – one click between your AI agent and a prod blast radius

author: zequera


value: archleaf

value:
I found out that a ton of job alerts are sent overnight: https://www.jobbox.cc/when-are-job-alerts-sent/index.html
Here’s how I got there:
While working at Indeed, I became fascinated by job alerts because we sent a ton each week. When I started to actually job search, I signed up for a bunch and my inbox started filling up. As I got application updates, replies and interviews scheduled, I noticed there was a lot going on in my inbox. Rather than start at the individual sites like LinkedIn, Indeed, Glassdoor, etc., I used my inbox as the source of truth.
That was the lightbulb moment for me.
That’s why I built JobBox. Right now it focuses on organizing job alerts into one place, and I’m going to try including application updates and recruiter emails next.
I’ve launched a beta that focuses on job alerts. It’s free and available at https://www.jobbox.cc.
Here’s an example dashboard for UX Designer jobs in New York so people can see the product without having to login: https://www.jobbox.cc/jobs/ux-designer/new-york
Another thing I found is that there’s actually very little overlap in the jobs these sites send: https://www.jobbox.cc/senior-product-manager-seattle-jobs.ht...
JobBox connects to your Gmail and uses readonly access to parse job-related emails. Google requires a security audit for this access, which we’ve completed.
I’m curious whether this matches what others see in their job searches, and what would make something like this more useful.

value: Show HN: I realized job search is basically an email problem so I built JobBox

author: archleaf


value: davidresilify

value: Show HN: An interactive map of hidden AI dev agent action paths

author: davidresilify


value: You can check your domain for gaps in DNS and email security. I'm striving to help domain owners prepare for the next step (e.g., DMARCbis). I'm building an articles section with the goal of explaining why a standard's important and easier than it was a few years ago to be in full compliance.

value: Show HN: A DNS Security Audit Tool

title: Show HN: A DNS Security Audit Tool


value: ritzaco

value: Show HN: BuzzOff.wtf – get no-buzzword descriptions of landing pages


value:
Hey HN, I am Robin from Rauno (link: https://rauno.ai). I built this tool because I’m tired of AI hallucinations.
I got sick of manually copy-pasting every prompt into 3 different windows just to verify the truth. I realized the only way to get real accuracy was to let the models debate & fact-check each other in real-time, in one screen. I couldn't find any platform online that does this and actually works smooth and user-friendly, so I ended up throwing this together just to make my own life easier.
I built an orchestration layer that runs the models in sequence and manages the state and context windows so they can actually debate. The backend routes the conversation to make sure they are skeptical towards each other's opinions, to make sure they catch each other's flaws in thinking. By talking to each other, the models immediately call out each other’s mistakes and when you push a little more, they definitely don't hold back. It currently supports recent models like Claude Sonnet 4.6, Gemini 3.1 Pro and ChatGPT 5.2.
Running this is pretty token-heavy, but the free tier is open so you can test if the approach works for your workflows. Would love to hear your feedback.

value: Show HN: A multi-model interface where LLMs discuss & argue with each other


value: vunderba

value:
A favorite game of mine as a kid was an old DOS game called Redhook's Revenge released all the way back in 1993. It was an interactive naval board game where you roll dice, move ships, conquer ports Risk-style, and answer maritime trivia. My sister and I spent hours playing it until we'd basically memorized every question.
About 10 years ago, I reverse engineered the game's packed binary asset format to inject new general knowledge trivia questions, being careful not to shift any memory offsets pointing to sound effects or graphics, which would crash the game. On a whim, I tracked down the original author, who while they no longer had the source code, did give me permission to release an official sequel (joking that I only had to split any earnings over $100,000 with him).
The original remake used .NET and DOSBox and only ran on Windows, which really missed the spirit of the project, so I ported it to run in the browser using js-dos so anyone can play it. The core game is the same (e.g. dice, ships, trivia)   but with random general knowledge questions so it's more like Trivial Pursuit meets naval Risk.

value: Show HN: Redhook's Revenge II

author: vunderba

title: Show HN: Redhook's Revenge II


value: abi

value:
Sharing a small Mac app I built around OpenAI’s gpt-realtime-2 model. You call up a voice coding agent and talk to it like you’d talk to a freelancer ("make the hero tighter, put a product image on the right, that one's too big"). You can even point at things on your webpage and say “remove this” or “make that bold”. Pointing feels like a killer feature. It pushes the conversation bandwidth way up, and feels just like working with a real person over a screen share.
Video demo: https://youtu.be/RteRVM7BSps
Github URL: https://github.com/abi/1-800-CODER
How is pointing implemented? GPT-Realtime-2 only supports image inputs (unlike Gemini Live which also supports video inputs). So, the app sends a screenshot including the cursor when the model emits a speech_stopped event. That way, the agent always has a fresh visual before it replies.
Limitations:
- GPT-Realtime-2 is okay at front-end changes, probably at a GPT-4o level. Small modifications like copy changes, adding/removing elements, formatting updates work really well at low latency. In fact, for these types of changes, this might be my ideal interface. But if you wanted this app to be more useful for larger changes or generating UI from scratch, you’d want to hook up a subagent system that runs a smarter model like GPT 5.5 or Claude Opus.
- GPT-Realtime-2 is expensive. The good news though is that bandwidth is really high here so you might save time with this interface.

value: Show HN: 1-800-CODER, macOS app where you call an AI developer to edit your page

author: abi


value: behzad

value:
Ever noticed AI outputs drifting in voice, style, and tone? I’ve seen it too—and heard the same from some friends.
So I built StyleRef, a tool that helps you define your creative style once and reuse it across any AI tool to keep outputs consistent.
It covers 160+ style attributes and can also extract style from your reference files.
Happy to hear your thoughts and answer any questions.

value: Show HN: StyleRef – Define your creative style once, use it across every AI tool

author: behzad


value: In browser PPO training demo, made possible by tinygrad: TinyJit -> WebGPU kernels.<p>Requires WebGPU.

value: Show HN: Watch a neural net learn to play Snake


value: amitabhi

value: Show HN: Halgorithem – Catching AI Hallucinations Using Trees, No AI in Pipeline

author: amitabhi


value: gmac

value: Show HN: Yes We Scan: rescue old scanners with an in-browser Linux VM and WebUSB

author: gmac


value: Knuspii

value: Hi HN, my first post!<p>CrunchyCleaner is a minimalist, open-source TUI system cleaner written in Go. I built it because I wanted something faster and cleaner than traditional GUI tools, but more interactive than a simple bash script. Single Binary & Cross-platform (Windows & Linux).

value: Show HN: CrunchyCleaner – A cross-platform TUI tool to purge software caches

author: Knuspii


value: kasperbergholt

value: Show HN: Sun – a Prolog generator for the 2026 solar eclipse

author: kasperbergholt


value: iridis

value: Show HN: nichy – a visualizer for Rust type memory layouts

author: iridis


value: haxfenx

value: Show HN: Pokémon SVG Generation LLM Benchmark

author: haxfenx


value: lveillard

value: Show HN: BlitzGraph – Supabase for graphs, designed for LLM agents

author: lveillard