value:
A couple years ago I shared my Jeopardy-style game maker on HN, Buzzinga. A bunch of folks ended up using it for team events, classrooms, and game nights, which was fun to see.
I kept running into the same problem with "Wheel of Fortune"-style games though. The options are basically:
- Console games (Wii, Switch, etc.)
- PowerPoint templates
- Or cobbling up some DIY solution
I don't have a console and the other options were clunky. I wanted something that:
- Runs entirely in the browser
- Doesn't require players to use their phones
- Handles the game flow so the host isn't juggling rules, manually updating scores, remembering who's next, etc.
So I built Spinorama: https://spinorama.io
A few things that might be interesting here:
- The host drives everything from a single screen, players just call things out (no phones required)
- Game flow is stateful and enforced, so you can't accidentally break the rules mid-round
- Uses the Web Speech API for turn prompts (spin, buy a vowel, solve, etc.) and to check spoken solutions
- Full keyboard control via hotkeys for running the entire game
- No signup required to try it, accounts are only needed if you want to create and save custom games
Still early, but it's fully playable and I've been using it for small groups.
Curious what this crowd thinks, especially around:
- Anything that feels clunky or breaks immersion
- Missing features you'd expect when hosting a real game

value: Show HN: A Wheel of Fortune game you can run in the browser


value: daveoshawrus

value:
Thank you to everyone who offered feedback on my Hacker Show post for Forkle last week. I had some fantastic input from a few of you, which I have now integrated into the game.
Major & Minor Improvements:
- Much easier. I was getting a lot of feedback that the puzzle was too difficult, from here, reddit and others. This was for a number of reasons, but I have made best efforts to simplify the puzzles.
- Improved checking : One user advised that common crossword proactive is to have more "checking" where letters intersect. This has been increased, within the possibility of a shared grid.
- Increased number of shared letters - I have attempted to add more shared letters to puzzles which makes them easier, more fun, and more in the spirit of the game.
- Ensured that copy and paste is accessible via keyboard shortcut on main game screen.
- Ensured that rules for vocabulary and grammar logic for clues are more tightly regulated. One comment mentioned plurality of a clue but not an answer. This is poor crossword form, and now improved.
- Addressed enhanced tracking bug in Firefox (still could be an issue)
Thank you to everyone, I want to make the game fun to play. Feel free to check out the new puzzles today and this week, which are improved. I may have to reduce the difficulty once again, but will see!
Original Post :
Forkle (forkle.co.uk) is a daily word game where two thematically linked crosswords occupy the same grid simultaneously. Every tile contains two letters - one belonging to each puzzle - displayed as a diagonal colour split. Where the two puzzles intersect, some tiles share the same letter, giving you a foothold into both crosswords at once.
The mechanic has two layers: the shared grid, and the connected themes. Each day's two crosswords are thematically paired around a central idea. For example, a previous puzzle was "Same House, Different Kingdoms" - same home, same humans, entirely different worlds. One crossword is the dog's world, the other is the cat's. The themes are chosen to be related but distinct, which creates an extra layer of satisfaction when the connection clicks.
The constraint of forcing two crosswords into one physical space turns out to create genuinely interesting solving decisions - sometimes the two puzzles help each other, sometimes they fight.
Built solo over a few months using React, Python, Supabase, Fly.io and Resend. Three months of daily puzzles pre-loaded. Launched two weeks ago.
Would love feedback from anyone willing to try it.

value: Show HN: Updated – A dual crossword puzzle where two crosswords share one grid

author: daveoshawrus


value: todience

value:
I've always had the urge to have my two macbooks communicate. Having one idle while working on the other felt like underutilization of resources. So I built Loopsy. Initially the goal was to do file transfer via local network, and then came running commands. I then tried running coding agents from one machine to the other, and it worked.
Later I figured there should be a better way to continue my claude sessions remotely on my phone from the gym. So I did a cloudflare worker that connects to my local machine. I just need to ensure the laptop is plugged in.
I know I might be reinventing the wheel, but I love that it just works. Still working on E2E encryption. iOS app still in review.
Lemme know your thoughts.

value: Show HN: Loopsy, a way for terminals and AI agents on different machines to talk

author: todience


value:
Bitcoin Monitor Widget V2 is live.
Build your own real-time crypto space with price widgets, portfolio views, themes, logs, terminal, games, custom API cards, alerts, and cloud sync.
Overall what is supported:
Real-time crypto price widgets
Portfolio tracking
Customizable themes and layouts
Log monitoring widgets
Terminal/network tools
Game widgets
Custom API widgets
Alarm alerts
Cloud save/load and multi-slot layouts
New sandbox mode for trying things safely
I'm giving V1 to open-source as well: https://github.com/cryptofuture/btc-monitor-widget

value: Show HN: Bitcoin Monitor Widget

title: Show HN: Bitcoin Monitor Widget


value: eummm

value: Show HN: Revdoku – visual document review with AI (open-source)

author: eummm


