value:
Dear diary, this is my story: I'd been sharing MCP configs with other devs at work a lot - templates in shared repos, credentials in Bitwarden, everyone cowboying their own env vars. That's a lot of manual wiring and lack of any real control, so there was already a problem statement forming in my mind. Then three weeks ago I was putting my kids to sleep and reading about Jensen Huang saying every company will run 100 agents per employee, and the math started mathing.
That evening I kept thinking about what agents actually need to operate in the real world and eventually landed on the same answer as every spy movie ever: basically, a passport suitable for the mission and clever drop-off locations. So I built STACK. True story.
- The passport: a signed JWT (EdDSA) that proves which agent is acting, who authorized it, and what it's allowed to do. Works offline - any service can verify it without calling STACK. Agents can delegate to sub-agents but the scope ever only narrows. Max 4 hops.
- The drop-off: is an encrypted handoff between agents. Agent A drops off a package with a JSON schema contract, encryption at rest, and a TTL. Agent B collects it, the custody transfers, and the payload gets deleted. Neither agent needs to trust the other. Just like in the movies!
All credentials are KMS-encrypted. In proxy mode they are injected at the network boundary so the agents can make API calls through STACK without ever seeing the raw key.
To try it, sign up at https://getstack.run, grab your API key, and connect:
claude mcp add stack --transport http https://mcp.getstack.run/mcp --header "Authorization: Bearer YOUR_API_KEY"
I want to provide a generous free tier and I hope people get value out of it.
Keycard ($38M, a16z) does scoped agent credentials, Descope ($88M) does auth flows, Composio ($29M) does tool integrations. I'm a solo founder in Stockholm without funding, but I'm betting the full control plane is where the market is heading. I may be naive about that, but that's the bet. I like betting.
                                                                                Docs at https://getstack.run/docs.

value: Show HN: Stack – the control plane for AI agents


value: GRVYDEV

value:
Hey HN,
In this age of agentic coding I've found myself spending a lot of time reviewing markdown files. Whether it's plans or documentation that I've asked my agent to generate for me, it seems that I spend more time reading markdown than code.
I've tried a few different solutions to make it easier to read such as Obsidian however I've found their Vault system to be quite limiting for this use case and I've found TUI solutions to not quite be as friendly to read as I've wanted so I made Marky.
Marky is a lightweight desktop application that makes it incredibly easy to read and track your markdown files. It also has a helpful cli so you can just run marky FILENAME and have the app open to the md file that you pointed it at. I've been using the daily over the past week and I really enjoy it so I figured I'd share it.
Here's a video if you want to check out a demo: https://www.youtube.com/watch?v=nGBxt8uOVjc.
I have plans to add more features such as incorporating agentic tools such as claude code and codex into the UI as well as developing a local git diff reviewer to allow me to do local code review before pushing up to git.
I'd love to hear your thoughts and any feature suggestions you may have :)

value: Show HN: Marky – A lightweight Markdown viewer for agentic coding

author: GRVYDEV


value:
What's New in v0.3<p>Retry failed transcriptions – history entries that failed can now be retried with saved audio
Cancel with ESC – press ESC during recording to cancel without creating invalid entries
More stable long recordings – fixed truncation issues for extended sessions
Fn key support – custom hotkeys now support Fn key combinations

value: Show HN: AriaType v0.3 Has Come – Fast and Private Voice to Text Input Client


value: chrischtel

value: Show HN: A tool for automatically grading/sorting astrophotography FITS frames

author: chrischtel


value: kouhxp

value: Show HN: Arrow. Point your phone, walk where it says, find out where

author: kouhxp


value: Show HN: We beat Google, Cognition, Claude Code at codebase docs generation


value: linsys

value: Show HN: RetrieveIT – Semantic Search Across Gmail, Confluence, GitHub, etc.

author: linsys


value: keertahacker

value: Show HN: Health billing agent denies claims in 1.2s, offices should know why

author: keertahacker


value: vrennat

value:
Mulligan Labs is a browser-based playtester for Magic: The Gathering. No account or install needed. Just create a room, share the link, import a decklist from Archidekt or Moxfield, and play with mouse and keyboard (mobile support is not great right now).
Stack: SvelteKit on Cloudflare Workers, PartyKit (Durable Objects) for the authoritative game server. Clients propose actions over WebSocket; the server validates and broadcasts state.
My background is networking and my cofounder's is industrial design. Neither of us had shipped a codebase like this before. We built it over the last 5 months with heavy Claude assistance. Happy to get into what that actually looked like in the comments.
It's rough in places (the deck builder is just ok right now) but the core multiplayer loop is solid and we have played a ton of games on it with our Commander pod. We'd love feedback, especially from anyone who's played Cockatrice/XMage/Untap and has opinions on what a browser-native version should feel like.

value: Show HN: Mulligan Labs – multiplayer Magic: The Gathering in the browser

author: vrennat


value: anydigital

value: Docs & demos: https://blades.ninja/css/

value: Show HN: Blades CSS – Framework-agnostic, class-light CSS⁺ kit inspired by Pico

author: anydigital

story_text: Docs & demos: https://blades.ninja/css/


value: tudorg

value: Show HN: Xata, open-source Postgres platform with copy-on-write branches

author: tudorg


value: ragojose

value: Show HN: Shader Lab, like Photoshop but for shaders

author: ragojose


value:
Hey HN! We're Charles and Dean, and we're building Stage: a code review tool that guides you through reading a PR step by step, instead of piecing together a giant diff.
Here's a demo video: https://www.tella.tv/video/stage-demo-1pph.
You can play around with some example PRs here: https://stagereview.app/explore.
Teams are moving faster than ever with AI these days, but more and more engineers are merging changes that they don't really understand. The bottleneck isn't writing code anymore, it's reviewing it.
We're two engineers who got frustrated with GitHub's UI for code review. As coding agents took off, we saw our PR backlog pile up faster than we could handle. Not only that, the PRs themselves were getting larger and harder to understand, and we found ourselves spending most of our time trying to build a mental model of what a PR was actually doing.
We built Stage to make reviewing a PR feel more like reading chapters of a book, not an unorganized set of paragraphs. We use it every day now, not just to review each other's code but also our own, and at this point we can't really imagine going back to the old GitHub UI.
What Stage does: when a PR is opened, Stage groups the changes into small, logical "chapters". These chapters get ordered in the way that makes most sense to read. For each chapter, Stage tells you what changed and specific things to double check. Once you review all the chapters, you're done reviewing the PR.
You can sign in to Stage with your GitHub account and everything is synced seamlessly (commenting, approving etc.) so it fits into the workflows you're already used to.
What we're not building: a code review bot like CodeRabbit or Greptile. These tools are great for catching bugs (and we use them ourselves!) but at the end of the day humans are responsible for what gets shipped. It's clear that reviewing code hasn't scaled the same way that writing did, and they (we!) need better tooling to keep up with the onslaught of AI generated code, which is only going to grow.
We've had a lot of fun building this and are excited to take it further. If you're like us and are also tired of using GitHub for reviewing PRs, we'd love for you to try it out and tell us what you think!

value: Show HN: Stage – Putting humans back in control of code review


value:
I’ve been working on this tool on and off for a while, and I recently got it back into a shape that feels ready to share.
It’s an open-source cost attribution tool for Kafka systems that supports both identity-level and topic-level attribution. The original version focused only on identity-level attribution using Confluent Cloud API and metrics data. In v2, I expanded it to support topic-level attribution as well.
The backend is Python/FastAPI, and the frontend is React. Compared to v1, which was fully in-memory and depended on Prometheus and Grafana for retention and visualization, v2 adds SQLite-backed persistence, an evolving REST API, and a plugin-based architecture for extending to other ecosystems.
No signups, free to use, and fully open source. I’d appreciate feedback, especially from people who deal with Kafka platform ownership, multi-tenancy, or chargeback/showback problems. I’m actively working on it, and I’d be glad to hear about bugs, gaps, or features that would make it more useful.

value: Show HN: Chitragupta - Kafka Identity and topic level cost attribution


value: Sansparsh

value: Show HN: Modulo – A daily spatial reasoning puzzle

author: Sansparsh


value: modinfo

value: Show HN: MemPalace Agent that sits in front of any LLM endpoint and gives memory

author: modinfo


value: mosspigletdev

value: Show HN: Metamorphic – Zero-knowledge, end-to-end encrypted habit tracker

author: mosspigletdev


value: srothgan

value:
I use Claude Code every day, and the React Ink TUI started buckling whenever the work got real. Multiple agents in parallel, big diffs streaming in, long tool-call chains. The frontend, not the model, was the bottleneck. It was frustrating to me.
So I rewrote it from scratch in Rust on Ratatui. It talks to Anthropic's official Agent SDK through a small TypeScript bridge, so it should follow Anthropic's ToS. Tool calls, file edits, and permissions all work the same. Only the terminal layer changed.
The thing that surprised me: you don't realize how much the UI was shaping your perception of the model until it's gone. With smooth rendering and no input lag, the same Claude that felt slow and buggy before suddenly feels sharp and responsive. The model didn't change. The friction did.
It's pre-1.0. Would love feedback from anyone :)

value: Show HN: A native Rust TUI for Claude Code, because Ink got slow

author: srothgan


value: harthor

value: Show HN: Constellate – Finding patterns by reasoning about groups, not pairs

author: harthor


value:
I built an open-source research agent. You ask a question, it searches the web via Tavily, synthesizes an answer with an LLM, and shows the sources it used. Answers stream in real-time.
The interesting part is the backend. It's a single JS file (~100 lines) that handles web search, LLM streaming, and per-user conversation history. No vector database, no Redis, no separate storage service.
It runs inside a cell — an isolated environment with a built-in database, search index, and filesystem. The cell handles persistence and streaming natively, so the agent code only has to deal with the actual logic.
Tech: Next.js frontend, Tavily for search, OpenRouter for LLM (Gemini 2.5 Flash default).
Demo: https://youtu.be/jvTVA7J925Y

value: Show HN: Open-source Perplexity clone one file back end, streaming answers


value: anju-kushwaha

value:
Claude Opus 4.7 is Anthropic's most capable generally available model, released April 16, 2026. It outperforms Opus 4.6, GPT-5.4, and Gemini 3.1 Pro on key benchmarks including agentic coding, multidisciplinary reasoning, scaled tool use, and agentic computer use. It is benchmarked below Claude Mythos Preview — which remains restricted to Project Glasswing partners.
https://vucense.com/ai-intelligence/ai-tools/claude-opus-4-7...

value: Show HN: Claude Opus 4.7: Everything You Need to Know

author: anju-kushwaha


value: Show HN: HyperFrames – Render Video from HTML via Chrome's BeginFrame API


value: artiomyak

value: Show HN: Online Sound Decibel Meter

author: artiomyak

title: Show HN: Online Sound Decibel Meter


value: denismarkelov

value:
I am making a programming language called Kedr. The code in Kedr is displayed as plain text on Codeberg, so I have made my compiler emit html files that provide navigation, syntax highlighting and tooltips with the type information.
https://codeberg.org/denismarkelov/kedr

value: Show HN: Compiler outputs HTML for code display

author: denismarkelov


value: drdruide

value:
Hey HN,
Last year I built and open-sourced open-launch.com, a Product Hunt-style launch directory. Sold it this summer (low 5 figures). Launchy is the premium rebuild, packaged as a Next.js 16 template.
It's a full Next.js app with Drizzle/Postgres, Better Auth, Stripe Checkout for paid submission tiers and self-serve sponsor slots, R2 uploads, Redis rate limiting, Turnstile captcha, Plunk transactional email, a cron-driven weekly batch that publishes accepted submissions and sends the newsletter, a Tiptap blog, threaded comments with a 26-language profanity filter, and an admin panel with 28 DB-backed settings so customers rebrand without touching code.
Setup with "bun run setup" — most people are live in under an hour.
Pricing: first 10 copies 49 USD, then 79, 99, 129. One-time, lifetime updates, direct support.
Live demo version: launchy.tools

value: Show HN: Launchy – A Next.js template for weekly launch directories

author: drdruide


value: basteez

value: Just released it on maven central https://central.sonatype.com/artifact/it.bstz/jsf-autoreload...

value: Show HN: Maven plugin to enable hot reload on JSF projects

author: basteez


value: Nedomas

value: Built a library to translate between OpenAI Responses/Assistants APIs and other provider APIs. Provides full compatibility so it’s a total drop-in regardless of which provider you use or which features (computer use, web search).<p>End goal will be translating between any SDK and any other SDK with full features, no proxies, no latency.

value: Show HN: AI compatibility without compromises

author: Nedomas


value: Freezone

value: Show HN I made my vacation rental bookable by AI agents–no Airbnb, 0% commission

author: Freezone


value: jaaacckz

value:
Early in my career I worked on DataLab, the sister site to USASpending.gov before it got merged into it. I then worked on USASpending a bit. Datalab had more of a "for the people" storytelling vibe to it which I liked a lot more and I feel that spirit got lost when we "merged" into USASpending. I built The Public Tab in response to this feeling.
My core idea: The district you are in is a more relatable measure of analysis for federal spending for the average person. You want to know what is going on around you. You can more easily "follow the money" this way.
I have a pipeline that runs nightly/weekly with data digest from USASpending, SAM.gov, and some other big players in the space.
You can subscribe to changes and get updates daily/weekly on spending in your district. You can map that to lobbying, new contracts that pop up, as well as what your rep is voting on.
The client libraries are written in ruby and are open source here: https://github.com/govapi-rb
You can also check out the API Docs here: https://thepublictab.com/docs/api
It is deemed "beta" for now.. I'd love any feedback and to hear what is cool and what is not.
Thanks!

value: Show HN: The Public Tab – See every federal dollar flowing through your district

author: jaaacckz


value: sethito

value: Show HN: King Louie a desktop AI with 20 agent tools, no cloud required

author: sethito


value: dubeyKartikay

value: Show HN: Lazyspotify, a Beautiful TUI for Spotify

author: dubeyKartikay


value: aarcamp

value:
Hi HN, I'm a big fan of tmux, so I took a shot at adding what I felt was missing:
- OS-native copy/paste and search from any pane
- A bit more "UI" than just a status bar and border lines
- Persistent remote logins w/o the mental load of tmux-in-tmux
- Pane tabs, so any pane slot can serve multiple purposes
- Access to my running agents anywhere w/ minimal context switching
AFAIK, what I've built occupies a nascent design space: it's not a tmux plugin, and not a traditional terminal app, but an outer overlay layer built around tmux itself. Under the hood it uses tmux control mode, OpenTUI for rendering, libghostty for terminal emulation, and ghostty-opentui for parsing. Basically it adds a new UX layer situated between your emulator and multiplexer, providing a desktop-like environment.
With this architecture, one of the first features I built was global agent visibility and response: if an agent in another pane, window, or session needs attention, just hit a key and a floating overlay connected to that agent's PTY appears so you can respond inline. Or, set hot keys to approve, deny, or jump to the pane, without the full terminal interaction. Integrates with Claude Code, Codex, Gemini, and OpenCode. If you configure remote-backed panes (see below), it will monitor your remote agents as well!
The OS native search/select feature is called "buffer zoom" and works as follows: (a) runs capture-pane on the current pane, (b) disables mouse reporting, (c) temporarily switches out of alternate screen mode, and (d) populates the primary screen with the captured contents. You are then able to use the usual keyboard shortcuts or mouse to search and/or select without relying on tmux copy mode. Meanwhile, PTY output continues to be processed in the background. Hit any key to exit, which re-enables mouse reporting and returns you to the main application view.
Remote-backed panes work like this: (a) user configures an ssh target w/ public key auth, (b) a tmux instance is spawned at that server via an auto-managed background connection, and (c) a synchronized mirror of the local tmux layout is maintained at the remote. With this approach, any local pane can then be converted to a remote one with one click. The idea is to give the user a single combined local+remote workspace without having to manage nested tmux instances.
There are some smaller built-ins too: conversation search, layout profiles, pane screenshots, quick terminal, inactive pane dimming, and root-shell tinting.
This was fun to build and I'd love to hear your feedback and bug reports.
https://hmx.dev
https://github.com/honeymux/honeymux
Thanks, -Aaron

value: Show HN: Honeymux, a TUI wrapper for tmux that simplifies agent-driven workflows

author: aarcamp


value: Show HN: Ternary Bonsai, delivering top intelligence at 1.58 bits


value: dshapi

value:
Hi HN
I’ve been working on an open-source project to explore a problem I keep running into with LLM systems in production:
We give models the ability to call tools, access data, and make decisions…
but we don’t have a real runtime security layer around them.
So I built a system that acts as a control plane for AI behavior, not just infrastructure.
GitHub: https://github.com/dshapi/AI-SPM
What it does
The system sits around an LLM pipeline and enforces decisions in real time:
Detects and blocks prompt injection (including obfuscation attempts)
Forces structured tool calls (no direct execution from the model)
Validates tool usage against policies
Prevents data leakage (PII / sensitive outputs)
Streams all activity for detection + audit
Architecture (high-level)
Gateway layer for request control
Context inspection (prompt analysis + normalization)
Policy engine (using Open Policy Agent)
Runtime enforcement (tool validation + sandboxing)
Streaming pipeline (Apache Kafka + Apache Flink)
Output filtering before response leaves the system
The key idea is:
Treat the LLM as untrusted, and enforce everything externally
What broke during testing
Some things that surprised me:
Simple pattern-based prompt injection detection is easy to bypass
Obfuscated inputs (base64, unicode tricks) are much more common than expected
Tool misuse is the biggest real risk (not the model itself)
Most “guardrails” don’t actually enforce anything at runtime
What I’m unsure about
Would really appreciate feedback from people who’ve worked on similar systems:
Is a general-purpose policy engine like OPA the right abstraction here?
How are people handling prompt injection detection beyond heuristics?
Where should enforcement actually live (gateway vs execution layer)?
What am I missing in terms of attack surface?
Why I’m sharing
This space feels a bit underdeveloped compared to traditional security.
We have CSPM, KSPM, etc… but nothing equivalent for AI systems yet.
Trying to explore what that should look like in practice.
Would love any feedback — especially critical takes.

value: Show HN: Runtime security for AI agents(injection,tool abuse, data exfiltration)

author: dshapi


value: YoungGato

value:
Hey HN,
I made agent-hub an open source tool that lets you talk to all your AI agents running locally or on remote machines.
It works with setups where you already have agents running (Claude Code, Codex, Hermes, OpenClaw, etc.) and just want a simple way to access and use them in one place
Why I built this:
I run agents across a few remote machines + my local computer, and switching between them was painful. Existing tools like Conductor felt too tied to specific workflows (e.g. Git-based), and I couldn’t find anything that handled:
- GTM  tasks
- Coding tasks
- remote agents over SSH
The vision: Build a mobile app to accompany this as well. I find myself talking to my agents on mobile as well.
I am Omar and I vibe coded this over the past weekend :)

value: Show HN: Talk to all your agents in one place

author: YoungGato


value: bkls

value:
Interesting to see that the entrepreneurs from more recent years tend to be doing well relative to years prior.
Some interesting future directions could be:
- Expanding search to be global and include more competitions, like biology and chemistry
- Improving search so less unknown results
- Showing insights, like trends over the years
Kudos to Perplexity Computer for making this

value: Show HN: Tracking Top US Science Olympiad Alumni over Last 25 Years

author: bkls


value: mmethodz

value: Show HN: NoFS – What if files are just projections, graph is the truth?

author: mmethodz


value: It’s a single Go binary that turns unused home GPUs into a decentralized, peer-to-peer AI compute grid. Think SETI@home, but for running local LLMs and AI workloads.

value: Show HN: Rebuilt SETI Home but for AI

title: Show HN: Rebuilt SETI Home but for AI


value: krenerd

value: Show HN: A free Instagram email downloader

author: krenerd


value: yvonboulianne

value: Show HN: LLMs don't hallucinate because they're bad at math, it's the format

author: yvonboulianne


value:
Hi HN — I'm Jiawei, one of two co-founders of VCoding.
4.5mb IDE that uses only 8mb of ram!
Github to check it out: https://github.com/Tonyjw2014/Vcoding
A few honest notes since I'd rather front-run the obvious questions:
What "no dynamic dependencies" means in practice: The binary statically links MSVCRT,OpenSSL, and libssh2. Dynamic imports are 13 Windows OS DLLs (kernel32, user32, gdi32, etc.). No Electron, no Qt, no MFC, no Node, no npm. Whether you call that"zero deps" depends on how strict you are; we try to be precise about it.
Some context for why we built this: our vision is to build a infrastructur designed for AI agents use, in the mean time we were tired of every modern dev tool being a 300-500 MB Chromium wrapper. Zed went hard on speed and ended up at ~400 MB with a GPU requirement. We wanted to see how far the other direction could go. Turns out: pretty far.
Happy to answer any questions
Thanks for taking a look.

value: Show HN: VCoding – A 5 MB native Windows IDE with no dynamic dependencies


value: bushido