value:
I tried to make this because I need the port to CheerpJ with a custom WebSocket wrapper that the private server is also modified to accept. The desktop client works flawlessly even on my Mac Mini M4 because LWJGL 3 ships an JNI implementation for mac-arm64. I have all the Windows, Linux and Mac platform to have their JNI bindings shipped together in the shadow jar, so as long as you have a private server running void (https://github.com/GregHib/void) then you are good to go.
What I (or LLM) vibed out is that I told it to observe how the APIs are called, and used Ghidra MCP server that I configured to load and decompile the C native libraries and do a deep research, analyzing how the native libraries worked, and then rewrite the code without using JNI but to for example, use LWJGL's OpenGL binding for the Jagex's implementation for OpenGL, and also some other native libraries like the "C library" which is basically some hardware information. Then Ghidra will puke out the decompiled pseudo C code, and let LLM to make sense of it.
The only native code left is the software rendering mode but it is obviously out of the scope as of now because we all know how worse it could be to implement software rendering in Java even with JIT. AOT might be another story, but software rendering in general is not a good idea anymore today. The code is intentionally snubbed out from being loaded in the class loader so it is a RuntimeClassError. To be fair if you want "software rendering", going through llvmpipe or Zink would fare much better.
As a result, the game client now can run over technically any platform given that LWJGL supports it, not having to care about it being 32-bit or 64-bit, without much limitations on the JVM platform besides from some deprecated APIs that I can just slop it out asking LLM to replace them with modern alternatives but I just don't really want to bother yet.
This is a direct consequences to my findings in https://github.com/stevefan1999-personal/demcstify to decompile and reconstruct Minecraft to source code, but this time I already have a partially working and launchable game only that the state of the source code was obfuscated. This is a direct thesis to the closing part of my demcstify project: you can't hide your code by layering down obfuscations and virtualizations as LLMs are kind of great at dealing with those semantic games.
Instead, now softwares can be cheaply manufactured and cloned to some port, I think it is serious time to think about how the future of software development and open source entangle with each other -- LLM can basically read the binary (binaries if it has multiple platform supports), spew out enough reasonings to know what the code and algo are doing, and even make a reasonable clean-room reimplementation of your software (I have one pending with Picovoice's Porcupine, but I just want it to run on ESP32, I have yet to release it until it really runs)

value: Show HN: Porting partially deobfuscated Old School Runescape to use LWJGL 3


value: inguz

value:
World of Objects.
It's basically LambdaMOO, but over Cloudflare Durable Objects and MCP.
---
Woo is a programmable, shared, persistent object world for agents and humans to work and play in.
Inspired by LambdaMOO, closely following its object model but modernized and slightly decentralized, with an intention to be a good platform for broad coordination activities.  Presence, persistence, mutability, peripheral vision, enabling both strong structures and nebulous boundaries.
Objects, properties and verbs, permissions, a self-contained VM runtime. Interact with Websockets, MCP tools, and REST APIs.  MCP tools are just whatever affordances of the place you're in.  Templates are shareable "catalogs", Git-hosted collections of objects that make up an application.
Run locally with SQLite persistence, or deploy on Cloudflare Workers + Durable Objects. Objects that support sequenced events get their own DO.
Current Status:
Very early implementation.  Sharp edges and wishful thinking.  It works.
Code: https://github.com/hughpyle/woo
Online demo: https://woo.hughpyle.workers.dev/
Current example apps installed from the local build include: a small chat-room world with many of the LambdaMOO behaviors (and a cockatoo); "Dubspace", a realtime interactive audio playground; "Pinboard", a shared noticeboard; "Taskspace", a task-management workspace (e.g. for AI agents); and a very minimal IDE/inspector.
Not yet built: user onboarding flows, full programmer experience.  Once an agent can build stuff within the world over MCP that will be a whole other level of fun.
Have fun with it!

value: Show HN: "Woo", a multi-user world for agents

author: inguz


value: infamous-oven

value:
Hi HN, I built BetterClaw after watching the PocketOS incident on April 25: a Cursor agent running Claude deleted a company's entire production database in 9 seconds, then zapped the backups. The agent had access to a Railway MCP server with destructive tools, and "be careful" in the system prompt didn't bind anything.
BetterClaw takes a different angle: you describe the workflow you want in plain English ("Diagnose the credential mismatch - read the config, test the connection, report findings — do not modify or delete anything"), and the CLI compiles that paragraph into a directed graph of nodes, where each node declares which tools are allowed at that step. A plugin hooks into your agent's tool-call path and blocks anything outside the graph before it dispatches to the MCP server.
So in the PocketOS reproducer (included in the repo with a mock Railway server, so you can run it without an account): the agent tries railway_delete_volume mid-conversation, the hook returns a deviation error, the volume is never touched.
What I'd love feedback on:

   - Is "paragraph -> graph" the right authoring model, or should this be YAML / a DSL?
   - Where does this fall down for you? (Multi-step approvals? Loops? Sub-agents?)
   - What other agent runtimes should we support beyond Claude Code + Cowork + OpenClaw?

Repo: https://github.com/jfan22/BetterClaw
Demo (90s): https://youtu.be/ZreUtANHET0?si=VpdjA6lf0Wa1mhoi
Install: npm install -g @betterclaw-ai/cli
Apache 2.0.

value: Show HN: BetterClaw – Compile a paragraph into a workflow that gates agent tools

author: infamous-oven


value: jilles

value:
Hi HN,
I've been playing around with Cloudflare's Browser Run and Workers AI to create this funny "website vs website"-website.
Google's Gemma 4b model is actually quite good at vision.

value: Show HN: Site Mogging

author: jilles

title: Show HN: Site Mogging


value: steviee

value:
Hey, I built git-issues to replace GitHub Issues, because
- my very own (probably flawed) workflow sometimes changes planned features along the way which tends to get source code and feature descriptions out of sync
- I wanted Claude Code (or Codex) to be faster when accessing the planned tasks
- have everything checked out that's needed for work to be able to work offline (sometimes happens on a boat etc.)
So, in short:
Issues stored as YAML-frontmatter Markdown files in .issues/, version-controlled alongside your code. Zero infrastructure: one Go binary, no server, no database, no accounts.
Built for two workflows:
  - Human: issues list, issues show, issues board (interactive TUI)
  - Agent: issues next → issues claim <id> → issues done <id>. Auto-generates .agent.md context for Claude Code and other agents.
Relations (blocks, depends-on, related-to, duplicates) are bidirectionally synced. Every change auto-git add-ed. Issues travel with branches, git bisect shows state at any commit.
go install github.com/steviee/git-issues@latest
What do you think?

value: Show HN: Git-issues – Issue tracker that lives in your repo as Markdown

author: steviee


value: richiejp

value: Show HN: LocalVQE: Tiny ~1M param audio model that cancels echo and noise

author: richiejp


value: pruetj

value: Show HN: MappyMail – The cheapest way to send letters online

author: pruetj


value: Given that PowerPoint's format doesn't play well with LLMs, I built a tool that generates presentations as real HTML instead. Think Lovable but for slides. Would love to hear what you think :)

value: Show HN: Stanzio, AI presentation tool that designs each slide as real HTML


value: EMPTYCONTOUR

value: Show HN: Glyph – byte-exact substring retrieval (~1.5ms, FM-index)

author: EMPTYCONTOUR


value: Show HN: Secure-by-default Ollama Docker image with built-in auth, only 70MB


value: beledev

value: Show HN: I have created newsletter interactive tools in one place

author: beledev


value:
The Ideaflow license is an experiment for which I'd love the thoughts/opinions of the HN crowd. I’m an engineer, and I really value the thoughts and opinions of other people that build things. These folks often participate in the open-source software ecosystem. We make use of software that other folks have written and contribute our own software to be used by other people. Most open-sourced software contains a license that describes how the author permits others to use their work. Ideaflow is such a license.
The Ideaflow license is based on the Beerware license, which states that "As long as you retain this notice you can do whatever you want with this stuff. If we meet some day, and you think this stuff is worth it, you can buy me a beer in return.”
Like Beerware, Ideaflow permits others to do whatever they want with the code, but it offers a different mechanism by which the user can thank the author. The license will include a link to material for review, and the person using the code is requested to look through that material and offer their thoughts/feedback/criticisms. That feedback will come via a form that’s also linked in the license.
I hope that this might help generate something like a peer-review ecosystem within the open-source community that doesn’t just operate on software that’s already written, but also operates on ideas, non-software-related work, etc. In addition to helping one another write code, it would be neat if we helped each other develop ideas.

value: Show HN: Ideaflow Software License

title: Show HN: Ideaflow Software License


value: MADEinPARIS

value: Show HN: Csrct – The Bottleneck Is the Strategy

author: MADEinPARIS


value: Show HN: Raft to allow a group of AI agents to reach consensus


value: ekvanox

value:
I built GitLeak (https://gitleak.io) - a free OSINT tool for GitHub. It scans through user profiles to find leaked email addresses, commit timezones, git usernames, and commit time patterns.
The motivation: I consider myself reasonably security-conscious and have my email set to "private" on GitHub's web UI. However, while playing around with GitHub's API, I realized my personal email was still completely exposed. I built GitLeak to see how widespread this is.
How it works: The leak usually happens because of a disconnect between local Git settings and GitHub's web settings. While a user might hide their email on their GitHub profile, their local git config user.email is often set to a personal address. When they push a commit, that email is permanently baked into the commit metadata. GitLeak scrapes the .patch files appended to these commits, parsing out the rich metadata that allows for email extraction from otherwise "anonymous" accounts. It also maps out daily commit activity to infer the user's sleep patterns.
The tool is completely free to use. I recommend searching for your own GitHub username to see if your email address is private.
I'd love to hear your feedback, or let me know if you find anything surprising!

value: Show HN: GitLeak – A GitHub OSINT tool for emails, timezones, and activity

author: ekvanox


value: keepamovin

value:
I built this because I was always creating machines on GH actions to test builds on different OS, and I wanted a tight CLI that could do it. I always saw Actions as this great resources and ephemeral machines you could do dev work in just were a natural way for me to work, so this grew out of that workflow.
I didn't expect it to blow up, so it wasn't 100% finished when I posted it. But it should stabilize pretty quickly.
Happy to know what you think and talk about it.

value: Show HN: GhostBox – Borrow a disposable little machine from the Global Free Tier

author: keepamovin


value: zoomacode

value:
Hi folks,
Some time ago I tried to find a way to clean up my 10k emails inbox and could find anything which worked for me. So I built built my own tool which evolved into a client.
More that out of necessity but for fun add semantic search, LLM based tagging, and clean up rules through  Ollama.
It has a demo mode to try without configuring anything.
On Mac:
brew tap herald-email/herald
brew install herald
herald --demo
With Go:
go install github.com/herald-email/herald-mail-app/cmd/herald@latest
herald --demo
The DEMO uses pre-populated synthetic data so no risk for your inboxes.
Any feedback will be highly appreciated.

value: Show HN: Herald – Local-first terminal email client

author: zoomacode


value: debarshri

value:
I have embarked on a journey of rewriting Kubernetes into a single binary in Rust, with everything embedded.
Architecturally, instead of etcd, it has options to use SQLite or PostgreSQL as a backend. I am trying to make it compatible with Kubernetes APIs, and kubectl should just work out of the box.
This is not 100% ready yet, but I just wanted to show the first look. It is almost 90% AI-generated. Claude code with Opus 4.7 is being used here.
It should just work out of the box on macOS with Docker as runtime.

value: Show HN: Superkube - Rewriting Kubernetes in Rust

author: debarshri


value: Mdtan

value:
A paternity leave passion project designed to measure your "social fitness" the same way Whoop and Oura measure physical wellness.
The app tracks who you spend time with and gives you a Connection Score (both overall and per person).
A core question I'd value input on:
- Does the same measure-then-improve premise for health, productivity, etc. work for relationships or break down because it's too challenging to score meaningfully?
App store: https://apps.apple.com/us/app/timewith/id6760588260
Landing page: https://timewith.app

value: Show HN: TimeWith – iOS app to track relationships with the people who matter

author: Mdtan


value: sdan

value: Show HN: I rebuilt my Twitter For You feed

author: sdan


value: colinarms

value:
I often copy and paste the same prompts into Claude, Codex & Gemini separately. It's helpful seeing where they all agreed and where they diverged. The signal of the agreement or divergence was often more helpful than any individual response.
So, I built a tiny open source CLI that does this automatically.
Council detects any `claude`, `codex` or `gemini` on your path and runs them in parallel. Once all finish, a lead summarizer produces one synthesized answer, flagging any disagreements.
Open source & MIT licensed: https://github.com/seeARMS/council

value: Show HN: Council – Run Claude, Codex and Gemini against the same prompt

author: colinarms


value: pacharanero

value: SNOMED-CT is the predominant medical terminology - essentially a namespace with an ontology bolted onto it. Existing SNOMED-CT tooling tends to focus on Terminology Servers, which are a pain to set up and learn. This toolkit is right on your computer, simple to use, and 6-60x faster than  IHTSDO Snowstorm in tests.

value: Show HN: `sct` – a SNOMED-CT medical terminology toolkit in Rust

author: pacharanero


value: TemporaryMail

value:
After some struggle to find a simple, affordable and reliable network tools I've made a site called <https://ipaddress.to> and my goal is to make it easier for fellow devs and I'll explain the some of the features that I like the most below:
- Extension
One perhaps strange habit that I've had for a long time is that I like to know where sites are hosted and the country that it's hosted in. I used to have to do "tracert" in cmd and then use an online service to lookup the IP address, but with the extension I can check that directly in the browser extension.
Chromium: https://chromewebstore.google.com/detail/ipaddressto-lookup/...
Firefox: https://addons.mozilla.org/en-US/firefox/addon/ipaddress-to-...
- WhoIs Lookups: https://ipaddress.to/whois/
This always used to be a hassle as you had to fill out an annoying captcha on a really slow page. The only downside that I have right now is adding support for the different TLDs as some don't have RDAP yet so I'm working to get this fixed.
- DNS Lookups: https://ipaddress.to/dns/
I used another site before, but they had such tremendously long caches that it made life difficult. Another strange habit that I have is to do regular checks while the DNS of a site is propagating and most services had a long cache that wouldn't let me do this as they would just present the same results from 15 minutes ago. I've gotten rid of this with a 1 minute cache and I've also done my best to improve the UI where you get to the see the full map.
- IP Address Score: https://ipaddress.to/score/
I run the website https://temporarymail.com (as you can perhaps tell from my username) and it's been a little battle to filter out the bots so I wanted to create a service that would give a quick score from 0-100. There are a lot of services like this out there, but they are tremendously expensive so this has been my attempt to make a cheap/free one.
I'm working on adding a lot more lists to make it more accurate, but this is a work in progress. This will also be somewhat expensive so my goal is to add a cheap paid service for a few dollars/month that will cover the server rent and the cost for the list.
Feel free to check it out and please give me some feedback on what I can improve as I want to make this a stable service that both I and other devs can use. :)

value: Show HN: IP Tools (Ipaddress.to)

author: TemporaryMail

title: Show HN: IP Tools (Ipaddress.to)


value: johnjoubert

value:
Every AI agent should be able to handle email, but all the existing options sucked.
So I built Robotomail. One API call. Real mailbox. Full send and receive.
Let me know what you think?

value: Show HN: Email for AI Agents

author: johnjoubert

title: Show HN: Email for AI Agents


value: mqmalagris

value: Show HN: CalculeOnline – 150 Brazilian financial/math calculators, in-browser

author: mqmalagris


value: Jpoliachik

value:
Hi HN, I'm JP
I wanted to automate my voice notes - pocket the phone (or watch), walk and talk, then send the transcript to my agent for processing.
So I built Ramble for myself.
It's a simple app. An on-ramp into your systems.
Free. Open source. No accounts.
Why a new app?
1) Apple Voice Memos are great, but no way to automate the result. You're also stuck with Apple's transcription (it got slightly better in iOS26 but still not the best)
2) Voice transcription in Claude / ChatGPT / messaging apps is built for short back-and-forth chat, not capturing a 10-minute walking ramble. They also don't let you record offline on Apple Watch.
3) I wanted a minimal distraction-free app to record thoughts and trust they'll be delivered. Nothing more.
I've been using Ramble on my phone & watch for months. Talk-to-think became a regular habit and I started getting real value from it. I highly recommend long-form talking to voice notes as a way to process your thoughts, regardless!
Some technical notes:
Native iPhone + Apple Watch, SwiftUI, no third-party deps. App is < 2MB.
Recordings and transcripts stored locally on device. Watch recordings work offline and sync to the phone when in range.
Default transcription is Apple's on-device SFSpeechRecognizer (free, offline). Cloud models (Groq, Deepgram, OpenAI, etc) are optional and route through a stateless Cloudflare Worker that forwards audio and returns text. Nothing persisted server-side. It's all in the repo if you want to verify.
The proxy uses Apple App Attest instead of accounts: each request carries a DCAppAttestService assertion proving it came from a real copy of Ramble on a real device. That's how the cloud tier is gated without ever asking for an email.
Webhooks are sent from device - the transcript POSTs to a URL, signed HMAC-SHA256 with a per-user secret so the receiver can verify it. Pipe it into n8n, an agent, whatever.
Landing page: https://goodloop.dev/ramble/
Repo: https://github.com/Jpoliachik/ramble-ios
App Store: https://apps.apple.com/us/app/ramble-voice-notes/id676185775...
Feedback welcome

value: Show HN: Ramble, iOS voice notes that send webhooks

author: Jpoliachik


value: Show HN: Access OPFS from multiple tabs using a fake Shared Worker


value: Hi HN! I'm the founder of ProjectHQ — the idea came to me while building another product and realizing I was wasting a ton of time (and money) managing separate tools for analytics, support, SEO etc. I really like the idea of natively interconnected data and what it unlocks - for example, you can run a site audit and ProjectHQ will automatically use that data to build a knowledge base for your AI Chatbot to answer support questions from customers. I’m constantly finding new applications for this as I develop it. Would love to hear your feedback!

value: Show HN: ProjectHQ – Command Center for Your SaaS


value: gsibble

value: Show HN: Duo – AI Matchmaking over iMessage

author: gsibble


value: Show HN: Reckoner – A query workbench for domain experts


value: We seek the safety of a frictionless reality. But truth never lives in the math alone. It lives in the friction. From the subterranean heat of a New York jazz club to the discarded streets of Kathmandu, Dispatch 003 explores the physical resistance required to keep the absolute zero at bay.

value: Show HN: The Off Note

title: Show HN: The Off Note


value: middleastbeast

value:
Hello  My name is Henry. I built this app for people who want to know for sure that things that they are trying are actually working.
I am looking for enthusiastic people who want to see longevity and bio-hacker community grow.
At the moment the app is completely free to use. There is no sign up or anything like that. I need your feedback to build something beautiful.

value: Show HN: N=1 – iOS app for structured longevity self-protocols

author: middleastbeast


value: flamestro

value: Sanishne is a lightweight tool for teams to save, tag, and find shared links without losing them in Slack/Discord. It uses simple shared boards with viewer/editor/owner roles, and focuses only on bookmarks (no docs, no bloat). Free and currently an early MVP.<p>Would love to get some feedback.

value: Show HN: Sanishne – shared bookmarks for teams (so links don't vanish in Slack)

author: flamestro


value: calebhwin

value: Show HN: My Private GitHub on Postgres

author: calebhwin

title: Show HN: My Private GitHub on Postgres


value: zachdive

value:
Hi HN, I'm Zach, one of the co-founders of Adam (https://adam.new).
We've been on HN twice before with text-to-CAD/3D experiments [1][2]. The honest takeaway from those threads: prompt-to-3D model web apps are fun, but serious mechanical engineers don't want a black box that spits out an STL. They want help inside the CAD tool they already use, with full visibility and control over the feature tree.
So we built that. Adam is now a harness that integrates directly with your CAD. It reads your parts, understands the existing feature tree, and edits it for you agentically. We are now live in beta on Onshape and Fusion! [3]:
Install link Autodesk Fusion: https://fusion.adam.new/install
Install link PTC Onshape:
https://cad.onshape.com/appstore/apps/Design%20&%20Documenta...
Things people are using it for today: - "Merge redundant features and clean up my tree" - "Rename every feature so the tree is actually readable" - "Round all internal edges with a 2mm fillet" - “Parametrize my model” - Along with of course, using Adam to generate CAD end-to-end!
A few things we care about that aren't obvious from the listing:
1. From the start we have always believed in CAD as code as the right abstraction. Our harness leverages Onshape's FeatureScript and Python in Fusion heavily.
2. We run an internal CAD benchmark across frontier models. There has been a massive jump in the spatial reasoning capabilities of recent models, particularly GPT 5.5 and Opus 4.7 [4] [5]
3. We open-sourced our earlier text-to-CAD work [6]
A note on the Anthropic Autodesk connector that shipped a couple days ago [7]: We think it's great for the space and validates the direction.
Where Adam is different: - Model-agnostic. We pick whichever frontier model is winning on each task type from our own internal bench, instead of being tied to one lab. - We live natively in your CAD apps and are actively building integrations across all programs
What would you want an in-CAD agent to do that nothing does today?
[1] https://news.ycombinator.com/item?id=44182206
[2] https://news.ycombinator.com/item?id=45140921
[3] https://x.com/adamdotnew/status/2050264512230719980?s=20
[4] https://x.com/adamdotnew/status/2044859329329893376?s=20
[5] https://x.com/adamdotnew/status/2047795078912172122?s=20
[6] https://github.com/Adam-CAD/CADAM
[7] https://x.com/claudeai/status/2049143440508616863?s=20

value: Show HN: AI CAD Harness

author: zachdive

title: Show HN: AI CAD Harness


value: Show HN: CyberChef Payment Cryptography Extensions


value: Show HN: BeautyShot – easy macOS promo screenshots


value: Show HN: Blotter, a live map of police radio activity


value:
We were both genuinely impressed by Claude Code after it helped each of us fix nasty CI problems overnight. Doing those fixes manually would have taken days.
After that experience, we each found ourselves struggling through Ctrl+Tab through multiple Claude Code windows in our terminals. While we enjoyed having agents working for us in parallel, context switching and cycling through each terminal tab was a real pain.
So we thought: Can we design a TUI dashboard that manages a large swarm of agents in one place? Even better, can agents manage agents hierarchically, like how companies work?
OMAR (Open Multi-Agent Runtime) is the result of this exploration. We spent months building it, and we think it is now ready to show the world. If you find OMAR interesting, give it a try. We would love to hear from you. :)
Check out our blog here for more details: https://omar.tech/blog/introducing-omar/
Thanks!
Karim & Shaokai

value: Show HN: Omar – A TUI for managing 100 coding agents


title: Show HN: BeautyShot – easy macOS promo screenshots


value: theahura