value:
Swarms is the result of months of work where I have spent time tuning my memories, skills, and creating prompts which create consistent results when using agent teams.
I originally put this in a plugin to share it with co-workers, friends, and family so that they could achieve similar results to what I was achieving without having to learn all the different whack-a-mole strategies to keep Claude in check.
This was especially helpful over the last week where making some surgical changes allowed me to maintain quality.
Interestingly, with Opus 4.7, I am seeing some degradation in the initial quality of code that the main agent produces, but by the time it goes through the process which has been defined in this structure, it does result in a shape which I've come to expect.
It does especially well with the review cycles and the quality of writing that it can produce.

value: Show HN: Swarm – Get consistent results from Claude Code

author: bushido


value: I built MCP servers for my oscilloscope and SPICE simulator so Claude Code can close the loop between simulation and real hardware.

value: Show HN: SPICE simulation → oscilloscope → verification with Claude Code


value: waterproof

value: Show HN: Free API and widget to look up US representatives

author: waterproof


value: telui

value:
Ignore all the "pay to get credits" platforms, the pay to become a label, what if there was a platform without all the payments!
And thats what we thought...
Introducing LabelCompass, we removed all the bad stuff and made a good website for record labels! You have unlimited submissions because you add your OWN submissions page, and get a handle to share with everybody -- The link is simply "https://labelcompass.pages.dev/labels/@example/"! Ads? Gone! and we bring all your ownership to you, so you never have to worry about copyright being owned by us.
LabelCompass will help songs find their home 1 label at a time.

value: Show HN: LabelCompass, a new website to check for record labels

author: telui


value: ewindisch

value: Show HN: The Onion Shell

author: ewindisch

title: Show HN: The Onion Shell


value: kevinhacker

value: A living collection of real prompts shared by creators on Twitter, covering data viz, portraits, product design, and more.Links back to original tweets.

value: Show HN: A collection of GPT-IMAGE-2 prompts from X(Twitter)

author: kevinhacker


value: Show HN: Hailuo 3.0 AI – AI Video Generator


value: ygudeta

value:
I built *valuepulse.ai* out of a frustration I kept running into: everything is scattered across different tools. If I want to search internal knowledge, I use something like Glean. If I want to analyze data, I switch to a BI tool or a data agent. And if I need external context, I’m back to Google or Perplexity.
Even with all the progress in generative AI, it still feels pretty disconnected.
So I wanted to see if it’s possible to bring search (both web and enterprise) and analytics into one place.
The core idea behind Valuepulse is a *context layer* that models a company’s business domain (customers, revenue, operations, etc.) and sits across different data sources (structured and unstructured). On top of that, I built:
* natural language → dashboard generation (similar idea to tools like Replit/Lovable, but for BI), using agents like text-to-SQL and visualization selection
* a data agent that can query databases and warehouses in plain English
* unified search across internal docs and the web using vector search
It’s still early (beta), but I’d really appreciate feedback—especially on whether this feels useful for real business users (non-technical) or where it might break.

value: Show HN: Valuepulse – search docs, query data, and build dashboards in one place

author: ygudeta


value: RancheroBeans

value: Start with a FREE instant website for your AI on the open internet, then work with it to build a business that sells specialized datasets, files, premium reports, blogs, courses and more.

value: Show HN: Ask your AI to start a business for you, resolved.sh

author: RancheroBeans


value: qwikhost

value: Amazon Reviews Extractor – Export Amazon Product Reviews Instantly for Research & Analysis

value: Show HN: Amazon Reviews Extractor

author: qwikhost

title: Show HN: Amazon Reviews Extractor


value: ksri

value: Pull a google doc in markdown format. Edit the markdown and push. ExtraSuite will figure out the diff and apply them to the google doc, respecting your formatting.

value: Show HN: Treat Google Docs as Markdown

author: ksri

title: Show HN: Treat Google Docs as Markdown


value: edoardobambini-

value: Show HN: Agent Armor, a Rust runtime for enforcing policies on AI agent actions

author: edoardobambini-


value: jamespeng

value:
Hey HN, I built a service that merges user identity across websites, mobile
apps, and in-app WebViews into one profile.
The problem: if you have an app and a website, the same person shows up as 2-4
different "users" in your analytics. Your user counts are inflated, your funnels
are broken, and you're retargeting people who already converted.
I built SDKs (Web, Android, iOS) that handle this server-side. The bit I'm most
proud of is a WebView bridge — when someone opens a link in your app's in-app
browser, the SDKs silently link the sessions without needing a login.
Live demo: https://crosstrack-demo.onrender.com
Is this a problem you've actually hit? Curious what you'd need to try something
like this.
https://crosstrackdata.com

value: Show HN: CrossTrack – Cross-platform identity resolution as a service

author: jamespeng


value: nanojoel

value:
Viche (https://github.com/viche-ai/viche) is a private registry and communication protocol for agents. Overview at https://viche.ai
Think discord + agents + agentic search based on capabilities. We built the agent communication on the Erlang actor model.
No login required, you can simply go to https://viche.ai/dashboard to look around. The https://viche.ai/join page gives you a link you can copy and give to your openclaw, opencode, or other agents to install our communications plugin, and that's it, you're connected.
If you want a more secure (and actually private) registry, you can sign up for an account and create private registries for your agents.
Why did we build it? I wanted my openclaw instance to talk to my other openclaw instance on another computer, or somewhere over the internet. No other solutions on the market solved the needs of my co-founder and I cleanly, so we built Viche.
What can it be used for? We see a few common usecases:
- Comms channel between openclaw agents for people who run their own OpenClaw micro-saas
- Load-balance your anthropic subscription between seats to maximize claude usages
- Allow devs to design agents (which can be done with owl, a meta-harness we've built: https://github.com/viche-ai/owl), and the rest of the org can run the agents from the dev machines
There are many more applications we haven't thought of yet, so we need your help getting this tool in front of others who will also find it useful.
If you have a second, please give it a star and send us along to anyone who would find this interesting

value: Show HN: Viche – OSS private registry for agent communication

author: nanojoel


value: Show HN: Real-time aviation Pirep dashboard built on Cloudflare Workers and D1


value: michaelbrooks

value: I've always felt like Twitch was missing a social aspect, and I'm trying to address it. I know they had Twitch Pulse, and they decided to shut it down, but I'm hoping this can be a better solution.

value: Show HN: I built a Twitch social network

author: michaelbrooks


value: tee-es-gee

value:
Hi HN,
This is Tudor from Xata. You can think of Xata as an open-source, self-hosted, alternative to Aurora/Neon. Highlight features are:
- Fast copy-on-write branching.
- Automatic scale-to-zero and wake-up on new connections.
- 100% Vanilla Postgres. We run upstream Postgres, no modifications.
- Production grade: high availability, read replicas, automatic failover/switchover, upgrades, backups with PITR, IP filtering, etc.
You can self-host it, or you can use our [cloud service](https://xata.io).
Background story: we exist as a company for almost 5 years, offered a Postgres service from the start, and have launched several different products and open source projects here on HN before, including pgroll and pgstream. About a year and half ago, we’ve started to rearchitect our core platform from scratch. It is running in production for almost an year now, and it’s serving customers of all sizes, including many multi-TB databases.
One of our goals in designing the new platform was to make it cloud independent and with a careful selection of dependencies. Part of the reason was for us to be able to offer it in any cloud, and the other part is the subject of the announcement today: we wanted to have it open source and self-hostable.
Use cases: We think Xata OSS is appropriate for two use cases:
- get fast your preview / testing / dev / ephemeral environments with realistic data. We think for many companies this is a better alternative to seed or synthetic data, and allows you to catch more classes of bugs. Combined with anonymization, especially in the world of coding agents, this is an important safety and productivity enabler.
- offer an internal PGaaS. The alternative we usually see at customers is that they use a Kubernetes operator to achieve this. But there’s more to a Postgres platform than just the operator. Xata is more opinionated and comes with APIs and CLI.
Technical details: We wanted from the start to offer CoW branching and vanilla Postgres. This basically meant that we wanted to do CoW at the storage layer, under Postgres. We’ve have tested a bunch of storage system for performance and reliability and ultimately landed on using OpenEBS. OpenEBS is an umbrella project for more storage engines for Kubernetes, and the one that we use is the replicated storage engine (aka Mayastor).
Small side note on separation of storage from compute: since the introduction of PlanetScale Metal, there has been a lot of discussion about the performance of local storage. We had these discussions internally as well, and what’s nice about OpenEBS is that it actually supports both: there are local storage engines and over-the-network storage engines. For our purpose of running CoW branches, however, the advantages of the separation are pretty clear: it allows spreading the compute to multiple nodes, while keeping the storage volumes colocated, which is needed for CoW.
So for now the Xata platform is focused on this, but it’s entirely possible to run Xata with local storage: basically a storage-class change away.
Another small side note: while Mayastor is serving us well, and it’s what we recommend for OSS installations, we have been working on our own storage engine in parallel (called Xatastor). It is the key to having sub-second branching and wake-up times and we’ll release it in a couple of weeks.
For the compute layer, we are building on top of CloudNativePG. It’s a stable and battle-tested operator covering all the production great concerns. We did add quite a lot of services around it, though: our custom SQL gateway, a “branch” operator, control plane and authentication services, etc.
The end result is what we think is an opinionated but flexible Postgres platform. More high level and easier to use than a K8s operator, and with a lot of battery included goodies.
Let us know if you have any questions!

value: Show HN: Xata, open-source Postgres platform with copy-on-write branches

author: tee-es-gee


value: jeffyaw

value:
Hey HN, adding new mcp servers by hand-editing JSON across Claude Code, Claude Desktop, and Cursor is annoying. So I built mcp.hosting, the easiest way to install MCP servers.
Add mcp servers by clicking to add from the Explore page. Or click on github repo badges. Or manually add as well. It's easy to add a bunch in your online account and then they're immediately available in your mcp client of choice. There is also Smart Routing built in to make sure it's fast and uses the best mcp tool for the job.
Free tier covers 3 active servers, Pro is $9/mo for unlimited, and self-host is available if you want to run the whole stack.
Happy to answer questions about the compliance suite (coming soon), the registry, or the stack (Fastify + Postgres + Caddy on EKS).

value: Show HN: mcp.hosting – The easiest way to install MCP servers

author: jeffyaw


value: nielsmouthaan

value:
Hi HN,
I built a small macOS utility to solve something that kept bothering me: external drives not being safely ejected when a Mac goes to sleep, leading to “Disk Not Ejected Properly” warnings and potential data issues.
macOS doesn’t always give volumes enough time to unmount, especially with SSDs, SD cards, or disk images. Manually ejecting works, but it’s easy to forget.
Ejectify automates this by unmounting selected volumes right before sleep (or display off) and mounting them again on wake.
In Ejectify 2, I focused on making (un)mounting more reliable, with an optional helper for better consistency, improved sleep handling to give operations more time to complete, broader volume support, and the ability to suppress system warnings if they still occur.
To celebrate the launch, it’s available for €4.99 (instead of €6.99) with the code EJECTIFY2.
Best, Niels.

value: Show HN: Ejectify 2 Launched: No More "Disk Not Ejected Properly" notifications

author: nielsmouthaan


value: lukaswrede

value:
We're building Soforce, an AI automation platform for businesses. We're not fully autonomous yet — when you describe a process, our team manually reviews it and generates a structured automation plan with a step-by-step workflow and time saving estimate. You receive it within a few hours.
We built this to validate which processes people actually want to automate before we invest in full automation of the pipeline itself. Curious what use cases come in.
Happy to answer questions about the technical setup or the approach.

value: Show HN: Soforce – Describe a process, get a free automation plan from our team

author: lukaswrede


value: cdnsteve

value: Show HN: Real War Room incident simulations for teams

author: cdnsteve


value: TrendRiderAlgo

value: Show HN: Open-source Freqtrade strategy – 66% WR live trading

author: TrendRiderAlgo


value:
We're building Soforce, an AI automation platform for businesses. We're not fully autonomous yet — when you describe a process, our team manually reviews it and generates a structured automation plan with a step-by-step workflow and time saving estimate. You receive it within a few hours.
We built this to validate which processes people actually want to automate before we invest in full automation of the pipeline itself. Curious what use cases come in.
Happy to answer questions about the technical setup or the approach.
-> https://app.soforce.ai

title: Show HN: Soforce – Describe a process, get a free automation plan from our team


value: proshan

value: I built a small CLI after running into UI/UX problems on my own site. It runs quick checks on a URL (layout overflow, tap targets, basic a11y via axe, console/network errors) and outputs a JSON report plus screenshots. Early stage and feedback welcome

value: Show HN: UXRay – CLI to audit UI/UX issues on live websites

author: proshan


value: aleximb

value:
Hi HN,
I've had to pull data from Discourse forums a few times now, and always had to keep dealing with raw requests.get(), rate-limiting and navigating the returned JSON. Our ecosystem is in Python so I looked if there was already a solution, I found pydiscourse (https://github.com/pydiscourse/pydiscourse), but it requires setting up an API key (a hassle) and only returns raw dicts.
There were good solutions in other languages (like discourse2 in TypeScript) but yeah that wasn't in Python.
This is useful if you don't want to set up an API key, only care about retrieving data (not interacting with the platform) and want something in Python. Also has some basic rate-limiting built in!
Example usage:

  from discourse_reader import DiscourseClient
  client = DiscourseClient("https://meta.discourse.org")
  topic = client.topics.get(12345)
  print(topic.posts)
  print(topic.accepted_answer.cooked)

  for topic in client.topics.latest(limit=100):
    print(f"{topic.views:>6} views  {topic.title}")

The Pydantic models are set with extra="allow", so if you use this to hit forums with plugins that have extra fields those won't be dropped.

value: Show HN: Discourse-reader – a typed, read-only Python client for Discourse

author: aleximb


value: Soocile

value:
ShadowStrike Phantom is a Open-Source Endpoint Protection Platform at Github.
Mainly we will have 3 product tiers
|
|->ShadowStrike Phantom Shared Modules(PhantomCore + PhantomEmulator/disassembler + PhantomCortex AI/ML models + PhantomSensor(kernel driver))
|+
|->Phantom Home(For mostly home users - will have a local UI to control the Antivirus and will have some extra stuff like privacy - gamemode etc. For home-users)
|
|->Phantom EDR(For the Endpoints - will have the local web dashboard For Community Enterprise-users + Endpoint-specific additional protections + forensics)
|
|->Phantom XDR(Extended detection for endpoints - will include SIEM Integrations etc. Every related-stuff will be added to this product)
Community/EDR-XDR-Home products will be able to work locally at the Host Machine. And we are planning to do Phantom Pro - Phantom Enterprise products that will include cloud-based systems - Global Threat Intelligence - Online Web Threat Intel Dashboards For companies etc. stuff.[Of course, we need capital to do these things, so they are part of our long-term plan.]
Currently We are mostly extracting the Attack surface-map of the ShadowStrike Phantom and Fuzzing it with our harnesses - Integration/Unit tests - Coverity/PVS-Studio scans - Working with the Product Splits and their own additional protection features - Bugfixes - Security Vulnerabilities - Kernel BSODs. Pretty much everything...
If you are interested in the Open-Source Endpoint Detection and Response/Extended detection and Response/Antivirus Systems and Kernel Stuff and lots of C/C++:
Github : https://github.com/ShadowStrike-Labs/ShadowStrike

value: Show HN: Open-Source ShadowStrike Phantom EDR/XDR Platform Progress-Post

author: Soocile


value: eummm

value: Show HN: AICW Summarize – widget for asking AI about current page (open-source)

author: eummm


value: namirsab

value:
Hey everyone!
For the last 2 weeks, I've been working on an MCP server for my Novation Circuit Tracks (in case you don't know what it is, is just a little device to make electronic music). The idea is simple: I want an AI Agent to be able to make music using my gear, so I gave it tools to do it so I can just say something like "Build me a melodic ambient song with a dark atmosphere" and see the AI just do it.
The whole project is Open Source (https://github.com/namirsab/circuit-tracks-tools) and I've written about it in my blog in case you want to go into more details. It is a fun project
that includes reverse engineering of proprietary file formats.
Would love to hear feedback, both from Circuit Track owners and just in general, what do you think about this idea? Have you tried something similar?

value: Show HN: An MCP server that lets AI compose music on a hardware synth

author: namirsab


value:
I've made [candalf](https://github.com/jarmo/candalf) to setup my own PC and servers by using simple shell scripts instead of using something more complex like Ansible or similar. It's been used by me to manage production servers (physical and VM-s) running Linux/FreeBSD for years now and I'm also using it to configure my own laptop (Linux) so that if I install OS from scratch I can get up to speed really quickly and to also have everything "documented" in the scripts to not waste extra time in the future.
I recently improved it a little to also support macOS, but have not used it for production usage having that OS.
Maybe someone else also finds it useful. If not then also no harm is done.

value: Show HN: Candalf – a simple tool to manage Linux/Unix-like systems via shell+SSH


value: Show HN: WhatsApp CLI without getting banned


value: jpomykala

value:
Hi HN,
I built NotchPrompter because I needed a simple way to read notes while looking at the camera during calls, without heavy or paid software.
- 100% free & open-source
- native macOS (SwiftUI)
- minimalist - focuses on the essentials.
Feedback and contributions are more than welcome!
PS No, I didn't use AI for it. I always wanted to play with SwiftUI and this is my 6th approach to this. Previous projects were too complex for my beginner skills. I'm mainly a Java developer.
It took me ~5 months to build this during free weekends.

value: Show HN: NotchPrompter – A simple, open-source teleprompter for macOS,no AI-slop

author: jpomykala


value: etiennead

value: Would love some feedback!

value: Show HN: My fun laugh inducing/team building app, for dev or sales teams for ex

author: etiennead

story_text: Would love some feedback!


value: Haroonbasil

value: Show HN: GetHireToday – AI resume builder that targets ATS keyword matching

author: Haroonbasil


value: freakynit

value:
https://w418ufqpha7gzj-80.proxy.runpod.net
Started for myself, but since Im not using it continuously, sharing it:
Open Access Qwen3.6-35B-A3B-UD-Q5_K_M with TurboQuant (TheTom/llama-cpp-turboquant) on RTX 3090 (Runpod spot instance).
5 parallel requests supported.. full context available (please don't misuse..there are no safety guards in place)
Open till spot instance lasts or max 4 hours.
And yes, no request logging (I don't even know how to do it with llama-server)
Prompt processing and generation speeds (at 8K context): 900t/s and 60t/s. And at 100K context: 450t/s and 30t/s.
Command used:

    ./build/bin/llama-server \
      -m ../Qwen3.6-35B-A3B-UD-Q5_K_M.gguf \
      --alias 'Qwen3-6-35B-A3B-turbo' \
      --ctx-size 262144 \
      --no-mmproj \
      --host 0.0.0.0 \
      --port 80 \
      --jinja \
      --flash-attn on \
      --cache-type-k turbo3 \
      --cache-type-v turbo3 \
      --reasoning off \
      --temp 0.6 \
      --top-p 0.95 \
      --top-k 20 \
      --min-p 0.0 \
      --presence-penalty 0.0 \
      --repeat-penalty 1.0 \
      --parallel 5.0 \
      --cont-batching \
      --threads 16 \
      --threads-batch 16

Thanks..

value: Show HN: Open Access Qwen3.6-35B-A3B-UD-Q5_K_M with TurboQuant

author: freakynit


value:
We all know the feeling: can’t remember the word but we know what it means. That’s why I built:
WordFor - a reverse dictionary where you describe a concept and it suggests the word you’re looking for.
- Runs entirely in the browser (no server calls)
- No ads, tracking, or accounts
- Low latency (results show up immediately as you type)
Curious how well it works for other people, and happy to answer questions about the approach or tradeoffs.
Technical Blog explaining the workings: https://zshn25.github.io/wordfor-reverse-dictionary/

value: Show HN: WordFor – a free, open, private reverse dictionary running on browser


value: julienreszka

value: I wanted a way to disambiguate my search queries in a sleek user interface so I created this tool that generates google search queries with advanced operators for me.

value: Show HN: Reloadium Search Describe what you want get optimal Google queries

author: julienreszka


value: Lately I've been working on a small tool to generate realistic handwriting animation from any text. Any feedback is welcome, hope you enjoy :)

value: Show HN: Generate a realistic handwriting animation from any text


value: Show HN: Robots2.txt – A robots.txt extension for AI agents and Age ratings


value: qudat

value: Show HN: Zmx – run local code agents on remote machines

author: qudat


value: jimlawruk

value: The map includes the course route, mile markers, gel stations, T and Rail stations. It could be helpful for a runner planning out the route or a spectator navigating the course.

value: Show HN: Boston Marathon Course Map with T and Rail Stations

author: jimlawruk


value: luckystrike

value:
Hey HN
I'd love to get your feedback on Mabon.ai.
I think job search is quite tedious for most people. They scan or subscribe to multiple job boards that often send jobs based on just a few keywords, without actually understanding the user's intent or what kind of job they 'really' want. Most of these job boards also seem to optimize for sending a high volume of matches rather than being targeted.
Mabon first understands the user's background and preferences, and then finds only relevant jobs specific to them.
Users can write anything they want in the preferences - "no consulting companies; only funded startups; salary at least $XXX", etc. After the search, it rates all the openings internally based on the user's profile & preferences, and then shows only the strong matches.
Users can then converse with the agent to further refine the search, and once they think the agent has nailed it down, they can set the search to "always-on", so that it keeps scanning continuously.
It helps both active job seekers and folks who are selectively open to a real high-quality match when it shows up.
Btw, it is not limited to the tech sector; it's meant to work across different types of jobs and industries.
I put this into production just a few days ago, so it could be a bit rough around the edges. Please try it out and share your thoughts on it. Thanks.

value: Show HN: Mabon – AI agent that finds jobs continuously and shows strong matches

author: luckystrike


value: techbelly

value:
Hey HN, recently I wrote an open-source Z-machine (https://github.com/techbelly/elm-zmachine)  to support a course I'm teaching about interpreters and functional programming. Once I'd done that, I just had to make my own client.
Partly, I wanted to enjoy playing the games I played when I was a kid. Partly, I just wanted to give my Z-machine a real test and see what kind of things I could build with access to the internals of the VM.
Those old games could be super-frustrating. Especially the ones that teach you how to play by killing you over and over again - looking at you, Infidel. And while I used to sit and play for hours at a time, these days I only have a few minutes here and there.
So, in Planedrift, every time you move, the full transcript and game state are snapshotted to localStorage. You can close the tab mid-game and come back to exactly where you were or use the history list to jump back in time. The idea is to make it easy to pick up a game for ten minutes and then put it down again.
I'm no designer, and I've done my best to make it pleasant to look at.
Behind the scenes it's written in Elm - which I know is not everyone's first choice, but it works for me! It only supports .z3 files at the minute, and .z5 is in progress. I’ve bundled the three publicly available Zorks, but you can bring your own .z3 file from one of the online archives.
I'm thinking of adding more comprehensive note taking, maybe auto-mapping, transcript search and I'm playing with some plug-in ideas, and of course, dark mode! What do you think? What features should I prioritize?
Ultimately, I hope you play some old Infocom games with Planedrift and enjoy it.

value: Show HN: Planedrift – Play Infocom games in the browser

author: techbelly


value: Show HN: Open source commitment protocol for AI agents


value: graiz

value: I got tired of juggling a stack of dev servers on random ports and never remembering which was which. local.vibe gives me a local TLD that reverse proxies to a specific port. Hit api.vibe or admin.vibe instead of localhost:4317. It's a tiny tool for other localhost vibe coders. Would love feedback.

value: Show HN: Local.vibe – Give localhost ports real names

author: graiz


value: xeubie

value: I couldn't find a database that was immutable (like Datomic) and embedded (like SQLite), so I made one. The reference impl is in Zig and there are now ports for Java, Clojure, TypeScript, and Go.

value: Show HN: XitDB – an immutable single-file database

author: xeubie


value: robin-raq

value: Show HN: Open-source tool that turns audio into playable piano sheet music

author: robin-raq


value: abenzzzz

value: Show HN: StackLens – CLI that explains Spring Boot log errors offline

author: abenzzzz


value: beledev

value: Show HN: Talk to your Oura Ring data

author: beledev

title: Show HN: Talk to your Oura Ring data


value: metahost

value:
I missed DDG style bang! shortcuts but didn't want to switch search engines or use a redirect server. Built this to handle it locally in Safari.
It's private (no tracking), works with any search engine that Safari supports, and lets you make custom shortcuts.
Link: https://apps.apple.com/app/id6762065197

value: Show HN: Bangs – DuckDuckGo-style search shortcuts for Safari

author: metahost


value: mkdirpepper

value: Show HN: Noodlist – Letterboxd for Instant Ramen

author: mkdirpepper


value: blemblemblam

value: Show HN: Use real handwriting for messages and forums (Write Me, Maybe)

author: blemblemblam


value: OOHehir

value: Show HN: Using an AI agent to refine a ML model for Zephyr RTOS

author: OOHehir


value: neozz

value:
Once subagents start spawning other subagents, basic questions get hard to answer: what is running right now, what tool did it just call, did the child agent actually do what the parent asked. I wanted a way to verify that each agent is doing the work that fits its role, and to spot when a run goes off track.
Lazyagent is a terminal TUI that collects events from Claude Code, Codex, and OpenCode and shows them in one place. It groups sessions from different runtimes by working directory, so Claude and Codex runs on the same repo appear under the same project.
Features:
- Filter events by type: tool calls, user prompts, session lifecycle, system events, or code changes only.
- See which agent or subagent is responsible for each action. The agent tree shows parent-child relationships, so you can trace exactly what a spawned subagent did vs what the parent delegated.
- View code diffs at a glance. Editing events render syntax-highlighted diffs inline, with addition/deletion stats.
- Search across all events. You know a file was touched but not which agent did it -- type `/` and find it.
- Check token usage per session. A single overlay shows cost, model calls, cache hit rate, per-model breakdowns, and which tools ran the most.
- Watch a run in real time, or go back through a completed session to audit what happened.
Please let me know if there's any feature you want!

value: Show HN: Lazyagent – Preserve what your AI agents doing and analyze usage

author: neozz


value: evan-choi

value:
My laptop sits to my left, where the camera handles Windows Hello.
My main display is a separate monitor in front of me.
So every sign-in goes: look left at the laptop to get recognized, look right at the monitor to find the "OK" button, click, get on with my day.
Apparently this is the intended UX.
I wanted signing in to be a breeze instead, something that drifts past without you noticing.
So I wrote a small Rust Windows service, Breeze, to do exactly that.
When a Windows Hello credential dialog appears (Okta Verify, sudo-style prompts, and friends), it checks whether face recognition is the active method and, if so, clicks OK for you.
PIN and fingerprint are left alone.
The camera sees you, the dialog quietly closes, you keep working.
Matching uses AutomationId and ClassName rather than button text, so it works regardless of the Windows display language.
A few notes:
- ~2 MB single binary, no runtime deps
- The service runs in Session 0 and spawns a helper into the user session via CreateProcessAsUser with an elevated token from WTSQueryUserToken
- FocusChanged event -> locate "Credential Dialog Xaml Host" -> if a PasswordField is present, it's PIN mode, skip -> otherwise click OkButton
- Does not work for UAC / Secure Desktop prompts. Windows blocks UI Automation there by design.
Install: cargo install breeze-wh && breeze-wh install.
The second command auto-elevates, so no admin shell is needed.
https://github.com/evan-choi/breeze-wh
Feedback is very welcome, especially from anyone with a fingerprint reader.
I only have a face camera, so that path is still untested.

value: Show HN: Breeze, auto-confirm Windows Hello face recognition dialogs

author: evan-choi


value: jmagland

value:
The Asymmetric Numeral Systems (ANS) algorithm (Duda et al, 2015) is perhaps the most practical way of getting near optimal compression ratios for independent and identically distributed random sequences of symbols from a known discrete probability distribution. Simplest example: a random sequence of 0’s and 1’s with probability p of getting a 1. Shannon’s entropy formula gives us the expected compression ratio for such a sequence, but realizing that compression ratio efficiently in a computer program is not such an easy task. ANS does the trick and is incorporated into several general purpose compression algorithms, but I wasn’t able to track down a simple, self-contained implementation that was reasonably performant.
So I made simple_ans, a straightforward Python package that uses a small, yet efficient, kernel of C++ code (few hundred lines of code).
If you want it even simpler, there’s also a pure Python implementation in the repo (much slower though).
I hope you find it interesting and/or useful!

value: Show HN: simple_ans – Asymmetric Numeral Systems Compression in Python/C++

author: jmagland


value: code-in-public

value: Show HN: React Email 6.0 – An open-source email editor you can embed in your app

author: code-in-public


value: tyleo

value: With Rec Room studio closing June 1, we put this site together to help this wonderful team find what's next. If you're hiring, you're in for a treat.

value: Show HN: recroomgrads.com – Celebrating Rec Room's Talented Team

author: tyleo


value: ohmyai

value:
hi HN — we're Cem and Oguzhan. today we are releasing Egregore (https://github.com/egregore-labs/egregore) as an open-source shared memory and coordination substrate for teams using Claude Code. MIT, runs locally, `npx create-egregore@latest --open`. Here's a 90-second walkthrough: https://shorturl.at/e1RX2
we were essentially working on dynamic ontology systems (how to organize unstructured data given context / starting conditions dynamically). since december new capabilities that came around with opus 4.5 completely altered the nature of our work. but despite the radical increase in speed and ambition of our experiments, we were visibly diverging from a common vision. once we acknowledged that together, we decided to find ways to infrastructure mechanisms for convergence. first it was integrating the GitHub organization and repos we are working on, later we developed custom commands that would help us share research, request code reviews and even send each other spam through a tg connector we built for notifications :)
https://imgur.com/a/egregore-telegram-notification-LM0ldPV
we then realized we can integrate the agentic knowledge graph infrastructure we were building for the dynamic ontology research. our stack emerged very rapidly and one week in it was glaringly obvious that we should stop everything and get to working exclusively on this. the speed of accumulation of multi-agent context coupled with frontier model capabilities yielded wow moments one after another. for two months we implemented key features and improved core functionalities.
given our background in organization design and distributed systems, we knew that this was a primitive that should be spread widely and experimented with since there is no single good answer to how an organization should be designed. but it was clear to us that using agent harness form factor as an organization design substrate is incredibly promising given: speed of context accumulation, the continuity (handoffs) it enables between individuals and adaptability of the organization to changing (internal and external) conditions.
anyway, after couple months of wow-ing to our own creation we knew we had to get this out and face the moment of truth whether: we actually built something interesting or we are getting high off our own supply. so thats what we are doing today: we created a version of egregore — slash commands, git-backed markdown memory, Claude Code hooks — that is self-hosted and without dependencies (no knowledge graph etc) so that we can release it as a viable open-source primitive anyone can use and mutate according to their needs with their friends and colleagues.
what you can do with it today:
- `/invite` — onboard a teammate with the full accumulated context already in place
- `/handoff` — pass a session on with reasoning and context preserved. the next person, future-you, or their agent picks up the thread without restarting
- `/activity` — see what the team has actually been doing, synthesized from real sessions
- `/deep-reflect` — cross-reference an insight against the organization's full memory
- `/view` — render a shareable artifact from any slice of what the team knows
excited to have you all try, and get your feedback.

value: Show HN: Egregore – Shared memory and coordination for multiplayer Claude Code

author: ohmyai


value: ahuth

value:
Introducing Prism, one inbox for pull requests across both Github and Gitlab.
AI makes it easy to generate a lot of code and PRs, so Prism makes it easy to track which PRs needs your attention. Eventually I'd like to make a great code review UI as part of this, too, but baby steps.
Free while in beta. Give it a shot, and let me know what you think.

value: Show HN: Prism, one inbox for GitHub and GitLab PRs

author: ahuth


value: chrka

value: Show HN: Interactive demos of sorting algorithms with runtime comparisons

author: chrka


value: tiagodeoliveira

value: Show HN: An AI memory that follows you

author: tiagodeoliveira

title: Show HN: An AI memory that follows you


value: igtumt

value:
Hi everyone,
I built a small tool called GitShrink to solve a simple problem: making videos small enough (<10MB) to upload to GitHub.
It runs entirely in the browser, so nothing is uploaded anywhere.
Website: https://igtumt.github.io/gitshrink/
GitHub: https://github.com/igtumt/gitshrink
It’s a small, local-first tool with no accounts, no tracking, and no backend.
Use cases:
README demo videos
Small product demos
Screen recordings for GitHub
Feedback is welcome.

value: Show HN: GitShrink – A simple in-browser video compressor for GitHub uploads

author: igtumt


value: codeguruking

value:
I built a mock server that reads an OpenAPI spec and serves realistic, deterministic responses — no mock definitions, no config files.
```
mimikos start petstore.yaml
```
That's the entire setup. Mimikos parses your spec, classifies each endpoint (create, fetch, list, update, delete), and generates schema-valid responses with realistic data. Same request always returns the same response, so it's safe for snapshot tests and CI.
What's different from Prism, WireMock, etc.:
Most mock servers either (a) require you to hand-write every response, or (b) generate random data that changes on every request. When the spec changes, your mocks break — or worse, silently become wrong.
Mimikos sits in an unoccupied spot: zero config + high-quality responses. The key piece is behavioral inference — a three-layer heuristic classifier that determines what each endpoint does (not just what it returns) from the HTTP method, path structure, response schema, and operationId. It gets this right 96% of the time across a 344-endpoint corpus (Stripe, GitHub, Asana, Spotify specs).
Features:
1. Deterministic responses via request fingerprinting + per-field sub-seeding (adding a field to your schema doesn't change existing field values)
2. Stateful mode (`--mode stateful`) for full CRUD workflows — POST creates, GET retrieves, DELETE removes
3. 120+ semantic field mappings — `email` gets an email, `name` gets a name, `url` gets a URL
4. Spec-authored `example` values used directly when present
5. RFC 7807 error responses with field-level diagnostics for invalid requests
6. Single Go binary, no runtime dependencies, <50ms responses
Technical details:
The architecture separates startup from runtime: spec parsing, schema compilation, and behavior classification happen once at startup. At request time, it's routing + deterministic generation from a pre-computed seed. No AI in the request path — no LLM calls, no network dependencies.
I explored using LLMs for behavior classification twice (GPT-4.1, Claude) and they scored worse than the heuristic both times. The heuristic wins because it can exploit structural signals (path patterns, schema shapes) that LLMs tend to ignore in favor of semantic reasoning.
Written in Go, single binary. OpenAPI 3.0 and 3.1. Apache 2.0 licensed.
- Get started: https://mimikos.dev/getting-started/
- Repo: https://github.com/mimikos-io/mimikos

value: Show HN: Mimikos – Zero-config mock server that infers API behavior from OpenAPI

author: codeguruking


value: ppolicyco

value: PayPal's crypto services will transition from PayPal, Inc. to PayPal Digital, Inc. effective on or after April 20, 2026.

value: Show HN: Amendments to the PayPal Cryptocurrency Terms and Conditions

author: ppolicyco


value: betocmn

value: Show HN: Preseason – see which developer tools each LLM picks

author: betocmn


value: devmegablaster

value: Show HN: I turned my MacBook notch into a live Claude Code dashboard

author: devmegablaster


value: imbd

value: Show HN: AI Hat Arena – real-time voice charades with AI

author: imbd


value: sageframe

value: Show HN: Glassroom – See what's happening in your kid's Google Classroom

author: sageframe


value:
I read HN every day, usually late at night and have seen people request a dark mode many times. Basically, I couldn't find one that I liked, so I built the one that I've always wanted.
It's inspired by terminal and IDE themes.
A few cool features:
- j/k to move, Enter to open, v to cycle density, 1–9 to switch themes, Esc to close
- Three density modes: compact, comfortable, and an immersive reading view
- 8 terminal-inspired themes (dracula, solarized, monokai, one dark, etc.)
- Article preview pane that pulls OG metadata so you can skim without leaving the feed
Stack: vanilla TypeScript + Vite, Cloudflare Pages Functions, CapacitorJS for the iOS/Android wrappers.
Android and iOS apps coming soon, if folks request it.
Would especially appreciate feedback and upvotes.
Thanks for reading this far!

value: Show HN: Dark Mode for Hacker News

title: Show HN: Dark Mode for Hacker News


value: modinfo

value: Show HN: I'm Just create a simple dock for Wayland in Rust

author: modinfo


value: I got tired of social media turning photographers into marketers and optimizing art for algorithms. I built Gallery Anonima as an "antisocial" network. There are no likes, comments, followers, or personal profiles. It’s just a quiet place to share photos anonymously. The focus is entirely on the image, not the engagement. Would love for you to check it out and hear your thoughts.

value: Show HN: I made a anonymous gallery / Anti Social Media


value: cedric-hsu

value: Show HN: I built a keyword research tool that doesn't require $99/month

author: cedric-hsu


value: sidneyottelohe

value: Show HN: Clamp – Web analytics your AI agent can read and query

author: sidneyottelohe


value: seanieb

value:
I wrote this after the case of a Washington Post reporter, Hannah Natanson, was compelled to unlock her computer with her fingerprint. This resulted in access to her Desktop Signal on her computer, revealing sources and their conversations.
https://www.yahoo.com/news/articles/washington-post-raid-pro...
Edit: I've a lot more details about the legality and precedence on the apps landing page https://paniclock.github.io/

value: Show HN: PanicLock – Close your MacBook lid disable TouchID –> password unlock

author: seanieb


value: It lets you search 1M+ jobs across multiple regions, refine by keyword/category/location, upload a plain text resume for better matching, filter by target companies. Searches, keywords extracted from resume and bookmarks are saved locally, and no signup is required.<p>I developed it mostly as a project to learn RAG etc but hoping it is now useful enough to be an additional tool for job seekers.

value: Show HN: Corvi Careers – privacy first job search with resume matching


value: pzxc

value:
I used to run a flash games website (SWF files) years ago. I've made a few games of my own. I'm also an avid gamer and love to play games of all kinds.
I'm also a software engineer, and a few days ago I decided I wanted to run a games website again. So I bought the domain gamevibe.us and with the help of Claude I've been vibe-coding one video game every day since.
Happy to answer questions, take feedback, etc -- don't hold back, I know it's pretty elementary so far

value: Show HN: Vibe-coding video games with Claude

author: pzxc


value: julsimon

value:
A terminal UI (TUI) for exploring, auditing, and cleaning developer cache directories on macOS and Linux. Scan cached packages for known CVEs, find outdated dependencies, and reclaim disk space — all from one tool.
Developer machines accumulate tens of gigabytes of invisible cache data — ML models, package archives, build artifacts, downloaded bottles. ccmd makes it all visible, scannable for vulnerabilities, and safely deletable.
brew tap juliensimon/tap && brew install ccmd
cargo binstall ccmd

value: Show HN: Ccmd – TUI to audit and clean developer caches

author: julsimon


value: VictorChanet

value: Show HN: USourceControl – Git and Perforce alternative for game studios

author: VictorChanet


value: riyaneel

value: Show HN: Tachyon: 56 ns zero-copy IPC across Python, Rust, Java

author: riyaneel


value: DavidCanHelp

value: Show HN: Bird, a CLI for Tired Brains

author: DavidCanHelp

title: Show HN: Bird, a CLI for Tired Brains


value: binsquare

value: Show HN: Smol machines – subsecond coldstart, portable virtual machines

author: binsquare


value: jshchnz

value:
Built this code art project as a commentary on the recent wave of using LOC as a primary measure of engineering productivity
It's now up to 350M lines of useless (but hopefully funny) code, constantly growing using GitHub actions and https://github.com/jshchnz/codemaxxing
Unfortunately, GitHub has now sent me a notice to remove the repo within the next 14 days, so enjoy it while you can

value: Show HN: Codemaxxed – 350M+ LOC and a GitHub cease and desist

author: jshchnz


value: Show HN: EX LIBRIS – a library-crawling RPG made with a 2000s engine


value: landdate

value:
Small cli program I made to convert and modify bookmark files. Supports converting between json and netscape bookmark file format (default formatted exported by chrome/firefox).
I created this because I have a lot of bookmarks across devices that I want to batch edit/delete and I can't always just directly modify the local browser db.
Not many filters implemented so far, but I made it easy to add filters see: https://github.com/ediw8311xht/cl-bookmark-tool/blob/main/sr...

value: Show HN: Bookmark Tool in Common Lisp

author: landdate

title: Show HN: Bookmark Tool in Common Lisp


value: marcandrysco

value:
Waputer is an operating system that runs entirely in the browser. When you visit the website at https://waputer.app, a kernel written in JavaScript sets up a filesystem and launches a WebAssembly program, which in turn talks to the kernel to handle the display and input. A purely terminal-based version is at https://waputer.dev.
My original intention was to create programs that run in the browser that have a lot more in common with the desktop. The traditional "hello world" program is not really suited for the web. Waputer changes that. The GitHub repo at https://github.com/waputer/docs gives a very brief overview of compiling a C program and running it on Waputer. There is a blog available from the main site that has a long-form explanation of Waputer and my motivations if you want some additional reading.

value: Show HN: Waputer – The WebAssembly Computer

author: marcandrysco


value: linsys

value: I've been presenting at local meetups about Context Engineering, RAG, Skills, etc.. I even have a vbrownbag coming up on LinkedIn about this topic so I figured I would make a basic example that uses bedrock so I can use it in my talks or vbrownbags. Hopefully it's useful.

value: Show HN: A working reference implementation of context engineering

author: linsys


value: Show HN: Arc Browser UI Skeleton (Next.js)


value: seanhly

value: I made this tool that allows server admins to decrypt passwords during bootup with the help of Matrix and HTTP.

value: Show HN: web-pinentry: a pinentry program that leverages matrix and http

author: seanhly


value: netnameus

value: Show HN: Smith – AI Agent Orchestrator

author: netnameus

title: Show HN: Smith – AI Agent Orchestrator


value:
I've grown increasingly skeptical that public coding benchmarks tell me much about which model is actually worth paying for and worried that as demand continues to spike model providers will silently drop performance.
I did a few manual analyses but found it non-trivial to compare across models due to difference in token caching and tool-use efficiency and so wanted a tool for repeatable evaluations.
So the goal was an OSS tool get data to help answer questions like:
“Would Sonnet have solved most of the issues we gave Opus?
"How much would that have actually saved?”
“What about OSS models like Kimi K2.5 or GLM-1?”
“The vibes are off, did model performance just regress from last month?”
Right now the project is a bit medium-rare - but it works end-to-end. I’ve run it successfully against itself, and I’m waiting for my token limits to reset so I can add support for more languages and do a broader run.  I'm already seeing a few cases where I could've used 5.4-mini instead of 5.4 for some parts of implementation.
I’d love any feedback, criticism, and ideas.  I am especially interested if this is something you might pay for as a managed service or if you would contribute your private testcases to a shared commons hold-out set to hold AI providers a bit more accountable.
https://repogauge.org
hi@repogauge.org
https://github.com/s1liconcow/repogauge
Thanks!
David

value: Show HN: RepoGauge – save token costs and compare agents on your own repos


value: nahrin

value: Show HN: Navox Agents – 8 AI Agents for Claude Code with HITL Checkpoints

author: nahrin


value: overflowy

value: On page load, it canonicalizes the current URL (strips query params, fragment, www., trailing slash, and protocol) and queries the HN Algolia API, then updates the menu label with the result count (e.g. "3 results" or "No results"). If you're already on a news.ycombinator.com/item page, it extracts the submitted URL from the post and searches for that instead.

value: Show HN: Userscript that shows HN submission count for any page

author: overflowy


value:
Hey HN, Sjoerd de Vries here. I have worked on Seamless for nearly 10 years now. It has been used in my lab, but I was always around for troubleshooting. This is the first time that I think it's ready to stand on its own. I would love to hear your thoughts about it.
It started as a hobby project, I had an itch about programming not being at-your-fingertips enough. Then I applied it to my work as a bioinformatics research engineer. The early versions focused on interactive workflows. After a year or two I realized that to make interactivity work properly, you need really good DAG tracking, so checksums were added everywhere. My lab built a collaborative web server with it that we published. More recently I've rebuilt it around the command line, persistent caching, and remote deployment.
It's still in alpha, but the core is usable.
Core idea: same code + same inputs = same result, identified by checksum. If you've already computed it, you don't compute it again.
Two entry points:
Python:

  from seamless.transformer import direct

  @direct
  def add(a, b):
      import time
      time.sleep(5)
      return a + b

  add(2, 3)   # runs, caches result
  add(2, 3)   # cache hit — instant

Bash:

  seamless-run 'seq 1 10 | tac && sleep 5'    # runs, caches result
  seamless-run 'seq 1 10 | tac && sleep 5'    # cache hit — instant

With persistent caching enabled, results are stored as checksum-to-checksum mappings in a small SQLite database that can be shared with collaborators, so that they get cache hits too.
Execution scales by changing config, not code: in-process, spawned workers, or a Dask-backed HPC cluster.
Remote execution also doubles as a reproducibility test. If your code produces the same result on a clean worker, it's reproducible. If not, Seamless helped you find the problem, whether it's a missing dependency, an undeclared input, or a platform sensitivity.
Built for scientific computing and data pipelines, but works for anything pipeline-shaped.

value: Show HN: Seamless – Content-addressed computation caching for Python and bash


value: modinfo

value: Show HN: Wrong Side of Zero – Google Flow Music [video]

author: modinfo


value: paperlantern

value:
Paper Lantern is an MCP server that lets coding agents ask for personalized techniques / ideas from 2M+ CS research papers. Your coding agent tells PL what problem it is working on --> PL finds the most relevant ideas from 100+ research papers for you --> gives it to your coding agent including trade-offs and implementation instructions.
We had previously shown that this helps research work and want to know understand whether it helps everyday software engineering tasks. We built out 9 tasks to measure this and compared using only a Coding Agent (Opus 4.6) (baseline) vs Coding Agent + Paper Lantern access.
(Blog post with full breakdown: https://www.paperlantern.ai/blog/coding-agent-benchmarks)
Some interesting results :
1. we asked the agent to write tests that maximize mutation score (fraction of injected bugs caught). The baseline caught 63% of injected bugs. Baseline + Paper Lantern found mutation-aware prompting from recent research (MuTAP, Aug 2023; MUTGEN, Jun 2025), which suggested enumerating every possible mutation via AST analysis and then writing tests to target each one. This caught 87%.
2. extracting legal clauses from 50 contracts. The baseline sent the full document to the LLM and correctly extracted 44% of clauses. Baseline + Paper Lantern found two papers from March 2026 (BEAVER for section-level relevance scoring, PAVE for post-extraction validation). Accuracy jumped to 76%.
Five of nine tasks improved by 30-80%. The difference was technique selection. 10 of 15 most-cited papers across all experiments were published in 2025 or later.
Everything is open source : https://github.com/paperlantern-ai/paper-lantern-challenges
Each experiment has its own README with detailed results and an approach.md showing exactly what Paper Lantern surfaced and how the agent used it.
Quick setup: `npx paperlantern@latest`

value: Show HN: Paper Lantern – on-demand techniques from 2M+ papers for coding agents

author: paperlantern


value: twelvenmonkeys

value:
Hunk-by-hunk and line-by-line staging for git, designed for building clean commit history!
Writing code is messy. Git history doesn't have to be.
During development we experiment, refactor, backtrack, and fix mistakes. If every step ends up as a commit, the history becomes noise. A curated history turns that process into a clear sequence of logical changes.
git-stage-batch helps you build that history incrementally by letting you stage changes hunk-by-hunk or line-by-line, shaping commits around meaning instead of the order the edits happened.

value: Show HN: Git-stage-batch – curate clean commit history before pushing

author: twelvenmonkeys


value: ajayarama

value:
AI is in a weird place right now. Technical people marvel over it while non-technical people don't really care.
So we built Co-Op, an app specifically designed for non-technical people to run AI agents without needing a Mac Mini or laptop running 24/7. Your agents run throughout the day and complete real work across your most important apps, no code required.
For me, this looks like a daily notification with my unread emails across Outlook, Gmail, and any other inbox, the weather, commute time, flight prices I'm monitoring, and the news. But it goes way beyond that. Our agents can build slideshows on Google Slides, track your finances, follow sports scores, summarize and write documents, manage your calendar, and a lot more. All running in the background without you having to constantly prompt.

value: Show HN: Co-op: Your 24/7 Digital Intern

author: ajayarama


value: bayff

value: Show HN: Agents.ml – a public identity page and A2A card for your AI agent

author: bayff


value: danielbilekq

value: Show HN: Jean2 – An Open-Source Agent You Assemble Like Lego

author: danielbilekq


value: akadeb

value: Cloudflare's recent voice agents release provides a free daily tier for Deepgram STT, TTS use.<p>So I created a Voice AI Agent pipeline that runs on Cloudflare workers with Durable Objects and it interfaces with an Arduino ESP32. This lets you bring any LLM to power your Voice AI Toys and Desk companions with STT + TTS handled natively.

value: Show HN: Realtime Voice AI on ESP32 with Cloudflare Durable Objects

author: akadeb


value: arjunchint

value:
We built AI Subroutines in rtrvr.ai. Record a browser task once, save it as a callable tool, replay it at: zero token cost, zero LLM inference delay, and zero mistakes.
The subroutine itself is a deterministic script composed of discovered network calls hitting the site's backend as well as page interactions like click/type/find.
The key architectural decision: the script executes inside the webpage itself, not through a proxy, not in a headless worker, not out of process. The script dispatches requests from the tab's execution context, so auth, CSRF, TLS session, and signed headers get added to all requests and propagate for free. No certificate installation, no TLS fingerprint modification, no separate auth stack to maintain.
During recording, the extension intercepts network requests (MAIN-world fetch/XHR patch + webRequest fallback). We score and trim ~300 requests down to ~5 based on method, timing relative to DOM events, and origin. Volatile GraphQL operation IDs are detected and force a DOM-only fallback before they break silently on the next run.
The generated code combines network calls with DOM actions (click, type, find) in the same function via an rtrvr.* helper namespace. Point the agent at a spreadsheet of 500 rows and with just one LLM call parameters are assigned and 500 Subroutines kicked off.
Key use cases:
- record sending IG DM, then have reusable and callable routine to send DMs at zero token cost
- create routine getting latest products in site catalog, call it to get thousands of products via direct graphql queries
- setup routine to file EHR form based on parameters to the tool, AI infers parameters from current page context and calls tool
- reuse routine daily to sync outbound messages on LinkedIn/Slack/Gmail to a CRM using a MCP server
We see the fundamental reason that browser agents haven't taken off is that for repetitive tasks going through the inference loop is unnecessary. Better to just record once, and get the LLM to generate a script leveraging all the possible ways to interact with a site and the wider web like directly calling backed API's, interacting with the DOM, and calling 3P tools/APIs/MCP servers.

value: Show HN: AI Subroutines – Run automation scripts inside your browser tab

author: arjunchint


value: seanhly

value:
I built this tool a while back when I accidentally deleted thousands of my PDFs.  I found the existing ext4magick and similar solutions to be cumbersome and complicated to use, and wanted something similar that just did PDFs.
As a bonus, because it only handles PDF documents, the pattern recognision is super simple, allowing this program to scan through a disk at high speed, like the maximum read speed for your disk.
Hope people find it useful.
Mirror: https://github.com/seanhly/recover-pdfs

value: Show HN: recover-pdfs is a tool for revovering all the deleted PDFs from a disk


value: Show HN: Mind-OS – First free online AI dependency self‑assessment


value: trey-orr

value:
I’ve been working on Pyra for the past few months and wanted to start sharing it in public.
Right now it’s focused on the core package/project management workflow: Python installs, init, add/remove, lockfiles, env sync, and running commands in the managed env.
The bigger thing I’m exploring is whether Python could eventually support a more cohesive toolchain story overall, more in the direction of Bun: not just packaging, but maybe over time testing, tasks, notebooks, and other common workflow tools feeling like one system instead of a bunch of separate pieces.
It’s still early, and I’m definitely not claiming it’s as mature as uv. I’m mostly sharing it now because I want honest feedback on whether the direction feels interesting or misguided.

value: Show HN: Pyra – a Python toolchain experiment inspired by uv and Bun

author: trey-orr


value: pinfloyd

value:
Built this around one simple idea:
the workflow that wants to execute should not be the same place that decides whether execution may continue.
This project puts an external allow/deny boundary before action.
Public entry points:
* live pilot
* commercial request
* private deployment
There is also a GitHub Marketplace action install surface, but the main point is the boundary model itself: decision stays outside the workflow that is asking to proceed.
Looking for feedback from people working on CI/CD, security controls, approval boundaries, and automated execution.

value: Show HN: External admission gate for GitHub Actions before execution

author: pinfloyd


value: thrinz

value: Show HN: Cogveo–Schedule AI agents to run Python on your files and email results

author: thrinz


value: Show HN: codeburn-rs; CodeBurn but 600x faster in Rust [view coding token usage]


value: We compared four architectures for putting AI agents on websites — RAG bots, API-tool agents(WebMCP), code-writing sandboxes (Cloudflare Agent Lee), and DOM-native execution. Three of them force you to maintain a parallel engineering surface. The DOM already has live state, user auth, and permissions baked in. A structural breakdown of why.

value: Show HN: AI agents should browse your site, not call your API


value: beeswaxpat

value: Show HN: Agentic Dev – AI dev-tools news, curated daily by Claude

author: beeswaxpat


value: anju-kushwaha

value:
Complete llama.cpp tutorial for 2026. Install, compile with CUDA/Metal, run GGUF models, tune all inference flags, use the API server, speculative decoding, and benchmark your hardware.
https://vucense.com/dev-corner/llama-cpp-tutorial-run-gguf-m...

value: Show HN: Llama.cpp Tutorial 2026: Run GGUF Models Locally on CPU and GPU

author: anju-kushwaha


value: rayneclarke

value: Show HN: PodWarden – A catalog of 9k+ self-hosted apps with one-click deploy

author: rayneclarke


value: rajatady

value: Show HN: Irl.rent – What renters pay, not what's listed in SF

author: rajatady


value: SowjanyaY

value: Show HN - TokensAI – Mint for AI Usage

author: SowjanyaY

title: Show HN - TokensAI – Mint for AI Usage


value: rednakta

value:
I built this to run OpenClaw safely. The problem: every sandbox I tried still handed the real API token to the agent as an env var.
nilbox never gives the agent the real token. It gets a fake placeholder instead (ANTHROPIC_API_KEY=ANTHROPIC_API_KEY). nilbox intercepts outbound API calls and swaps in the real token at the network layer.
So if the agent leaks the "token" — attacker gets a useless string. That's it.
Also ships a managed Linux runtime (consistent across mac/win/linux) and a Store for one-click agent app installs. Full shell access too.
Available for macOS, Windows, and Linux
https://nilbox.run
Curious how others are thinking about token security when running agents locally.

value: Show HN: Nilbox – Run OpenClaw without exposing your API tokens

author: rednakta


value:
I've been studying interval arithmetic for the past few weeks and it's a really interesting field because while there is a ton of super interesting research published over the past decades, it has never really gotten the recognition that it deserves, IMO.
One reason for this is that standard interval arithmetic has really poor handling of division by intervals containing zero. If you compute 1 / [-1, 2] in regular interval arithmetic, you get either [-∞, +∞], or you have to say that the operation is undefined. Both solutions are virtually useless. The real answer of course is [-∞, -1] U [0.5, +∞]: i.e. a union of two disjoint intervals.
This is useful because you can confidently exclude a non empty set of the real numbers ([-1, 0.5]) from the set of possible values that you can get by dividing 1 by a number between -1 and 2.
But this definition of interval division yields a value that is not an interval. This is a problem if you want to define a closed arithmetic system, where you can build and evaluate arbitrary expression over interval values.
(This behavior extends to any non continuous function like tan() for example, which is implemented in my project - not without difficulties!)
Well the obvious solution is to define your arithmetic over disjoint unions of intervals. This is the subject of a 2017 paper called "Interval Unions" by by Schichl, H., Domes, F., Montanher, T. and Kofler, K..
This open-source project I made implements interval union arithmetic in TypeScript in the form of a simple interactive calculator, so you can try it out for yourself! The underlying TypeScript library is dependency free and implements interval union arithmetic over IEEE 754 double precision floats (JS native number type) with outward rounding. This guarantees accuracy of interval results in the presence of rounding issue inherent to floating point.

value: Show HN: I made a calculator that works over disjoint sets of intervals


value: trezm

value:
Hi all,
I've been working on Small for a bit now, and I think it's ready to share. The idea being that larger writing platforms have memberships and have become an untenable way to truly share content. Small represents a return to paying writers and creators for their content. We chose to use x402 to embrace open protocols and payment rails.
Still lots to do, so please leave any things you do or don't like and we'll start to address them!

value: Show HN: Small, an x402 powered writing site

author: trezm


value:
devnexus is an open-source cli that gives agents persistent shared memory across repos, sessions, and engineers.
It maps out dependencies and relations at the function level, builds a code graph, and writes it into a shared Obsidian vault that every agent reads before writing code. Past decisions are also linked directly to the code they touched, so no one goes down the same dead end twice.
Still building it out but I would love to hear any thoughts/feedback

value: Show HN: devnexus – persistent context across repos, sessions, and engineers


value: olliewagner

value:
I found myself reaching for SF Symbols' 'Copy Image As…' quite often during agentic design sessions, so I made a command-line tool that the agent can use by itself. It exports Apple SF Symbols as SVG, PDF, or PNG.
The vector paths come directly from macOS's symbol renderer. Internally it reaches a private ivar on NSSymbolImageRep to get the CUINamedVectorGlyph, draws into a CGPDFContext, then walks the PDF content stream back out as SVG `d` commands. The output matches what the system draws, rather than an approximation traced from rasters.
A few things about it:
- Every subcommand accepts `--json`, and `sfsym schema` returns a machine-readable description of the whole CLI.
- Symbol enumeration reads the OS's Assets.car BOM tree, so the list of 8,300+ names stays current with macOS updates without a version table in the binary.
- Each SVG `<path>` carries a `data-layer` attribute, so you can retheme in CSS without touching geometry.
It's been saving me a bunch of clicking. Please let me know if you have any other ideas for it.

value: Show HN: Sfsym – Export Apple SF Symbols as Vector SVG/PDF/PNG

author: olliewagner


value: dharmatech

value:
Hey y'all,
Here's a walkthrough of how I use the 9front distribution of Plan 9 on Windows:
https://www.youtube.com/watch?v=IzEa2L_Pgw0
Topics covered:
- 9front distribution of Plan 9 running in qemu on Ubuntu inside WSL on Windows 11
- Drawterm running natively on Windows 11
- Running arbitrary commands on Plan 9 from Ubuntu
- Mounting a directory from Plan 9 on Ubuntu
- Using OpenAI codex LLM with Plan 9
- Editing files on Plan 9 with vscode
Comments and suggestions are welcome.

value: Show HN: My workflow for using Plan 9 on Windows

author: dharmatech


value: qwikhost

value: Download HD Twitter Videos & Images Instantly | Fast, Private Tweet & Profile Media Saver with Twitter Media Downloader

value: Show HN: Twitter Media Downloader – X Media Downloader

author: qwikhost


value: wyxuan

value:
Transcribe the audio (passing it in at 2x speed) via whisper, use a cheap LLM to identify the ad snippets, and then take it out!
Have been using for the past couple days - it's not perfect but I've enjoyed using it.
Feel free to add your episodes!
https://github.com/mergd/podads

value: Show HN: Podads – An Ad Blocker for Your Podcasts

author: wyxuan


value: jonypopovv

value:
Built InGaming as a frontend MVP for the iGaming space, with two main parts:
1. a back-office admin for casino / gambling operations
2. a multi-brand storefront system for casino sites
The starting point was simple: in all the years I’ve worked around iGaming, I haven’t seen a single admin panel I’d call genuinely good. Most of them are either bloated, awkward to use, or patched together from disconnected tools that don’t really fit how teams work day to day. So I decided to build the kind of admin I actually wish existed.
On the admin side, the MVP includes flows for players, payments and transactions, casino and sportsbook operations, content and static pages, reporting, and website configuration.
On the storefront side, I built a separate frontend repo to validate a multi-brand setup on shared foundations. Right now that includes two demo brands: BetStake and ShipBet.
Important caveat: this is frontend work and product validation, not a finished end-to-end platform. I’m treating it as an expanded MVP that is already strong enough to be a serious starting point, rather than just another rough concept.
What I’m really trying to figure out now is whether this is already valuable as a project someone could buy as a head start. My view is that it could save a lot of time for a team that would otherwise need to build the admin, storefront layer, and overall product structure from scratch.
Happy to answer product or frontend architecture questions.

value: Show HN: InGaming, front end MVP for casino brands

author: jonypopovv


value: vlidholt

value:
Artificial intelligence is an amazing tool for brainstorming, programming, or generating images. But it’s also incredibly good at writing long, meaningless text filled with platitudes or producing code that continuously reinvents the wheel or misses edge cases. This has become known as slop.
My inboxes have been increasingly filled with low-effort slop. I’m sure that this happens to many of you, too. The reddest of flags is being sent slop for work; at first glance, it may look credible, but it falls apart when you actually read the text.
This prompted me to write three principles for working with AI and creating a website to send to your friend or colleague when they send you slop.
Let's stop the slop and get back to doing great work together.

value: Show HN: A site for stopping work slop

author: vlidholt

title: Show HN: A site for stopping work slop


value: roomymy

value: Show HN: Saucybargain – a community for bargains with zero affiliate marketing

author: roomymy


value: felixne

value:
Hi HN, I'm the builder.
I realized that using cloud AI APIs for sensitive workflows—like transcribing board meetings, OCRing employment contracts, or cleaning up ID photos—is a massive privacy liability.
So I built a client-side workspace using transformers.js, Whisper, and WebGPU. Everything runs locally. You can turn on Airplane Mode after the initial model load, and it still transcribes and extracts text perfectly.
To keep myself honest, I wrote a technical audit of how the data flows (or rather, doesn't flow). My only backend is a tiny 2-core node in Singapore running self-hosted Plausible analytics: [https://gist.github.com/ygx2378/3275b333504c6a9def50ef531b54...]
I'm still learning the ropes of browser-based memory management, so I'd love your feedback on how the models load on your specific GPUs!

value: Show HN: PrivaKit – A zero-upload AI workspace in the browser via WebGPU

author: felixne


value: ispaceman

value: Show HN: I made a self-employed expense keeper

author: ispaceman


value: pixelatedRudy

value:
Hi HN,
I've been doing freelance work and realized the most stressful part of the entire lifecycle isn't doing the work, it's the final handoff. You send over the final ZIP file or Figma link, attach your invoice, and then just wait and hope the client actually pays instead of running off with your files.
To fix this, I built TimeDrop to act as a mechanical intermediary. It basically removes the "trust" variable from the final delivery.
Here is the workflow:
You secure your final project link behind a "delivery gate" in the app.
The app emails the invoice to the client on your behalf.
The client receives the invoice and sees that the files are ready, but the link is strictly locked.
The second you mark the invoice as paid on your dashboard, the system automatically unlocks and delivers the final files to the client.
It acts as the bad cop so you never have to send another awkward "just following up on the payment" email.
The site is https://timedrop.work
I would love to hear your thoughts on the mechanics of this workflow, or if you see any glaring edge cases I'm missing..

value: Show HN: A delivery gate that automatically releases files when invoice is paid

author: pixelatedRudy