value:
Hey folks,
My team and I have been building a background agents as a service product. One of the things we needed pretty early on was for some way for the agents to be able to drive slack.
Right now, I don't think there are many good agent-first ways of doing this. I don't love MCP -- it's just too many tokens in the context window, and agents seem to do better with CLIs because they can embed them in code and so on. But other CLIs that exist are either a) subsets of the web api that only focus on human needs and b) have polished terminal UIs with spinners and colors and interactive things that make it hard for LLMs to actually use them.
nori-slack-cli is a very thin dynamic wrapper over @slack/web-api (i.e. bolt). Whatever the SDK can call, the CLI can call. When slack adds a new method it should just work without a new release on our end. (Inspired by the GWS cli: https://github.com/googleworkspace/cli).
So you(r agent) can do things like:
`nori-slack chat.postMessage --channel C123 --text "hi"`
`nori-slack admin.users.list`
`nori-slack bookmarks.add`
etc.
It's pretty easy to build a cli these days, so what makes this special? We spent a bunch of time thinking about what is necessary to make something 'agent first', which is I think the real value of this CLI: the design stuff.
- Every response is a one line JSON on stdout, no colors or interactivity.
- Every error includes a source field with the on-disk path to the CLI. When the agent is confused it can just go read the source (also useful for asking the agent to go add a feature on the fly)

  - (Re the above, we generally recommend downloading and running the cli from source on your machine!)

- you can describe any method to get required/optional params, pagination support, and the docs URL without having your agent do additional webfetches
- there's a list-methods function for discovery
- the 'paginate' flag auto-cursors and merges pages into a single response
- and my personal favorite: any unknown method will try and Levenshtein fuzzy match to surface other methods the agent may have meant
We purposely wanted the CLI to match the bolt API 1:1 because we felt it critical that the agent had the capability of doing anything it needed. Scopes are managed via the tokens the cli has access to.
Repo: https://github.com/tilework-tech/nori-slack-cli
Would love to hear feedback about what works for other people when designing cli products for agents

value: Show HN: An Agent First Slack CLI

author: theahura

title: Show HN: An Agent First Slack CLI


value:
Various patterns for safer C programming have been cargo-culting around the industry for decades. Because the language evolves intentionally slowly, these patterns rarely get folded into the language as first-class constructs and are passed down through the generations in a sort of oral tradition of programming.
lib0xc leverages GNUC extensions and C11 features to codify safer C practices and patterns into real APIs with real documentation and real testing. Reduce your casts to and from `void *` with the `context_t` tagged pointer type. Enable type-checked, deferred function invocation with `call_t`. Interrogate structure descriptors with `struct_field_t`. Stop ignoring `-Wint-conversion` and praying you won't regret it when you assign a signed integer to an unsigned integer and use `__cast_signed_unsigned`. These are just a few of lib0xc's standard-library-adjacent offerings.
lib0xc also provides a basic systems programming toolkit that includes logging, unit tests, a buffer object designed to deal with types, a unified Mach-O and ELF linker set, and more.
Everything in lib0xc works with clang's bounds-safety extensions if they are enabled. Both gcc and clang are supported. Porting to another environment is a relatively trivial effort.
It's not Rust, and it's not type safety, but it's not supposed to be. It's suppsoed to help you make your existing C codebase significantly safer than it was yesterday.
My employer holds the copyright and has permitted its release under the MIT license.

value: Show HN: Lib0xc, the C standard library you wish you had


value: GiorgosGennaris

value: Correctify is an AI designer converting content into complete, branded designs. Forget templates or vague prompts. Correctify works around your content generating designs based on your size, style and branding.

value: Show HN: Generate marketing material with your text and images in minutes

author: GiorgosGennaris


value: ArmanTsaturian

value: Show HN: Arc Browser + Agents IDE

author: ArmanTsaturian

title: Show HN: Arc Browser + Agents IDE


value: bhouston

value: Show HN: Pixel-Perfect MaterialX in Blender and Three.js

author: bhouston


value:
We have been building a platform that analyzes quantum-vulnerable cryptography across four layers:
Source code parses ASTs to find RSA, ECC, DH, and weak symmetric algorithms and generates fix suggestions pointing to NIST PQC replacements (ML-KEM, ML-DSA, SLH-DSA)
Binaries disassembles PE, ELF, and Mach-O files to detect crypto patterns without source access
Network endpoints probes TLS/SSH to identify deprecated cipher suites and whether the endpoint supports hybrid post-quantum key exchange
Certificates checks signature algorithms and key parameters against post-quantum readiness criteria
Binary, network, and certificate results roll into a unified quantum risk score (0 to 100) so you can prioritize remediation.
NIST finalized FIPS 203/204/205 in August 2024. CNSA 2.0 is setting transition timelines. The practical challenge for most organizations is just finding where RSA and ECC are buried across a large codebase, third-party binaries, and infrastructure.
Free trial at cerebion.com. Happy to discuss the detection approach or the scoring model.

value: Show HN: Cerebion Rivet, post-quantum cryptography vulnerability analyzer


value:
Destiny is the Claude Code's plugin that gives you a real fortune reading.
Type /destiny to see today's destiny!
It uses the actual classical East Asian astrology system. You enter your birthday once, then /destiny gives you today's reading anytime.
Two layers, kept honest:
1. The numbers (your eight-character birth chart, today's day pillar, the hexagram for the moment, five-element relationships) are computed by a Python script. Same person + same day = identical output. You can verify against any traditional calendar source.
2. The prose (today's stars, character sketch, life arc, advice) is written by Claude, applying centuries-old reading conventions to that fixed data. Not LLM-hallucinated horoscope.
If you have fun with it, a star would mean a lot.

value: Show HN: Destiny – Claude Code's fortune Teller skill


value: joshuashelvin

value:
Every smartphone built in the last twenty years assumes the same thing: the battery will be charged once a day. Before I get to the math, sit with this for a moment: what would actually change if a phone never needed to be plugged in?
That is what I am building. The power source is betavoltaic — electricity generated continuously from the decay of a radioactive isotope, with no moving parts, no combustion, no charging infrastructure.
The device I am describing is not a current smartphone with a different power source. It is a device designed from the ground up around a power budget that current betavoltaic technology can sustain. Day One capability is meaningfully more limited than a 2026 flagship phone. That gap closes as the power architecture advances.
The source physics:
Tritium (H-3) decays by beta emission to helium-3.
The emitted electron carries a maximum energy of 18.6 keV, with a mean energy of approximately 5.7 keV. The neutrino carries the rest and is unrecoverable. The beta spectrum is continuous — a statistical distribution of electron energies up to the endpoint — which is why mean energy, not maximum, is the relevant figure for power calculations.
Tritium activity for power calculation: 1 Curie of tritium is 3.7 × 10¹⁰ disintegrations per second. At 5.7 keV mean energy per disintegration, 1 Ci of tritium releases approximately 1.6 × 10⁻¹⁹ J/eV × 5,700 eV × 3.7 × 10¹⁰ dis/s = approximately 33.8 mW of total beta energy. This is the upper bound on recoverable power — conversion efficiency determines how much becomes electricity.
Tritium's specific activity is 9,650 Ci/g. One gram of tritium therefore releases approximately 33.8 mW/Ci × 9,650 Ci/g = 326 W/g of total beta energy. Commercial betavoltaic cells at 1–4% conversion efficiency yield approximately 3.3–13 W/g electrical output — but tritium gas is diffuse and the actual cell includes a substrate, so power density per unit volume of assembled cell is far lower than per gram of tritium. Practical assembled cell power densities in current commercial products run 1–10 mW/cm².
City Labs in Miami produces tritium-on-silicon betavoltaic cells commercially under NRC license. Their current cells produce in the range of 50–300 μW/cm² of active junction area under typical loading. A mid-range figure of 150 μW/cm² is defensible for planning purposes with current commercial cells.
A multi-layer stacked cell module with 35 cm² of active junction area per layer and four layers — a total stack volume roughly comparable to a conventional battery pack — yields approximately 35 cm² × 4 layers × 150 μW/cm² = 21 mW total output. Accounting for interconnect losses and cell-to-cell variation, net output at the module terminals: approximately 15–18 mW continuous.
The conservative number — fewer layers, lower-yield cells — lands around 5–8 mW. I am designing the Day One architecture around 5 mW continuous as the floor, with 15 mW as the target as cell technology matures.
The decay curve is governed by the half-life
P(t) = P₀ × (1/2)^(t/12.32)
At t = 5 years: P = P₀ × 0.755. At t = 8 years: P = P₀ × 0.629. At t = 12 years: P = P₀ × 0.499. The device at year 12 produces half its launch output. That output is predictable to high precision years in advance. No battery ages on a curve this clean.
The decay curve and upgrade cycle:
A device launched at 5 mW reaches the Day One capability floor at year 12. No consumer electronics device in history has been designed around a decade of predictable, transparent degradation rather than a two-year replacement cycle driven by software obsolescence. This one is.
What I'm looking for:
I'm the founder. I'm raising a pre-seed round to sign two co-founders: one with betavoltaic or nuclear battery hardware experience who can lead the prototype program. If you're that person, or you know them, I'd like to talk.
For the full essay and technical whitepaper, or to contact me directly, visit shelvin.com.

value: Show HN: Building a smartphone powered by nuclear decay: the power engineering

author: joshuashelvin


value: ahmedmeky

value: Show HN: Aide-memory – persistent memory for AI coding agents and teams

author: ahmedmeky


value: Show HN: Building self-evolving AI Agents without training


value: bloomca

value:
I have lots of audio CDs and last year I did some systems programming, so I figured it would be cool to rip audio CDs using my own software. I used LLMs to understand how it is done, and I've learned a great deal on how SCSI commands are formed and processed.
I also wrote a separate app to actually rip the CDs using this library and populate the metadata, but I think technically it is much less interesting.
I think the biggest takeaway is that if you have some intimidating project, give it a try! It might be very much doable.

value: Show HN: CD-DA Reader, Rust library to read audio CD data

author: bloomca


value: willswire

value: Show HN: Turn Docker Compose files into airgap-ready UDS Packages

author: willswire


value:
Today I learned that I can find the most interesting jobs for myself in the "Who's Hiring" thread with a single command:

    curl https://news.ycombinator.com/item?id=47975571 | \
      uvx html2text | \
      llm --model gpt-5-nano "These are Hacker News comments under a Who's Hiring thread. Find interesting jobs that matches my timezone (US/Canada) and is remote and preferably part-time. I'm interested in Python, infrastructure, and AI. I also work as a fractional head of engineering with early stage startups."

Requirements:

    - uv: https://docs.astral.sh/uv
    - llm: https://llm.datasette.io/en/stable/

value: Show HN: Single bash command to find the best matching HN jobs


value: orthodoz

value: Export your macOS apps, shell configs, system settings, hotkeys, and app preferences from a source Mac, then replay them on a fresh target Mac. One command, one script.

value: Show HN: Fast, privacy-first macOS configuration bootstrapper for (MDM) Macs

author: orthodoz


value: Show HN: Stealth Benchmark test if AI coding interview tools can be detected


value: veroz

value:
Hiya HN, so I got a 3D printer for Christmas last year which kicked off a mild obsession with printing all the things. I soon discovered Gridfinity and went about organizing all the drawers in my workshop.
Over the past few months, I've been building this open source tool to help me plan, catalog, and design complete drawer organization systems. One of the challenges as I got into this hobby is that I really suck at 3D modeling, but I know what good code looks like so it was easier for me to create a whole ass parametric 3D CAD library than it was to learn fusion.
I hopeful this helps others who have recently discovered Gridfinity and feel overwhelmed by where to start. Feedback is always welcome over at https://github.com/andymai/gridfinity-layout-tool

value: Show HN: A visual planner for the Gridfinity modular storage system

author: veroz


value: It's a toy project that I thought I needed when I walk. I am still evaluating and it's in WIP

value: Show HN: News on the Go

title: Show HN: News on the Go


value: shmayro

value: Show HN: TTS Studio: AI-Powered Text-to-Speech Tool

author: shmayro


value: tbueno

value:
Passages is a web app for saving articles from around the web and turning them into beautifully typeset ebooks you can read on your e-reader. It takes a different approach from other "read later apps" by focusing on content extraction and cleanup first, then rendering with typographic care, so your saved reads actually look and feel like they belong on an e-ink screen.
The workflow is simple: save articles through a browser extension (Chrome and Firefox) organize them into collections, and export those collections as a single ebook whenever you're ready to read offline. You get a curated, distraction-free reading experience.
I built passages to fight my lack of attention when trying to read long-form articles in a computer screen it has helped me to finally consume my backlog of articles collected over the years

value: Show HN: Passages – Read long-form articles on you E-Ink

author: tbueno


value: ostenjap

value:
I am based in Berlin, Germany and it is superfun to travel in Europe. I always have a guilty pressure of not connecting with other hackers or builders if I visit a specific place. I also realise planning trip around different events from platforms like Luma and Devpost is a very tedious process, I wish I have a worldwide map to see where people are building. Since I can't find one, I created Hackamaps.
I started out knowing very little on web development. It is mostly just HTML, CSS, JS. For the first interation I just use AI tool like Lovable and Windsurf. I manage to make a working prototy in a week and I my network in linkedin finds in useful. However, there is a lot of bugs and I cant fixed them. My friend Cyrus told me to code one from scratch and I took the challenge and fight my way through. Don't get me wrong Lovable is great for UI but lacks in the minor details. After a while I also realise there is a vendor lock feeling where lovable tries to trap you in their specific cloud ecosystem which made ownership and flexible development next to impossible.
Antigravity IDE: This is my new best friend. Compared to Claude Code, Antigravity feels literally like a Toyota; it gets you from A to B where Claude Code is a Mercedes Benz. Nevertheless I am super satisfied despite all the hate the got in Reddit. They struggle with bad editing at first and coding directly rather than plan at first but now they are way better.
Two months, invested I went all in and rebuild the app from scratch . My current stack is React Vite for Front End and Supabase Cloud is my whole backend. My friend Tyler came on board to overhaul the whole UI / UX for the second version and he did a phenomenal job for it.
The main engineering challenge then is the data pipeline . I am running a custom scrapper on Hetzner. You might ask, why not just do everything in Supabase and my reason is I am comfortable with Python and the have a lot of cool webscrapping library. I got the data from Devpost and Euro Hackathon. Keeping the data accurate and fromatted properly took me almost a week and it is harder than I expected.
My ultimate goal is to build a worldwide community of people who love to live in the moment and just build.
link : www.hackamaps.com
GitHub : https://github.com/ostenjap/hackamaps
I would love to hear your thoughts on the project. Specifically, for those of you who aggregate data, how do you handle deduplication when scraping multiple event sources? I am also highly open to any technical critiques on the stack or general feedback on the UI.

value: Show HN: Hackamaps – A global hackathon map I build after hitting Lovable Limits

author: ostenjap


value: TristanX

value: Hi, this is Tristan, CPO of XTrace.<p>We are launching a very cool feature that is inspired by Andrey Karpathy's LLM Wiki mindmap. Let everyone who doesn't have enough sessions and markdowns made with claude code be able to visualize their own memory mindmap!

value: Show HN: MemHub, Turn Your GPT/Claude/Gemini History into LLM-Wiki Mindmap

author: TristanX


value: onyks

value: This CLI tool easily routes all Linux traffic through Tor (using nftables). Easy to use and doesn't need configuration. Now it is also published on PyPI, even though pre-built packages are recommended. Documentation: https://onyks-os.github.io/ttp/

value: Show HN: Transparent Tor Proxy – Route all Linux system traffic through Tor

author: onyks


value: lahfir

value:
I've been building computer-use tools for a while, and I quietly launched this about a month ago (122 Stars on GH). I figured it was worth sharing here.
Over the last few months, a lot of computer-use agents have come out: Codex, Claude Code, CUA, and others. Most of them seem to work roughly like this:
  1. Take a screenshot
  2. Have the model predict pixel coordinates
  3. Click x,y
  4. Take another screenshot
  5. Repeat
That works, but it's slow, expensive in tokens, and fragile. If the UI shifts a few pixels, things break. And the model still doesn't know what any element actually is.
But the OS already exposes structured UI information:

  - macOS: Accessibility API
  - Windows: UI Automation
  - Linux: AT-SPI

Screen readers have used these APIs for years. On the web, Playwright beat screenshot scraping for the same reason: structured access is just a better abstraction than pixels.
So I built a desktop equivalent: agent-desktop.
It's a cross-platform CLI for structured desktop automation through the accessibility tree. One Rust binary, about 15 MB, no runtime dependencies. It exposes 53 commands with JSON output, so an LLM can inspect and operate native apps without screenshots or vision models. Inspired by agent-browser by Vercel Labs.
A typical loop looks like this:

  agent-desktop snapshot --app Slack -i --compact
  agent-desktop click @e12
  agent-desktop type @e5 "ship it"
  agent-desktop press cmd+return

So the loop becomes:

  1. Snapshot
  2. Decide
  3. Act
  4. Snapshot again

The main design problem was context size.
A naive approach would dump the full accessibility tree into the model, but real apps get huge. Slack can easily exceed 50,000 tokens for a full tree dump, which makes the approach impractical.
The approach I ended up using is progressive skeleton traversal:

  - First pass: return a shallow tree, typically depth 3, with deeper containers truncated and annotated with children_count
  - Named containers get references so the agent can request only that subtree
  - The agent drills down into the relevant region with --root @e3
  - References are scoped and invalidated only for that subtree
  - After acting, the agent can re-query just that region instead of re-snapshotting the whole app

In practice, this reduced token usage by about 78% to 96% versus full-tree dumps in Electron apps like Slack, VS Code, and Notion.
A few implementation details that may be interesting here:

  - Rust workspace with strict platform/core separation through a PlatformAdapter trait
  - Accessibility-first activation chain; mouse synthesis is the fallback, not the default
  - Deterministic element refs like @e1, @e2, with optimistic re-identification across UI shifts
  - Structured errors with machine-readable codes plus retry suggestions
  - C ABI via cdylib, so it can be loaded directly from Python, Swift, Go, Node, Ruby, or C without shelling out
  - Batch operations in a single call
  - Support for windows, menus, sheets, popovers, alerts, and notifications
  - Special handling for Chromium/Electron accessibility trees, which can get very deep and noisy

Why I think this matters: pixel-based desktop control feels like a leaky abstraction. The OS already knows the UI semantically. Accessibility APIs give you roles, names, actions, hierarchy, focus, selection, and state directly. That seems like a much better substrate for desktop agents than screenshot loops.
If you're building your own desktop agent, internal automation tool, or research prototype, this may be useful.
Install:

  npm install -g agent-desktop
  agent-desktop snapshot --app Finder -i

Repo: https://github.com/lahfir/agent-desktop
I'd especially love feedback from people who've built desktop automation before. What are the biggest pain points you've run into, and what would you want a tool like this to support?

value: Show HN: Agent-desktop – Native desktop automation CLI for AI agents

author: lahfir


value: I made a guide on how to have a more lock down version of Lobe Chat running locally: https://www.ppppp.dev/local-lock-down-lobo-chat-setup/

value: Show HN: Local Lock Down Lobe Chat Setup


value:
Parsing FHIR data and converting that to OMOP standard is a notoriously difficult problem. I think we've cracked it.
I've open sourced two GitHub repos:
1. Forge-Core. This is the secret sauce. Automatically parse ANY json structure inside your own data warehouse by mapping your schema and building dbt models on the fly. Easy to set up and use. https://github.com/foxtrotcommunications/foxtrotcommunicatio...
2. Avalon-Public. Following the forge parse, use these dbt models to correctly and efficiently build your needed omop models. https://github.com/foxtrotcommunications/foxtrotcommunicatio...

value: Show HN: Open-Source FHIR –> OMOP Pipeline


value: mlhpdx

value: Show HN: Raptor – fast, energy efficient small file uploads to S3

author: mlhpdx


value: ramoz

value: Show HN: Embed your Codex pets in React apps

author: ramoz


value: trangram

value: Show HN: Stop playing my matchstick puzzles, start building your own in seconds

author: trangram


value: omiliyomami

value: I just wanted to have an AI do research for me so I don't waste time on it. You can leverage your time by letting the AI search and evaluate your favorite stocks price every morning, searching for startup ideas every hour and so on while you focus on something else. I also made the AI customizable with persistent memory so you can give it a 'Jarvis' feel or whatever you desire. The limit is your imagination.  This is my first attempt in any kind of "app". Every advice is appreciated, good or bad please be brutally honest with me.

value: Show HN: I made an AI task scheduling app

author: omiliyomami


value: Nullence

value:
With copy.fail going around turning off extra surface area like the whole AF_ALG kernel module could be useful, this tool generates a list of pids and their fds that have a running AF_ALG socket.
Faster than using lsof | grep ALG, compiled for all the linux archs and result is an easily parsable format.
Hopefully this is helpful to folks!

value: Show HN: Detecting running processes using AF_ALG

author: Nullence


value: eskibars

value:
Hi HN,
I've spent a lot of my career working in open source and I want to give back.  Recently, I launched https://zeroquarry.com, which is a tool that helps you find 0-days in your software by through AI by tracing incoming requests down to the lowest level of implementation.  The tool will do things like automatically suggest patches if you want or be more hands-off if you prefer.  It will automatically produce POCs of the vulnerabilities for you to test.
I'm giving the tool away for free to any open source project.  If you ping me directly (shane at the domain) with some details on what you're scanning, I'll increase credits or provide additional help.

value: Show HN: Free security scanning for OSS projects

author: eskibars


value: Show HN: Agent with its own computer on the cloud


value: ArqueNova

value: Show HN: Glacier – A zero-config macOS terminal I vibecoded in Rust

author: ArqueNova


value: mnewme

value: Show HN: Create the right image sizes for social media

author: mnewme


value: Show HN: Hollow is an open-sourced self-modifying agentic system


value: alEscarcha

value: Show HN: Formattery – on-device file converter for iPhone, iPad, and Mac

author: alEscarcha


value:
In an attempt to reduce cold starts in AI sessions Ive made a tool that runs as an MCP server and loads the context before Turn 0.
Two things happen:
Personal Priors - your workflows and standards loads once per session and persists across every supported AI client.
Expert Priors - when prompt is stack specific, relevar priors inject based on semantic similarity. This is to reduce errors and unwanted behaviour of the AI.
Privacy guarantee: local-first by design. Raw prompts are never stored. Injection is always client-side.
```bash pipx install turnzero turnzero setup # registers MCP server with Claude Code, Cursor, Claude Desktop, Gemini CLI
turnzero verify # confirms everything is wired correctly ```
Demo:https://asciinema.org/a/8IV2yoLNTloSlZo0
Repo: https://github.com/turnzero-ai/turnzero

value: Show HN: TurnZero – Persistent Expert for LLMs


value: flamestro

value:
I built Sanishne because useful links in teams kept disappearing into Slack/Discord/Notion noise.
It is a small, free shared bookmark board app. You create a board for a project, add links with short notes and tags, then invite people as owners, editors, or viewers. It also supports search, tag filtering, expiring invite links, MFA-backed accounts, and JSON import/export so your bookmarks are not trapped.
The name comes from Georgian: სანიშნე means bookmark.
The app is intentionally boring: no AI summarization, no feed, no browser extension requirement, no team knowledge graph. Just a place where a group can keep the links that are actually worth coming back to.
Technically, it is built in Rust with Axum and some internal libraries I built over time.
I would especially appreciate feedback!

value: Show HN: Sanishne – Rust based bookmark boards

author: flamestro


value: brettnbutter

value:
Hello HN, over the past 7 months I've spent nearly 3,000 hours on building SNEWPAPERS, the first historical newpaper archive with full-text extractions, nearly perfect OCR, a vast categorization taxonomy and of course with semantic and agentic search capabilities.
Problem:
I wanted to search through newspaper archives, but when I tried every service only lets you search for keywords and dates, and gives you back raw images of the papers, and too many of them with no context.  A sea of noise.
Solution:
I taught machines how to read the newspapers and so far I've extracted the content from > 600k pages (about 5TB) from the Chronicling America collection.  Problems I had to deal with were an infinite variety of layouts, font sizes, image scan qualities, resolutions, aspect ratios, navigating around the images on the page.  I also had to figure out how to get OCR to be nearly perfect so people wouldn't hate reading the extracts.  I stitched together a multi-model pipeline (layout tech, ocr tech, llm, vllm) with heuristics to go from layout -> segmentation -> classification.  I put it all in OpenSearch / Postgres and made it semantically searchable and also put an agentic search tool on top that knows how to use the API really well and helps you write queries to find what you're looking for.  Happy to discuss AWS architecture and scaling as well, that was tough!
If you have five minutes and you just want to jump in and have your own personalized experience, what I would suggest is:
Before searching for anything, go to the Sleuth page
Ask it about anything from 1736 to 1963, maybe 1 or 2 follow up questions
Then go to the search page so you can see the queries it wrote for you (bottom left "saved queries") and uncover more info on whatever it is you're interested in
If you think it's cool and you want to learn more, then there's about 10 minutes of video guides on the various capabilities in "Guide" on the nav bar
Some other people have also taken a crack at this, notably:
https://dell-research-harvard.github.io/resources/americanst... (very good attempt)
https://labs.loc.gov/work/experiments/newspaper-navigator/ (focused on images)

value: Show HN: Large Scale Article Extract of Newspapers 1730s-1960s

author: brettnbutter


value: ersinesen

value:
What appears as the fundamental building blocks of music-notes, scales, harmony—are not primitives.
They are emergent structures.
Pitch is just rhythm sped up.
A podcast generated by NoteookLM: https://www.youtube.com/watch?v=q9bFUocrm70

value: Show HN: From Beats to Notes and Beyond

author: ersinesen

title: Show HN: From Beats to Notes and Beyond


value: nip

value:
Hey HN!
I built SimplePDF Copilot: an AI assistant that can interact with the PDF editor. It fills fields, answers questions, focuses on a specific field, adds fields, deletes pages, and so on.
It's built on top of SimplePDF that I started 7 years ago, pioneering privacy-respecting client-side pdf editing, now used monthly by 200k+ people.
As for the privacy model: the PDF itself never leaves the browser. Parsing, rendering, and field detection all run client-side.
The text the model needs (and your messages) goes to whatever LLM you point at. By default that's our demo proxy (DeepSeek V4 Flash, rate-capped), but you can BYOK and point it at any cloud provider, or go fully local (I've been testing with LM Studio).
Unlike the existing "Chat with PDF" tools that only retrieve the text/OCR layer, Copilot can act on the PDF: filling fields, adding fields (detected client-side using CommonForms by Joe Barrow [1], jbarrow on HN with some post-processing heuristics I added on top), focusing on fields, deleting pages, and so on.
I built this because SimplePDF is mostly used by healthcare customers where document privacy is paramount, and I wanted an AI experience that didn't require shipping PII to a third party.
Stack is pretty standard:
- Tanstack Start
- AI SDK from Vercel
- Tailwind (I personally prefer CSS modules, I'm old-school but the goal since I open source it, I figured that Tailwind would be a better fit)
The more interesting part is the client-side tool calling: events are passed back and forth via iframe postMessage.
If you're not familiar with "tool calling" and "client-side tool calling", a quick primer:
Tool calling is what LLMs use to take actions. When Claude runs grep or ls, or hits an MCP server, those are tool calls.
Client-side tool calling means the intent to call a tool comes from the LLM, but the execution happens in the browser.
That matters for: speed, you can't go faster than client-to-client operations and also gives you the ability to limit the data you expose to the LLM. For the demo I do feed the content of the document to the LLM, but that connection could be severed as simply as removing the tool that exposes the content data.
The demo is fully open source, available on Github [2] and the demo is the same as the link of this post [3]
What's not open source is SimplePDF itself (loaded as the iframe).
I could talk on and on about this, let me know if you have any questions, anything goes!
[1] https://github.com/jbarrow/commonforms
[2] https://github.com/SimplePDF/simplepdf-embed/tree/main/copil...
[3] https://copilot.simplepdf.com/?share=a7d00ad073c75a75d493228...

value: Show HN: Filling PDF forms with AI using client-side tool calling

author: nip


value: Show HN: PythonStarter – now with Bitcoin Lightning payments


value: holg

value:
Hi HN — author here. iesna.eu is a browser-based ecosystem for working with photometric data: parsing standard luminaire files (LDT/EULUMDAT, IES LM-63, Oxytech, ATLA-S001), running design calculations against EN 13201 / ANSI/IES RP-8 / CJJ 45 / IES-IDA MLO, and (the part I most want to show off here) rendering real urban scenes in Bevy with the photometric data driving actual streetlight behavior, including sky-glow contribution.
The Skyglow Analysis demo loads a real LDT file into a Bevy scene (Khronos Bistro test asset).
The luminaire's intensity distribution drives the streetlight rendering directly — no fudging — and the sky-glow grade updates live as you adjust the uplight percentage. Swap to a full-cutoff fixture and the sky goes from F (Severe) back to A (Excellent). You can see the difference on the buildings as well as in the sky.
Stack: Rust core (eulumdat-rs and friends, ~20 crates handling photometric formats), Bevy for the 3D rendering, WASM for browser deployment. No backend; everything runs client-side. About a thousand lines of new code on top of the existing photometric library to make the Bevy integration work.
Things I'd love feedback on:
The atmospheric scattering model is currently single-scattering Rayleigh+Mie. Is that defensible for the use case, or should I move toward multi-scattering?
The Bistro test scene works well visually but isn't a controlled environment.
Anyone know of a public urban geometry asset that's more typical of real road-lighting evaluation?
The CJJ 45 implementation (China's national road lighting standard) is the only one I've had to reverse-engineer from translated PDFs.
If anyone has primary-source experience with it, I'd value a sanity check.
Open-source on GitHub (eulumdat-rs and the related crates).
Crates.io: eulumdat

value: Show HN: Browser-based light pollution simulator using real photometric data

author: holg


value: zzarcon

value: Show HN: Shutt – Turn Strava activities into shareable photo/video posts

author: zzarcon


value:
Hi,
My name is Zsolt. I build clinical tools for labs and longevity clinics, and I release some of them as free public tools.
The Male Hormone Lab Interpreter unique feature is that it visualizes the testosterone production and feedback pathway on HPG axis to identify the true root cause of hormonal imbalances. All hormones are interpreted based on optimal ranges. This is something LLMs still struggles with.
The only difference between public and clinical ones is that the clinical suggest diagnosis and treatment options. But if there is any type of disfunction its obvious from the diagram and differentiating is also straigh forward.
All the tools on the longevity-tools.com are 100% free and private. No email or any data collection, no third party scripts, no tracking scripts. Full privacy.
Check out my other tools:
## Thyroid Function Interpreter
https://longevity-tools.com/thyroid-function-interpreter
Visualizes hormones, calculated sensitivities, and secretory capacities on the HPT axis so thyroid dysfunction patterns are easier to recognize.
## Glucose Metabolism Interpreter
https://longevity-tools.com/glucose-metabolism-interpreter
Verifies fasting and insulin status, then classifies glucose-metabolism dysfunction using insulin-dependent and non-insulin-dependent markers.
## Liver Function Blood Test Interpreter
https://longevity-tools.com/liver-function-interpreter
Calculates liver health scores, runs differential diagnostic logic, helps identify the tissue of origin of elevated enzymes, and surfaces relevant next steps from clinical guidelines.
## Iron Status Interpreter
https://longevity-tools.com/iron-status-interpreter
Adjusts ferritin for inflammation, estimates real iron stores, interprets them against optimal targets, and provides guideline-based next steps plus a personalized supplementation plan.
## Grip Strength Interpreter
https://longevity-tools.com/grip-strength-interpreter
Shows grip-strength percentiles, estimates all-cause-mortality risk impact, proposes achievable targets, and projects future muscle-weakness risk.
## Humanity's Bortz Blood Age Calculator
https://longevity-tools.com/humanitys-bortz-blood-age
The most advanced biological age calculator model based on blood tests available in commercial labs. It was trained on 306k UK Biobank participants and has higher predictive value than Levine PhenoAge.
## Levine PhenoAge Biological Age Calculator
https://longevity-tools.com/levine-pheno-age
A biological age calculator based on routine blood biomarkers, developed by Morgan Levine, Steve Horvath, and collaborators. It prioritizes accessibility and low-cost lab markers over maximum precision.

value: Show HN: I built Male Hormone Lab Interpreter that does what LLMs can't


value: Show HN: Autorank – Rank on Google and AI search while you sleep


value: izivkov

value:
I've been maintaining GShockSmartSync (Android) for a while, and a recurring ask was "can I do this without installing an app?" So I built a browser-based version using the Web Bluetooth API.
What it does:
- Time sync with NTP (atomic-clock precision)
- Full alarm management (all 5 alarms)
- Reminders/events with labels
- Watch settings (illumination, sound, display)
- Battery level monitoring
- Zero install, zero accounts — all BLE traffic stays local between your browser and the watch
Tech: Next.js + TypeScript, Web Bluetooth API, Material Design 3. Supports 19+ G-Shock models with per-model capability detection.
Live demo: https://gshock.avmedia.org
Source: https://github.com/izivkov/gshock-smart-sync-webapp
Can be self-hosted on a Raspberry Pi or any Node-capable server.
Browser support: Chrome/Edge/Opera (desktop & Android). iOS needs Bluefy or WebBLE. Safari and Firefox don't support Web Bluetooth — that's a vendor decision, not a fixable limitation on my end.
One honest limitation: Web Bluetooth requires an explicit user gesture to initiate a connection, so there's no background auto-sync — you click "Pair Watch" each session. Fine for my use case, but worth knowing upfront.
The most interesting part was reverse-engineering the BLE protocol. Happy to go into detail on that if anyone's curious.

value: Show HN: Manage Casio G-Shock watches from the browser

author: izivkov


value:
Hi HN,
I’ve been working on mljar-supervised (open-source AutoML for tabular data) for a few years. Recently I built a desktop app around it called MLJAR Studio.
The idea is simple: you talk to your data in natural language, the AI generates Python code, executes it locally, and the whole conversation becomes a reproducible notebook (*.ipynb file). So instead of just chatting with data, you end up with something you can inspect, modify, and rerun.
What MLJAR Studio does:
- Sets up a local Python environment automatically, runs on Mac, Windows, and Linux
- Installs missing packages during the conversation
- Built-in AutoML for tabular data (classification, regression, multiclass)
- Works with standard Python libraries (pandas, matplotlib, etc.)
- Works with any data file: CSV, Excel, Stata, Parquet ...
- Connects to PostgreSQL, MySQL, SQL Server, Snowflake, Databricks, and Supabase.
For AI: use Ollama locally (zero data egress), bring your own OpenAI key, or use MLJAR AI add-on.
I built this because I wanted something between Jupyter Notebook (flexible but manual) and AI tools that generate code but don’t preserve the workflow. Most tools I tried either hide too much or don’t give reproducible results and are cloud based
Demos:
- 60-second demo: https://youtu.be/BjxpZYRiY4c
- Full 3-minute analysis: https://youtu.be/1DHMMxaNJxI
Pricing is $199 one-time, with a 7-day trial.
Curious if this is useful for others doing real data work, or if I’m solving my own problem here.
Happy to answer questions.

value: Show HN: Mljar Studio – local AI data analyst that saves analysis as notebooks


value: patillacode

value:
I searched for a simple, self-hosted journal app for my girlfriend and everything I found was either too
complex, too feature-heavy, too feature-less for what I needed or required trusting a cloud service.
So I built Piruetas (it means pirouettes in Spanish - she chose the name btw).
It's a day-per-page diary with rich text editing, drag-and-drop image uploads, auto-save, public
share links, and a clean mobile UI.
It can be set up for Personal or Multi-user usage via docker compose deployment.
She seems to like it so I decided to give back to the community and make it available for everyone (after some QA)
Live demo: https://piruet.app (login: demo / piruetas — data resets every 30 min!)
GitHub: https://github.com/patillacode/piruetas

value: Show HN: Piruetas – A self-hosted diary app I built for my girlfriend

author: patillacode


value: deppep

value:
Hello HN,
This is toposonico, a music recommender and navigable map. At core it's a skipgram word2vec model trained over ~6M playlists. Tracks are embedded in a 128d space. Embeddings for albums, artists and labels are computed marginalizing over tracks. The 2D map was built with UMAP.
Both the model and UMAP were trained in the cloud over a NVIDIA A100. All things considered it cost me around ~50EUR, over two main training sessions and a few experiments. For the slippy map I experimented with a few libraries. Ended up with Maplibre GL JS. Loved working with it, kudos to their developers. For the recommender indexes I used FAISS, another fantastic piece of software. Pretty happy with the thing running on a small and cheap box.
Two things influenced me in making this.
The first is decade-old idea: human navigation and exploration skills work in information spaces too. Many ML concepts fit this idea especially well. It would be nice to see more experiments in this direction.
The second goes more like a story. Before moving out and selling my turntable, I used to visit record fairs and I always ended up finding something novel there. To find a new record you didn't sit down and listen to ten records in a row, selected based on a supposed model of your personality. You wandered around, speaking with dealers and looking through the crates they brought with them. The crates often leaned on some genre more than another, reflecting the dealer's history and taste. There were huge stalls and there were small ones. Some were  crap. Finding oddities was very easy. I wanted to write something that felt like that.
Let me know what you think, if you find any bugs or if you have any idea for improving it.
Repo link: https://github.com/peppedilillo/toposonico

value: Show HN: A navigable map and recommender for 17M music entities

author: deppep


value: immanuwell

value: Show HN: Droast – A Dockerfile linter that roasts you for your bad practices

author: immanuwell


value: aliezsid

value: Show HN: Toggles – open-source feature flags for everyone

author: aliezsid


value: alansaber

value:
Hi HN,
Seamless co-op increases the multiplayer limit in elden ring from 4 to 20+. Whilst this is great, the game becomes too easy with so many players, and the world feels lifeless.
To fix this, we hand-placed more spawns for every enemy, and removed all limits on the AI's aggression. Now, not only are there 3x more enemies (including bosses!), we tweaked their behaviour to fight dirty (they’ll always gank, never holding back like they do in the base game) and are always aggressive to the player across large distances.
Elden ring is already grand in scale, but this pushes it up a notch, and gives it some much needed dynamism.
Here’s a video:
https://www.youtube.com/watch?v=7rp-rXYtI2M
Here’s the mods:
Seamless Coop - https://www.nexusmods.com/eldenring/mods/510
More Spawns - https://www.nexusmods.com/eldenring/mods/1790
Aggression Mod - https://www.nexusmods.com/eldenring/mods/2361

value: Show HN: 3x Enemies Aggro Mod – Elden Ring Multiplayer Scaled Up to the Max

author: alansaber


value: Also available on Firefox at https://addons.mozilla.org/en-US/firefox/addon/mooblock

value: Show HN: MooBlock – blocks distracting sites with adaptive friction (and cows)


value: Show HN: nfsdiag – A NFS diagnostic application


value: lachlanchen

value: Show HN: AgInTiFlow, a local web and CLI agent workspace using DeepSeek

author: lachlanchen


value: shabda

value: Show HN: A Local-only URL shortener

author: shabda

title: Show HN: A Local-only URL shortener


value: threejin

value: I made this website to host popular open source HTML5 games

value: Show HN: Threej games – open-source gaming portal

author: threejin


value: fforbeck

value:
Hey, you probably already saw that reviewing AI-generated code is a nightmare and quickly becomes a bottleneck. Everyone is using AI agents to write code fast, but the hard part is reviewing a bazillion lines.
I was thinking about building something that would guide me during development and during PR reviews. Something that would give me signals based on facts, risks, and evidence. Not just one LLM reviewing the code it generated. The initial idea was to add a deterministic review layer and combine that with LLM reasoning, and use that to find gaps in code and point me to the most important places, so I don't need to read line by line.
I ended up building a tool called vdiff, and it is working very well for me, and I'm constantly improving it. It is a CLI that analyzes your git diffs and gives you a structured report: what changed, what's risky, and what's missing. It uses tree-sitter for AST diffs and an LLM on top, so you get actual evidence for each finding, not just vibes.
Some of the output signals:
- Tells you if it's safe to merge, with a risk score
- Lists what's wrong, how confident it is, and shows the evidence
- Dependency graph for blast radius analysis
- Review memory (tracks resolved/reopened findings across sessions)
- You can point it at a spec or PRD, and it checks if the changes actually match
- Structural metrics (acyclicity, depth, equality, graph)
It runs locally; I didn't want the tool publishing the code to a third-party server, so your code never leaves your machine. BYOK (bring your own LLM key) - you interact directly with the provider.
If you want to give it a try:

  npm i -g @4bk/vdiff     # install globally
  pip install graphifyy   # required to generate the knowledge graph
  cd your-project         # go to a git repo
  vdiff init              # set up provider, API key, build knowledge graph
  vdiff -v                # analyze staged changes

Would love to hear if this is something helpful for you as well, and what kind of signals you'd want to see. I usually run it before each commit on a feature branch, and then on CI to verify the feature branch against main.
Any feedback is very welcome, and if it is crap, well, then just say it.
Cheers

value: Show HN: Vdiff – CLI to help you review AI-generated code

author: fforbeck


value: Show HN: RegularMonk – a web app that helps me use my phone less


value:
TradingAgents (github.com/TauricResearch/TradingAgents) is a great multi-agent stock analysis framework but requires LLM API keys. I rebuilt it as a Claude Code plugin that runs on your existing Claude subscription — zero extra API cost.
Type `/trading-analysis NVDA` and it spawns 7 subagents: parallel Technical/News/ Fundamentals/Macro analysts, then a sequential Bull → Bear → Risk Analyst debate, then Research Manager → Trader → Portfolio Manager.
/plugin marketplace add lucemia/trading-agents-plugin
/plugin install trading-agents-plugin
https://github.com/lucemia/trading-agents-plugin

value: Show HN: TradingAgents without the API bill – run multi agents in Claude Code


value: Show HN: Predicting the 2026 Kentucky Derby with 1T Monte Carlo Sims on Burla


value: spinchange

value: A Claude skill that produces 10 ranked answers to any prompt instead of one, each with a probability estimate. Includes a "Mixture of Eccentrics" synthesis. (Gist)

value: Show HN: Verbalized-Sample-Skill.md Modal Probability-Ranked Answer Distribution

author: spinchange


value: freakynit

value: Show HN: Writing a deep-research agent from scratch

author: freakynit


value: ChameleonDB

value: Show HN: ChameleonDB – A database toolkit with auditable schema versioning

author: ChameleonDB


value: TemporaryMail

value:
I made a really simple tool that let's you lookup the DNS, WhoIs and IP of the site that you're visiting. It also let's you highlight IPs on websites, right-click and do lookups in context windows as well.
Hope it helps out other devs as much as it helps me on a daily basis:
https://chromewebstore.google.com/detail/ipaddressto-lookup/...
https://addons.mozilla.org/en-US/firefox/addon/ipaddress-to-...
The extension uses https://ipaddress.to

value: Show HN: IP Lookup Extension

author: TemporaryMail

title: Show HN: IP Lookup Extension


value: lackoftactics

value: The chess app built with Next.js, Convex, and Clerk, where Stockfish (WebAssembly) runs entirely in the browser. Instead of playing freely, you're limited to the engine's top suggested moves — but their evaluations are hidden until you pick one. Human intuition guides the choice; the engine does the heavy lifting.revealed.<p>You can select from two types of move selections 1-5 and jkml; vim style

value: Show HN: Vim and centaur chess inspired app, where you choose from top moves

author: lackoftactics


value: opiniateddev

value: Show HN: Native agent runtime for Conductor OSS

author: opiniateddev


value:
Hi HN :D I'm 20 and I spent a year building something that shouldn't be possible: a custom on-device vision LLM that processes your entire digital life overnight on a phone.
We all have thousands of buried screenshots, notes, files, bookmarks, saved posts, etc we'll never find again. The only way to make AI understand all of it is to upload everything to the cloud -- privacy nightmare, and way too expensive at scale. And it shouldn't be possible on-device either: small models are too dumb, and phones are too slow for thousands of LLM inference runs.
So I spent a year deeply optimizing every layer of the on-device inference stack to make it possible anyway.
Sentient OS runs a custom multimodal vision LLM on your phone and laptop while they charge overnight. It understands your entire digital life -- every screenshot, note, file, email, bookmark, plus integrations for external services -- with nothing ever leaving your device.
This gives you three things that weren't possible before:
-> Talk to your entire digital life in natural language: "what was that wine I liked?" / "who did I wanna meet next week?" [on-device RAG]. And with MCP, your existing LLM (ChatGPT, Claude, etc.) can talk to your digital life too -- so it actually understands you.
-> Proactive reminders surfaced from your own data: "that tax return in your Downloads is due next week" / "tickets for that concert you screenshotted open tomorrow"
-> Knowledge graphs of your entire digital life: tap any node to find what you buried!
Here's what I had to build to make this possible:
Inference speed:
- KV cache reuse: the system prompt + few-shot examples are identical across all 3,000 analysis calls. I run inference on that prefix once, cache the KV state, and reuse it for every image. Prefill drops to just processing the image itself.
- Thermal-aware scheduling: I throttle the moment iOS reports thermal state > fair. I have all night, so I trade speed for not cooking the device.
- iOS jetsam awareness: iOS kills apps above a specific RAM threshold. I profiled that threshold across different iPhones and push right up to the edge.
Model quality at small size:
- Vision transplant: a 2B Qwen model has terrible vision. I transplanted Qwen 3.5 9B's multimodal projector onto the 2B base. Same architecture family makes this possible.
- Selective quantization on MLX: MLX doesn't support k-quant style mixed precision. I built it manually: less quantization on first/last layers and high-activation layers, more aggressive on the rest.
The alpha processes ~3,000 screenshots entirely on-device on a 6 year old iPhone. Coming to Mac and iPhone!
Previously I researched Apple's neural accelerators: https://www.reddit.com/r/LocalLLaMA/comments/1ohrn20/
And I love OSS! I built https://github.com/theJayTea/WritingTools (2K+ stars, ~30 press features). I'm considering making Sentient OS OSS under AGPL (so no one else can profit off of my work haha).
I think this is one of the coolest consumer usecases to take advantage of on-device LLMs. I'd love to hear what you all think, and happy to answer any questions (I love geeking out about the deep work that's gone into optimizing models and inference!) :D

value: Show HN: Sentient OS – On-device intelligence layer for your entire digital life


value: mikolajw

value: Show HN: Rust library for Undo/Redo using deltas, snapshots or commands

author: mikolajw


value:
This work establishes a foundational
invariant for
proactive stability monitoring in artificial intelligence, legal frameworks, financial systems,
.and biological sequences

value: Show HN: A Universal Stability Criterion for Symbolic Complex Systems


value: Show HN: High perfomance database - Graph, vector, array, columnar, KV


value: Show HN: Which public repos are friendliest to an AI coding agent?


value: PestoDiRucola

value: Show HN: Fabrica – A minimal terminal-based coding agent built in Rust

author: PestoDiRucola


value: Show HN: Virshle – Make ordinary virtual machines


value: RaiyanYahya

value: Show HN: I built a dev workspace with AI as backbone

author: RaiyanYahya


value: vednig

value: Show HN: Clipmon is a macOS clipboard manager on steroids

author: vednig


value: cryptoz

value:
Hi everyone,
I've encountered two major problems while building AI-powered sites: 1) Most agentic tooling doesn't have a enough of a targeted approach to edits to existing files, and will make extraneous edits, 2) Many users will want to try things casually but not spend on each LLM-powered webapp they want to use.
The first problem of targeting edits was a much bigger issue previously, where, before agents, ChatGPT would just delete a chuck of code and replace it with `// existing code goes here`. Simply editing existing files was a pain. This is mostly solved now as Cursor et al. do a much better job by replacing specific lines and such. However, they still go off the rails a lot (especially gemini cli I've noticed) and make unnecessary and unwanted changes.
I'm hoping to solve that by using my Abstract Syntax Tree approach: when editing a file, the LLM is actually instructed to write code that will modify the data structure backing the source text, rather than the source text itself. For example, to edit an HTML file, we instruct the LLM to write python that imports beautifulsoup and then modifies the data structure underneath it.
I hope to solve the second problem (of token usage costing real money but users not wanting to sign up for every site they might want to use) by running a token margin sharing system. Here's how it works: I charge 2x for token usage based on the LLM provider (Anthropic and OpenAI support so far). This creates the margin. A developer can then publish their LLM-powered webapp to a subdomain, where I will proxy all the LLM requests to capture token usage. Then when an end-user lands on their site, the user is charged at the 2x rate, where the developer earns 80% of the extra margin and I earn 20%.
Yes, end-users would still have to sign up and pay via stripe, but only once, on Code+=AI. Then they can use any site published on our subdomains that calls LLMs without having to pay for each one.
Curious what you think about all this. I've just opened guest-usage on the site so you can build a project without signing up (guests have $2 to spend, and you get $3 more when you make a free account).
Thanks and cheers!
- Jacob

value: Show HN: A marketplace for LLM-powered webapps earning on token margins

author: cryptoz


value: Show HN: I Built a Museum Exhibit

title: Show HN: I Built a Museum Exhibit


value: Show HN: Rotato – Node.js proxy that rotates LLM API keys on 429 errors


value: yunusabd

value:
Hello HN,
I was away from my computer for two weeks, and after coming back and reading the latest discussions on HN about coding assistants (models, harnesses), I felt very out of the loop. My normal process would have been to keep reading and figure out the latest and greatest from people's comments, but I wanted to try and automate this process.
Basically the goal is to get a quick overview over which coding models are popular on HN. A next iteration could also scan for harnesses that people use, or info on self-hosting or hardware setups.
I wrote a short intro on the page about the pipeline that collects and analyzes the data, but feel free to ask for more details or check the Google Sheet for more info.
https://hnup.date/hn-sota

value: Show HN: State of the Art of Coding Models, According to Hacker News Commenters

author: yunusabd


value: ramoz

value: Show HN: Plannotator for Codex

author: ramoz

title: Show HN: Plannotator for Codex


value: itsloopyo

value:
Hi all, I've been tirelessly swearing at Claude for several months in an effort to cram head tracking into loads of games and generally make it more accessible.
I'm working on dozens of OpenTrack compatible game mods all of which are being released under the MIT license, 9 are out now and can be found on GitHub/Nexus Mods:
https://github.com/itsloopyo?tab=repositories&q=head+trackin...
https://www.nexusmods.com/profile/itsloopyo/mods
In the linked video I discuss my iPhone app, Headcam, and the library powering its absurdly responsive video streaming.
If anybody would like to try it, you can join the TestFlight beta at https://headcam.app

value: Show HN: Headcam - head tracking & streaming app (iOS) [video]

author: itsloopyo


value: ChadNauseam

value:
I'd like to share my language learning site: https://yap.town . (Github: https://github.com/yaptown/yap )
The basic idea is to combine spaced repetition (like Anki) with comprehensible input. So the app tracks what you know and tries to give you sentences that are at your level and that reviews what you need to review. The sentences are pulled mostly from movies and TV shows so you get to review every word in a natural context and with realistic usage. I find this much more fun than just looking at flashcards.
Currently I support French, Spanish, German, Italian, and Portuguese. I also have early support for Russian and Korean.
I originally made it to help myself learn French, but my friends kept asking to use it, so I thought I'd add some more languages and release it publicly. I have friends using it for German, Spanish, Italian, and Korean right now. I'm not interested in making money from it right now so there's no monetization.
P.S. For people who like pimsleur, you can also choose to review words from any pimsleur lesson in Yap.

value: Show HN: Language app with spaced repetition and comprehensible input

author: ChadNauseam


value: Show HN: FundSim – free browser LBO, DCF and IB deal simulator (no signup)


value:
I created a simple project to allow you to use a phone as a web proxy.  This is not a proxy for the phone, its a way to proxy web traffic from elsewhere via the phone.  One practical use case is accessing geo-restricted content. If you have a trusted contact in the country with an Android phone, this can serve as a simple alternative to a commercial VPN.
To set it up you need to run a proxy server which can run as a docker container. You then need to install the app on the Android phone which will connect to the server. Finally you configure a browser to use the proxy server as the HTTP/HTTPS proxy.
More details here: https://github.com/vgaj/proxy#mobile-phone-proxy
Let me know how you go and if you run into any issues.

value: Show HN: Use an Android Phone as an HTTP Proxy


value: nicolas-siplis

value:
Hey HN! I've been working on this for the past few months and I think it's at the point where I'm ready for some user feedback.
It's a WASM engine attempting to accurately model all of MTG's rules and cards. AFAIK, this is the first MTG engine which tries to accomplish this by live compiling the entire card collection at runtime, instead of coding each individual card.
You can create your own unique cards to playtest against ("Compile Card" button is what you're looking for), as long as they follow the engine's supported grammar (which I'm working on so that it fully supports Magic's ~30k legally playable cards, currently at 23k partially/17k fully supported).
It also supports 4-way P2P multiplayer lobbies via PeerJS, though I haven't had enough time to test everything network related so there may be some hidden bugs there!
My dev process was heavily influenced by the recent surge in agentic coding, but I think I've settled on an architecture which successfully manages to avoid slop creeping in:
Each card from its original, normalized oracle text into a CardDefinition struct which contains every single behavior for that particular card. By the time this card definition is compiled, we no longer have access to the original oracle text.
Each effect in the card's compiled definition can be decompiled into human readable text, after which a series of normalization steps based on the AST structure of the card's compilation and a post-pass to cleanup awkward wording is applied. The resulting compiled oracle text is compared against the original card's using vector embeddings, which gives us a semantic similarity score.
The entire purpose of this development workflow is making it obvious to the AI which cards are working correctly and which ones still need better support, without having to rely on behavioral tests for every single card. It took me some time until I finally managed to get the architecture to the point where the AI doesn't cheat its way into improving the card coverage, but the whole experience has been a fantastic way of getting used to this new way of coding and I'm excited to see how the future of our profession looks like in a few years.
I'm looking for any kind of feedback, both UI/UX and engine related, so please share your thoughts!

value: Show HN: A (de)compiler and parser/engine for custom Magic: The Gathering cards

author: nicolas-siplis


value: drschlange

value:
I build a raspberry pico rp2040 synth named LISA which relies on a live dynamic wavetables approach to build a sound from low-speed signals.
It has up to 6 voices, it proposes the BRAIDS macro-oscillators, exposing +40 differents sound engines, and it adds an additional experimental engine where the wavetables are created by an async brain, named Nallely. Nallely is a small modular environment coded in Python which runs on a raspberry pi and is built for exploring emergent behaviors. You program it by patching independent autonomous modules together.
How does it works? The brain generates signals which are streamed via MIDI (via pitchwheel on 4 different channels for 14bits resolution) at slow speed in 4 different circular wavetables of the synth. LISA lets you play while the wavetables are constantly rewritten in real-time. The brain execution model is a fully async hybrid actor model based on independent threads. No global clock or synchronization is enforced. Consequently, because of the CPU load, temperature, OS scheduler, network,... and message passing, the modules constantly drift unpredictibly, either lightly, or harshly depending on the topology of your patch. The signals that are produced by Nallely can be used as waveform for the wavetables, as notes sequences, or as CV equivalent, there is no distinction in what signals represent, the topology of the patch determines what will be the final piece.
In the demo video, I just built an harmonic oscillator using 2 integrators patched in feedback, which is fed to one of the wavetables. This oscillator is then connected to other modules to derive other wavetables and functions which are patched in the other wavetables and the synth parameters.
https://www.youtube.com/watch?v=fxvfnqQKWsY
LISA firmware is written in C/C++ and runs on rp2040, while Nallely is written purely in Python, and can run on a Raspberry Pi. Nallely have been successfully tested on a rpi zero2, a rpi3, and a rpi5.
You don't have to use Nallely to use LISA, it's a standalone MIDI synth, and you don't have to use LISA to use Nallely, it's a generic modular brain which happens to speak MIDI, but LISA coupled with Nallely become the Fodongo synth: a synth that lets you sculpt your wavetables in real-time.
I'm just starting to experiment with this and I try to explore what can be done with slow cv-rate signals feeding wavetables to create sounds. So far I can get a nice variety of sounds, from very pure sine if using LFOs, to very harsh drifting phasing sawtooth sound, or massive organ-like sounds.
It fits well for drone, especially using the envelope: the release can go up to 5s, emphasizing all the micro-drifts and variations in the wavetables, sounds overlap, changes, fades, etc.
LISA and Nallely are free open-source projects:
Nallely: https://github.com/dr-schlange/nallely-midi
LISA: https://github.com/dr-schlange/LISA

value: Show HN: Lisa a live dynamic wavetables synth you play and program in real-time

author: drschlange


value: Show HN: Pantheon – A Path 1 PlayStation 2 game engine (VU1 / EE / DMA)


value: theaniketmaurya

value:
I've been running Pi using SmolVM to build SmolVM!
SmolVM provides an abstraction over microVMs to easily create sandboxes for coding agents, OpenClaw, or just to build a custom harness.
To use it, install using:
curl -sSL https://celesto.ai/install.sh | bash
and then run:
smolvm pi start

value: Show HN: I'm running parallel Pi agents on a local sandbox

author: theaniketmaurya


value: threejin

value: drag the start button to right to start playing

value: Show HN: Tidal town – HTML5 game where you protect your town from tides

author: threejin


value: ulfdev

value: Show HN: ScaleBridge – sync Withings weigh-ins to Garmin Connect

author: ulfdev


value: Show HN: Hangman Game

title: Show HN: Hangman Game


value: evantahler

value: Show HN: Keryx: TypeScript framework where one Action becomes HTTP, WS, CLI, MCP

author: evantahler


value: janpmz

value: Show HN: Stay Lean – Calorie Navigation

author: janpmz

title: Show HN: Stay Lean – Calorie Navigation