value: kaniksu

value:
I've been using this daily for 4 months and figured others might find it useful. This is my first open source project so would love any feedback.
Ray connects to your bank via Plaid, stores everything in an encrypted local SQLite database, and lets you ask questions about your finances in natural language. No cloud, no account, your data is stored on your machine.
Before anything reaches the LLM, all PII is stripped — your name, companies, transaction details are redacted and replaced with tokens, then rehydrated locally in the response. The AI never sees who you are.

value: Show HN: Ray – an open-source AI financial advisor that runs in your terminal

author: kaniksu


value: ivanjeka

value: Show HN: Tmuzika – terminal music player in C (v1.1.2)

author: ivanjeka


value: vsromanc

value: Show HN: Chrome extension prototype for cross-tab/frame network interception

author: vsromanc


value: dmk

value:
There are plenty of Artemis II trackers out there. I looked at a bunch and kept running into the same issues - some had data that didn't look right, it was hard to use on smaller screen, others felt overly complicated for what I actually wanted to know: what's the crew doing, where is Orion, how fast is it going. The best one I found was issinfo.net/artemis, which inspired a lot of the design.
So I built my own. The part that was genuinely interesting to me was the data. Turns out anyone can query JPL's Horizons API for full ephemeris data on the Orion spacecraft - position, velocity, range - for free. I had no idea this existed.
Even better: NASA's Deep Space Network publishes a live XML feed (eyes.nasa.gov/dsn/data/dsn.xml) that updates every 5 seconds showing exactly which ground antennas are talking to which spacecraft. Right now two dishes in Canberra are locked onto Orion - one sending commands, both receiving 6 Mbps of S-band telemetry at 296,000 km. You can see Juno at Jupiter, JWST, Mars Odyssey, all in the same feed. It's pretty amazing what's just sitting there in the open.
The app fetches trajectory from Horizons, crew activities from NASA's published flight plan, and live ground station status from DSN. I'll be honest - it's mostly vibe-coded with supervision. The data pipeline is the part that was more manual: figuring out what's publicly available, how to compute relative positions from raw vectors, how to cache and backfill. That was the fun part.
Code is open on GitHub. I built it for myself and as a fun exercise, but happy for any feedback - especially around data correctness and what other public data sources are out there that I might be missing.
Source: https://github.com/dmarchuk/artemis.fyi

value: Show HN: Artemis.fyi - Real-time tracker for the Artemis II Moon mission

author: dmk


value: zimengx

value: Show HN: Self-Host Excalidraw with Collaboration and Storage

author: zimengx


value: fcpguru

value:
Been hacking on this project using 100ms.live video rooms with two people. And in order to test I've been using two browsers and just real live video of myself on both sides. There's an echo. And boy am I sick of looking at myself doing this lol.
So I wrote a script that launches a headless Chrome instance that joins a 100ms video room as a "bot user", streams a provided media file (video + audio) as if it were a real webcam/microphone. It uses ffmpeg + ffprobe to scale the video to a max dimension, normalize FPS, and convert to:
.y4m (video for Chrome fake camera)
.wav (audio for fake mic)
You can see a test 45 min podcast with these bots on our staging server:
https://staging-fe.taout.tv/view-podcast/9b106d39-3c78-415a-...
This has been a game changer for our internal testing. Now the bots take care of the two hosts and our team can join the room as viewers which has all sorts of other features to test.
You are welcome to try out the real site too. Prod is:
https://www.taout.tv/

value: Show HN: Using bots to connect to 100ms.live video room for testing

author: fcpguru


value: menggg

value: Show HN: Watch an AI-agent utopian commune fall apart

author: menggg


value: ilayn

value:
Before anything, let me get certain concerns out of the way, right away
Mandatory disclosure: Just to prove that this is not some yet-another-LLM cracked-pottery, I did similar work for SciPy and hand-translated ARPACK, PROPACK, QUADPACK, ODEPACK and bunch of other packs (https://github.com/scipy/scipy/issues/18566 for the complete list, ~85K SLOC) when LLMs were not good for this type of work. Most of the translations are already released in previous SciPy versions so I hope that provides credibility for F77 -> C11 translation work. Now LLMs are slightly better and for LAPACK translation, I used Claude Code as an assistant for certain tasks. End of PSA.
-------- We now return to normal programming.
This is a C11 translation of the venerable Fortran77 linear algebra library, LAPACK. In case you can't afford or don't want Fortran dependency, this project might help. It works exclusively with a CBLAS interface to avoid the symbol naming bonanza that affects every other vendor (is it uppercase or not, with/out trailing underscore, ...). A bit controversially, translation is 0-indexed inside out, except the error codes. unfortunately `info = 0` encodes success so we can't do much about that.
Current test coverage; LAPACK own test suite (450K parametrized tests also mapped to C), NumPy test suite and SciPy test suite all pass. At least in the most common algorithms it is sound. For less covered ones, still there might be bugs and hence I marked it as alpha for now. But if you find any, write up an issue in the repo.
Also this makes it much easier to compile OpenBLAS and LAPACK with for your own machine or wherever it is meant to be running with architecture optimizations enabled and it works with a leaner binary size.
If you also want a drop-in replacement, there is also a fortran-shim supplied that will convert the wrappers to be seen as 1-indexed (that's how I tested NumPy/SciPy) with a bit of performance hit.
You can also name mangle the symbols to your liking with prefix and suffixes if you don't like the default. ILP64 is also supported and if you try to link with ILP64 CBLAS, it either complains if it was accidentally linked or handles things for you if you provide the flag.
The doxygen version of the documentation on Netlib, always rubbed me the wrong way for some reason; hence I tried my spin on it. It's here: https://ilayn.github.io/semicolon-lapack/
One particular detail I wanted to see often, was to see all four flavors at the same time; now they are grouped like this https://ilayn.github.io/semicolon-lapack/api/linear-systems/... If I failed please let me know, I'm still exploring the details. The default fonts, as an example, definitely need some love.
A couple of points as a futile attempt to prevent unhelpful discussions;
- There is nothing wrong with Fortran. If you like it keep using it. I don't, though big fan of Fortran77 for its era, not so much what is called the modern one.
- This work has nothing to do with Fortran. It tries to serve a particular audience that use exclusively a C toolchain and does not want inter-language issues.
- This work hopes to attract more people for optimizing the C code for common benefit.
Some more reasoning is given in the documentation.
All feedback/criticism welcome.

value: Show HN: LAPACK without Fortran77; a C11 translation

author: ilayn


value: feelingsonice

value:
I was frustrated that memory is usually tied to a specific tool. They’re useful inside one session but I have to re-explain the same things when I switch tools or sessions. Furthermore, most agents' memory systems just append to a markdown file and dump the whole thing into context. Eventually, it's full of irrelevant information that wastes tokens.
So I built this local memory layer that unifies memory across agents. Instead of a flat file, it builds a structured knowledge graph of "memory notes" inspired by the paper "A-MEM: Agentic Memory for LLM Agents" (https://arxiv.org/abs/2502.12110). The graph continuously evolves as more memories are committed, so older context stays organized rather than piling up.
It captures conversation turns and exposes an MCP service so any supported agent can query for information relevant to the current context. In practice that means less context rot and better long-term memory recall across all your agents. Right now it supports Claude Code, Codex, Gemini CLI, OpenCode, and OpenClaw.
Would love to hear any feedback.

value: Show HN: Unify memory across agents and improve context rot, written in Rust

author: feelingsonice


value: faalbane

value: Hi everyone! I'm a megafan of Bladerunner 2049 and the idea of preserving memories, stories, and wisdom of human beings long into the future, and for this information to be easily accessible to anyone anywhere anytime.<p>This is my phase 1 implementation of this vision. Phase 2 are 3D models and photorealism. Here's how it works: anyone can create Essence models of themselves or anyone else. You can train these models on information (text for now). Then, you can share this model with the world to enjoy and chat with, about anything. You can also organize a dinner party or debate with multiple Essence models to see what happens when they interact.

value: Show HN: Essence is a living human wisdom archive

author: faalbane


value: simonsysun

value: Show HN: SeekLink – Local hybrid search and link discovery for Obsidian vaults

author: simonsysun


value: adshao

value: Show HN: Vibooks – Local-first bookkeeping software built for AI agents

author: adshao


value: waveywaves

value:
Hi HN, I built Contrapunk because I wanted to play guitar and hear
counterpoint harmonies generated in real-time. It takes audio from your guitar, MIDI player or your computer keyboard and generates harmony voices that follow counterpoint rules to generate harmonies. You can choose the key you would like to improvise/play in and the voice leading style and which part of the harmony you would like to play as, as well.
macOS DMG:
https://github.com/contrapunk-audio/contrapunk/releases/tag/...
Source: https://github.com/contrapunk-audio/contrapunk (do open any issues if you have any)
Would love feedback on the DSP approach and the harmony algorithms. I am also looking at training a ML model for better realtime guitar to midi detection. I believe that will take some time.

value: Show HN: Contrapunk – Real-time counterpoint harmony from guitar input

author: waveywaves


value: poitrus

value: Show HN: Lagsim – Simulate real network conditions (3G, WiFi, Starlink)

author: poitrus


value: Show HN: Dobby Layer – Tool to uncover hidden costs in crypto trades and fix it


value: dougcalobrisi

value: Show HN: A LinuxCNC gRPC Server with Clients in Rust, Go, Python, Node

author: dougcalobrisi


value: sparacha

value:
Hey HN
Salman, Shuguang and Adil here from Katanemo Labs (a DigitalOcean company).
Wanted to introduce our latest research on agentic systems called Signals. If you've been building agents, you've probably noticed that there are far too many agent traces/trajectories to review one by one, and using humans or extra LLM calls to inspect all of them gets expensive really fast. The paper proposes a lightweight way to compute structured “signals” from live agent interactions so you can surface the trajectories most worth looking at, without changing the agent’s online behavior. Computing Signals doesn't require a GPU.
Signals are grouped into a simple taxonomy across interaction, execution, and environment patterns, including things like misalignment, stagnation, disengagement, failure, looping, and exhaustion. In an annotation study on τ-bench, signal-based sampling reached an 82% informativeness rate versus 54% for random sampling, which translated to a 1.52x efficiency gain per informative trajectory.
Paper: arXiv 2604.00356.
Project where Signals are already implemented: https://github.com/katanemo/plano
Happy to answer questions on the taxonomy, implementation details, or where this breaks down.

value: Show HN: Signals – finding the most informative agent traces without LLM judges

author: sparacha


value: TechSquidTV

value: This is 100% vibe coded. I have been tired for a while wanting a quick way to make "meme" style images and other simple image edits without bloat, signups, ads, watermarks etc.<p>Just a simple react app, in-browser, hosted on GitHub Pages.

value: Show HN: Simple Local Meme Generator

author: TechSquidTV

title: Show HN: Simple Local Meme Generator


value: chevuru

value:
I always assumed Gmail bloat came from large attachments.
  Turns out 3 senders were responsible for 30% of my inbox —
  thousands of tiny emails I'd never thought to clean up.

  I built mailtrim to surface this pattern:

  - ranks senders by actual storage impact (not just count)
  - confidence scoring on what's safe to bulk-delete
  - 30-day undo on everything — nothing is permanent by default
  - runs entirely locally, no email data leaves your machine

  Free, open source (MIT). No subscription, no backend.

  One friction point upfront: Gmail API setup is one-time, ~15 min.
  After that it's just `mailtrim stats` and `mailtrim purge`.

  Keen to hear feedback on the confidence/safety model especially —
  that's the part I'm least sure I've got right.

  https://github.com/sadhgurutech/mailtrim

value: Show HN: mailtrim – find what's actually filling your Gmail inbox

author: chevuru


value: kstonekuan

value:
yoink is a Claude Code plugin that removes complex dependencies from your codebase by reimplementing only the functions you actually use.
yoink runs as a three-step, agent skills-based workflow:
1. /setup clones the target repo and scaffolds a replacement package.
2. /curate-tests generates tests verified against the original's expectations.
3. /decompose determines dependencies to keep or decompose based on principles such as "keeping foundational primitives regardless of how narrow they are used".
We built yoink in response to the five major supply chain attacks that happened in two weeks, including LiteLLM and axios. We install most of these packages without thinking twice.
Andrej Karpathy recently called for re-evaluating the belief that "dependencies are good". OpenAI echoed this in their harness engineering article: agents reason better from reimplemented functionality they have full visibility into, over opaque third-party libraries.
yoink makes this capability accessible to anyone.
Refer to the GitHub repo to install the plugin to Claude Code: https://github.com/theogbrand/yoink
Love to hear what you think!

value: Show HN: Yoink functionality from dependencies and avoid supply chain attacks

author: kstonekuan


value: lexalizer

value: A project which groups together curated open source intelligence tools, frameworks, and techniques.

value: Show HN: OsintRadar – Curated directory for osint tools

author: lexalizer


value: Show HN: Bb – Windows API viewer for hackers, in the browser


value: adekdev

value:
I built a browser-based simulator of NASA's Artemis II mission — the first crewed lunar
flight since Apollo 17.
You fly the actual mission profile: launch to parking orbit, raise to High Earth Orbit,
fire Trans-Lunar Injection when the Moon is in position, swing behind the Moon, and
return to Earth. The physics uses RK4 integration with real Earth and Moon gravity.
Have fun experimenting with what happens if you don't time it right!

value: Show HN: Artemis II Moon Mission Simulator in the Browser

author: adekdev


value: brenocq

value: Show HN: ImPlot v1.0 – 6 years of Immediate-mode plotting for Dear ImGui

author: brenocq


value: aaresvictor

value: show HN:I built a GDPR consent manager for agencies (one dashboard, 30 domains)

author: aaresvictor


value: maxshadurskiy

value: Hi Hackers. I built an EAT skill that lets an agent place food delivery orders. The idea came up while cooking and realizing ordering groceries requires too much screen interaction. This lets you send something like “order eggs from Wolt” and the agent handles the flow. It currently integrates with Wolt and runs on top of OpenClaw.<p>Still rough around the edges.

value: Show HN: I built an EAT skill that lets an agent place food delivery orders

author: maxshadurskiy


value: Show HN: Markdown wikis that are easy for agents and humans


value: ajoshu

value: This is something I made with Astro, I am going to attempt to monetise it and run ads since I think it is a cool business model, I can post a guide on how this works if anyone is interested. - It's using Astro, Headless Shopify and Gelato, the main cost will be running ads.<p>It's a useful template if anyone wants. - Play about with the editor

value: Show HN: Starframer.com

author: ajoshu

title: Show HN: Starframer.com


value: artiomyak

value: Show HN: White Border

author: artiomyak

title: Show HN: White Border


value:
Hey HN! Over the past few years, I’ve spent way too much time copy-pasting SSH public keys just to give people access to servers. It always felt like a chore, and the security risks (offboarding, revocation, etc.) aren’t great either.
I looked into solutions like Teleport and Smallstep, but they felt a bit too heavy and complex for what I needed.
So over the past few weeks I vibe-coded a small solution to scratch my own itch: sshifu.
The idea is simple — you set up a “sshifu server” as an auth server, configure your SSH servers to trust it, and then giving access is just telling someone to run:
"npx sshifu sshifu-server.com ssh-server.com"
That’s it. No more copying keys or touching "authorized_keys".
It’s still early and a bit rough around the edges, but it’s been working well for me so far.
Would love feedback — what’s missing for real-world usage, and what would stop you from using this?

value: Show HN: Sshifu – Give SSH access in 1 command. Teleport/Smallstep alternative


value: kaant

value: Show HN: I built a free web tool to convert PNG/SVG files to 3D printable STLs

author: kaant


value: harryfelio

value:
Like many solo devs and indie hackers, I was paying $100+/mo for enterprise SEO tools (Ahrefs, Semrush) but only using about 5% of their features. I really just needed basic keyword research, SERP difficulty analysis, and simple rank tracking.
I wanted to see what the actual floor was for raw SEO data if you stripped away the fluff and enterprise bloat.
I spent the last few months wiring together different data sources to find out. I got my costs down to a few cents per report and because the data is so cheap to fetch on-demand, I packaged it into a minimalist tool which strictly focuses on the essential elements of SEO:
A keyword analyzer which pulls the top 10 search results, audits them, and flags weak spots (like low DA sites or forums like Reddit) to calculate a realistic difficulty score, a keyword finder which generates hundreds of scored long-tail variations, and a rank tracker with email notifications.
Because the costs on my end are so lean, I don't need to charge $100/mo - so I set up a "Hobbyist" tier at $9/mo which more or less covers data costs and gives you 100 deep searches a month.
If you want to poke around the UI or test the data accuracy, new accounts get 3 free credits every month (no card required). I'd love brutally honest feedback on the UX / if you could see yourself doing keyword research with it.

value: Show HN: I built a $9 Ahrefs alternative because raw SEO data is cheap

author: harryfelio


value: INVARIAN

value:
We built a vector search engine based on Quantized Tensor Train (QTT) decomposition. Instead of approximate nearest neighbor (ANN) indices like HNSW or IVF, we factorize the entire dataset into a compressed tensor format and serve exact cosine similarity queries directly from the compressed representation.
The headline: 1 billion vectors on a single H100, 38ms query, 100% recall, 66 GB serving.
Recall improves with scale at fp16: 96% at 400M → 98% at 500M → 99% at 600M → 100% at 1B. This is the opposite of ANN indices, where recall degrades with scale. More data helps the decomposition converge.
Every number below is measured, not projected. Full benchmark suite across 4 GPUs at 3 precision tiers. H100 80GB, 384-dim embeddings, rank=32.
fp16 (Scale tier) — H100 80GB:

  100M:  5.87ms p50,  6.6 GB serving, 100% recall, 46.5x compression
  500M: 20.54ms p50, 33.0 GB serving,  98% recall, 46.5x compression
    1B: 38.51ms p50, 66.0 GB serving, 100% recall, 46.5x compression

fp32 (Production tier) — H100 80GB:
  100M: 18.96ms p50, 13.2 GB serving, 100% recall, 23.3x compression
  300M: 46.29ms p50, 39.6 GB serving, 100% recall, 23.3x compression
  500M: 76.53ms p50, 66.0 GB serving, 100% recall, 23.3x compression
fp64 (Exact tier) — H100 80GB:
   10M:  2.68ms p50,  2.6 GB serving, 100% recall, 11.6x compression
  100M: 20.40ms p50, 26.4 GB serving, 100% recall, 11.6x compression
  200M: 40.40ms p50, 51.6 GB serving, 100% recall, 11.6x compression
Hardware portability — same codebase, different GPUs:
  P4000  8 GB:   fp16 50M,  26ms p50, 100% recall, $0.07/hr
  A100  40 GB:   fp16 200M,  3.1ms p50, 98% recall, $0.70/hr
  H100  80 GB:   fp16 500M,  3.1ms p50, 98% recall, $2.09/hr
  B200 192 GB:   fp16 500M,  1.4ms p50, 99% recall, est. ~$5/hr
Recall is hardware-invariant. Same math, same results, P4000 through H100. The 2B run on B200 is in progress.
How it works: The dataset X (N×D) is factored as X ≈ Z · V_T where Z is (N×r) and V_T is (r×D), with r=32. Query is a single GEMV: scores = Z · (V_T · q). Bytes per entry: 2r bytes at fp16 = 64 bytes regardless of embedding dimension. A 1536-dim OpenAI ada-002 embedding compresses 23.6x at fp32 with zero recall loss.
Compression is dimension-independent:

  384-dim  MiniLM:     11.6x, 100% recall
  768-dim  E5-large:   11.8x, 100% recall
  1024-dim Cohere v3:  15.8x, 100% recall
  1536-dim ada-002:    23.6x, 100% recall

Operational details (H100, 10M vectors):
  QPS: 317 single client, 183 at 100 concurrent
  Cold start: 8.88s from snapshot to first query
  24h soak: 2.9M queries, 8.6M inserts, zero data corruption
  Insert-under-query: 885 inserts/s concurrent with 101 QPS
  All artifacts (JSON + logs) available
Build uses streaming randomized SVD — peak VRAM equals serving size, not dataset size. The 2B run on B200 uses streaming coefficient regeneration so the 512 GB coefficient matrix is never fully allocated in RAM.
brad@holonomx.com

value: Show HN: 1B Embeddings

author: INVARIAN

title: Show HN: 1B Embeddings


value: gkoos

value: Live benchmark comparing fetch, axios, ky, and ffetch side-by-side with configurable latency, failures, and rate limiting. No setup needed. Run chaos scenarios and see real-time reliability metrics.

value: Show HN: Fetch Reliability Arena – Compare HTTP clients under chaos

author: gkoos


value: Leftium

value:
- Visualize weather metrics via space and colors
- Compare current/future conditions with weather you experienced the day before
- Understand/compare how conditions change throughout the day
---
WeatherSense started out as a hand-coded project: https://github.com/Leftium/weather-sense
- Would you consider this project a good example of how AI can be used to enhance coding?
- Claude helped implement many new features from the backlog, like 60-min precipitation forecasts
- Claude helped add some whimsical features: I only considered adding because AI experimentation is cheap:
* "Calm mode:" truly emphasizes how WeatherSense doesn't need numbers by removing/replacing all numbers from UI
* Dynamic background color based on sun angle (time + location)
---
Major inspirations:
- DarkSky
- MerrySky (https://merrysky.net)

value: Show HN: Beautiful intuitive weather forecasts that don't rely on numbers/units

author: Leftium


value: Show HN: Homebutler – Self-healing homelab in a single Go binary


value: askintml

value: Show HN: Async bulk product shots and videos to automate store visuals

author: askintml


value: I love The Dictionary Game (the party game where everyone submits a fake definition for an obscure word and you vote for the one you think is real), but I found it not so easy to get a session going. I made this async version to play the game more casually and hopefully against a larger pool of players, too.<p>There is one word per day. You play against the definitions submitted by yesterday's players and (optionally) submit your own for tomorrow's word. All definitions rank on a global leaderboard.

value: Show HN: Plausible – asynchronous Balderdash (a.k.a. the Dictionary Game)


value: jcubic

value: Show HN: AI-agent instructions to restore Claude Pro/Max in OpenCode

author: jcubic


value: ekadet

value:
I built a Claude Code skill called crabby that makes Claude output diagnostics in rustc error format - severity codes, location arrows, causation spans, and a paste-able fix every time. The twist: Claude becomes Ferris the crab, grumpy and unimpressed, but technically precise.
The format works for code review, writing review, architecture, strategy - anything you submit. The "writing review" example tends to surprise people: it flags passive voice in a postmortem with the exact same error[W002] format as a SQL injection.
https://github.com/ekadetov/crabby

value: Show HN: Crabby – Claude Code skill that reviews code like the Rust compiler

author: ekadet


value: Hilash

value:
Hi HN,
for quite some time I've been thinking how LLMs are missing the knowledge base, where I can dump CSVs, PDFs, and most important, inline web app. running on Claude Code (bring your own agent) with agents with heartbeats and jobs
https://runcabinet.com
It runs locally and is installable via npm.
GitHub (open source): https://github.com/hilash/cabinet
This is still very early. I put the first version together quickly after seeing a post by Andrej Karpathy about LLM knowledge bases, which matched closely with what I’d been building.
Some people have already started trying it and opening PRs, which has been encouraging (got 374 stars in 2 days :] )
If useful:
Waitlist for a hosted version: https://runcabinet.com/waitlist
Discord (small, but growing): https://discord.gg/rxd8BYnN
Would really appreciate feedback:
does this “KB + agents” model make sense?
what would you expect from a system like this?
where does this fall apart?
Happy to answer anything.
Hila

value: Show HN: Cabinet – Kb+LLM (Like Paperclip+Obsidian)

author: Hilash


value:
Hi HN,
I had a few days during the easter break to finish up a long standing project I had in mind for my solidity development: a cli based debugger and tracer.
I used truffle-debug a lot, but the whole project got sunset (and was painfully slow anyways, but thats a different story). I was never into hardhat, but I really like foundry as a successor. I always missed a properly formatted tracer and debugger like we know it from tenderly, but cli based, with local, text based outputs.
I wanted something a human and an LLM can use. So, I sat down and I wired up foundry into a tx replay with revm, also all in rust, same style as foundry itself. If you use foundry then soldebug will be just as easy to use.
Anyways, its a first version, but maybe its also helpful for others. If you find it useful (or not), let me know, or generally, any feedback very welcome.

value: Show HN: A Solidity CLI Tracer and Debugger


value: andreamonaco

value: Show HN: A Common Lisp implementation in development

author: andreamonaco


value:
Hi HN, this is my first Show HN submission.
I've been thinking about how product development will change with AI. The earliest stages of product development have so much ambiguity. Because code was costly and expensive, we spent a lot of time writing specs and doing user research.
I thought I'd try an experiment after (a) seeing advancements around evaluation systems especially for UX (b) realizing that AI can create a reasonably good enrichment of a persona/end-user (c) seeing karpathy's autoresearch project.
Autocrit is a pi extension. Start the pi harness and run the autocrit skill. It will ask you for a high-level app idea, and a definition of the target user. Autocrit will create a persona definition, has that persona create evaluation tasks, and then starts a loop where a coding agent builds a prototype, and a persona agent will try to use it in a real browser. They will judge it based on the tasks, giving scores and verbatim feedback. The coding agent creates a plan to fix things, keeps improvements, reverts bad ideas, etc. The loop runs overnight.
The goal is to get a better understanding of where to take the product at an early stage e.g. paper prototypes, before actually starting to build the product. The evaluation loop of prototyping and getting feedback is automated here, but humans provide the definition of the persona, app idea / product goals, and hypotheses that need validation.

value: Show HN: Autocrit – an agent loop that builds and tests web prototypes


value: jarredkenny

value:
I've been a tmux user for years. When I started running 5-10 Claude Code sessions in parallel, I tried the tools that are out there: Conductor, cmux, the GUI orchestrators. None of them felt right. They either wanted me to leave tmux entirely for a 100MB+ Electron app with its own editor and Git workflow, or they were thin wrappers that didn't solve the actual problem: I need to parallelize my entire development environment, agents, editors, servers, logs, and keep track of all of it.
So I built jmux. It turns tmux into a parallel development environment. Every session, every agent, every running process, visible and navigable from one terminal. When Claude Code completes a response, an orange flag appears on that session. Switch to it, review the work, move on. No context switching to a different app. No learning a new workflow. It's still tmux underneath.
The key decision was to build on tmux instead of replacing it. My ~/.tmux.conf still works. My neovim setup still works. My keybindings, plugins, prefix key, etc, all of it carries over. jmux just makes it all work at scale.
What it does:
- Run Claude Code, Codex, aider. Any agent, directly, in parallel
- Attention flags. Know the moment an agent finishes without watching every pane
- Instant switching between sessions (Ctrl-Shift-Up/Down, no prefix key)
- Auto-groups sessions by project and git branch
- Works with your existing tmux config, editor, and tools
- No SDK, no API wrappers. First-party tools, no middleman.
What it doesn't do:
- No built-in editor (I use neovim btw)
- No built-in Git (use yours)
- No agent protocol/wrapper (run them directly in the terminal)
~1800 lines of TypeScript, ~0.3 MB installed. MIT licensed.
Landing page: https://jmux.build
Github: https://github.com/jarredkenny/jmux

value: Show HN: jmux – tmux-based development environment for humans and coding agents

author: jarredkenny


value: srodriguezp

value:
A prompt tuned for Llama 3 often degrades on Mistral or Qwen — same task, different behavioral surface. Identa automates the recalibration.
It implements two things from the PromptBridge paper (arXiv:2512.01420):
A transfer engine that learns a mapping between model behaviors using source/target prompt pairs
A MAP-RPE evolutionary loop that iteratively improves candidates against a scoring function until behavioral parity is reached
Works fully local via Ollama. Also supports OpenRouter for cross-hosted runs. No telemetry, no cloud dependency.
Built with Python, Typer, Pydantic.
Happy to go deep on the calibration algorithm or the tradeoffs in the scoring design.
https://github.com/shepax/identa-agent

value: Show HN: Identa – CLI to calibrate prompts across local LLMs

author: srodriguezp


value: itay-maman

value: Show HN: Regression-dog – A 20-line skill that reviews your code for regressions

author: itay-maman


value: waitlist is open!

value: Show HN: Imladri – Cryptographic enforcement and semantic monitoring for your AI

story_text: waitlist is open!


value: prithsr

value:
(Started working on this 11 months ago, HN comment from 8 ago!: https://news.ycombinator.com/item?id=44702833#44711006)
Inspired by my wife yelling "YARDSARD" every time we drive past a yard sale sign (and us having way too many knickknacks at home that I'm trying to get rid of): YardSard is a simple inventory tool built for yard/garage/estate/etc sales. This is my first non-pivot-or-quit app launch, & I've tried really hard to make it a useful experience for when someone actually walks up to you and is ready to buy your old GameCube game or t-shirt.
To keep this short: YardSard lets you create multiple sale "events", categories, items, etc. You can link external payment app usernames to make it easy for sellers to scan auto-generated QR codes that pre-fill item name/price/description on their end (this app doesn't handle any of the actual transactions between you + buyer), post-sale analytics.
There are 3 tiers. Guest (no account needed, local-first, local-only, slightly limited usage ["try before you commit" type thing]), Free (account via Apple/Google -- generous usage; unlimited items, events, etc.), and Premium (power user: cloud sync between multiple devices in real-time, backups, advanced exports, restoring deleted items/categories).
That said: feature I'm so incredibly excited about launching this week is the ability to find YardSards near you (https://ibb.co/yFLYg5fD), (https://ibb.co/cX81mdHZ), allowing any app user to 'find' your publicly listed event (listing your event requires a premium subscription, and is entirely optional).
Tried to keep this short, sorry for the long text. I'm just over the moon about finally launching something I've worked so hard on, for such a long time. I have so many more plans for this that I'm so excited to work on. If you made it this far, thank you.
Happy YardSarding!

value: Show HN: YardSard – Inventory Management

author: prithsr


value: jhyolm

value: Show HN: Stablemount, a response to EmDash, a prototype for a future CMS

author: jhyolm


value: boratanrikulu

value: Show HN: Gecit – DPI bypass using eBPF sock_ops, no proxy or VPN

author: boratanrikulu


value: thip

value: Show HN: Simulating a Glowing Fireplace with an RP2040

author: thip


value: jazzen

value: Show HN: VibeAround – Talk to Claude Code from Telegram and Hand over Sessions

author: jazzen


value: nkorai

value:
TLDR; the interactive demo here can give you broad strokes of what it does  and how it does it: https://justworkflowit.com/platform/organizations/de000000-0...
Why did I build this: over the years any time I've had an idea for a product, I dread building the same not so trivial core components for it over and over again, especially the reliability and scaling bits on the backend. I want to focus on building the parts of my product that make it unique and differentiate it, not build a generic job running infrastructure for the 30th time - inb4 "99% of the time you don't need a generic job running infra" but I end up building one anyway so what can you do.
So I built JustWorkflowIt, a platform that handles all of the core bits I kept rebuilding like infrastructure level retries, timeouts, recovering from failures in the middle of a job so I don't waste $$ and time re-running the job from scratch, versioned job flows with tagging capabilities, the ability to define branching logic and compose different system components on the fly via a schema enforced JSON specification.
Then on top of this core job running system I've built a marketplace layer, so anyone can publish a workflow they've built for use by others with metered usage and monetization capabilities. One of my early tag lines to explain this to people was imagine being able to monetize every GitHub repo you own" but I'm still workshopping that. The marketplace workflows don't have to be limited to your conventional integrations like Jira, Notion, Linear, Slack (although those are available) they can also be for for static code or infrastructure components that interact with APIs or database e.g. there are idempotency and circuit breaker check/record workflows.
So anyway I've been building this in all the ways startup advisors tell you not to build stuff i.e. I didn't start with product market fit, didn't do customer interviews prior to building, did not start with a basic landing page for sign ups, my MVP has a pretty big footprint etc. I felt like to actually show value in this I did have to actually build it out significantly and I've been using it to run a friends business backend.
Try out the interactive demo on the website please please please please! Remember I'm just a lil guy on the other side of this post, please be gentle with me.

value: Show HN: JustWorkflowIt, workflow orchestration platform plus code marketplace

author: nkorai


value: ryanisnan

value:
I got tired of not having a good solution for storing pics/vids on my iPhone, that weren't a part of the regular Photos ecosystem.
Existing options are built for the mass-market, but I wanted to be able to control where I stored my data, and I wanted to ensure that I was using client-side encryption.
So I built one, would love some feedback. If you're interested in trying it out (free for my first users if you don't mind giving me some feedback), hit me up.
First round of features are:

  - Configure your own storage backend that _you_ control (S3, GDrive, iCloud)
  - Client-side encryption (AES-256-GCM with PBKDF2)
  - Pin, auto-locking, metadata stripping, blur-when-in-background, delete-on-import
  - Zero telemetry, zero tracking, zero outbound connectivity except to talk to your configured storage system

ryanisnan@gmail.com

value: Show HN: Media Den – Photo/video app with client-side encryption and your cloud

author: ryanisnan


value: ieuanking

value:
Hi HN,
We built Ubik Studio because in professional research settings, or fields where accurate citation is required, AI tools kinda flop. Models hallucinate citations with total confidence and you are locked into one provider. Multi-hop tasks degrade in quality. Context engines fail on file-based work. And without step-by-step approval flows, humans now spend more time verifying AI work than doing the work itself, this is super strange.
We really believe that a successful AI use requires expert-level human judgment and verification. Researchers would rather work slower with certainty than fast and wrong.
Since we started building Ubik 2 years ago, we've focused on an assistive, human-in-the-loop design. We're model-agnostic and built-ready for the near future where local models run effectively on personal computers. We've spent all our research effort on the hard problems: multi-hop reasoning across complex tasks that require gathering sources, maintaining file context, and generating text with accurate evidence attribution. We've built a context engine and citation engine that our agents use to cite accurately and cross-analyze documents without hallucination across models.
Our HITL-AI design gives you control, transparency, and capabilities that mainstream AI tools lack. Our current users are professionals, researchers, and grad students doing work where accuracy and attribution are non-negotiable. Ubik Studio delivers a Cursor-like experience for professional researchers who struggle to integrate tools like Claude, ChatGPT, or NotebookLM into their high-level workflows.
We would love and appreciate your feedback, everything is public we have some paying users (super proud), but ofc we are always learning <3
https://www.ubik.studio/download

value: Show HN: Built a model-agnostic, desktop-native, research studio for local files

author: ieuanking


value: karimf

value: Show HN: Real-time AI (audio/video in, voice out) on an M3 Pro with Gemma E2B

author: karimf


value: joshkurz

value: A dad joke website where you can rate random dad jokes, 1-5 groans. Sourced from 4 different places, all cited, all categorized, and ranked by top voted.<p>Help me create the worlds best dadabase!

value: Show HN: A Dad Joke Website

author: joshkurz

title: Show HN: A Dad Joke Website


value:
Hey HN,
I started my career as a finance manager, transitioned into product management, and now I’m building my own products.
Back in my finance days, while managing a £6M budget, I uncovered a £15k leak hiding in plain sight: FX fees.
Today, I see solo founders making the exact same mistake. I realised most founders are quietly losing 2-5% of their revenue to what I call the Lazy Tax:
- Stripe's ~2% auto-conversion fee on inbound revenue,
- plus their local bank's ~3% spread when paying for global SaaS tools (AWS, Claude, Ads).
So I built FixMyFX to show founders their exact leak and how to fix it (using multi-currency accounts to achieve a zero FX leak setup).
Initially, I had Claude build this in React. Realised a simple calculator shouldn't need a 150kb payload and a complex build process. Threw the React code away and rebuilt it as a single lightweight HTML file using Alpine.js and Tailwind.
It's completely free and ungated. I hope it helps you keep a bit more of your hard-earned revenue. Would love your feedback.
Tania

value: Show HN: I built a tool to show how much ARR you lose to FX fees


value:
Hey!
I accumulate a lot of PDFs that I want to read, but never get back to them, and have no way of organizing them, so I built Elephant Folio.
Elephant Folio will organize your PDFs, suggest better filenames, index them and tag them; all on-device. Additionally, it features a Safari extension, so you can import PDFs you find from HN straight into Elephant Folio's library, or anywhere else you get your PDFs.
Let me know what you think!

value: Show HN: macOS PDF Organizer Using Apple Intelligence


value:
I have build couple of OSS, bloat free tools for everyone to use.
I saw this kind a service that is infested with cookies, accounts etc, so build clean open source client side tool.
- runs on browser
- can clean invisible characters
- no backend
- no ads
- no cookie
- no tracking
- no AI assistants
Runs at Cloudflare pages.
Domain registered for 10 years.
As build on vanilla HTML/JS/CSS, this is very maintenance free to keep running.
Github: https://github.com/timoheimonen/diffvoid

value: Show HN: Diffvoid.com – private, open source client side text comparison tool


value: inerte

value:
I've been working on a new programming language for AI agents. I would love your input on what makes programming languages good for AI agents, especially syntax, compiler, and tooling that could help AI agents write code.
What makes Sigil good for coding agents?
I've turned conventions into compiler rules whenever possible. The compiler owns the canonical printer and every AST has one accepted textual representation. For almost every syntax feature I tried to save tokens.
Order and naming conventions are enforced. No more "I think this argument is important so it should come first." Most things are alphabetical. Declarations are categorized and ordered alphabetically; parameters, effects, and record fields are alphabetical too. Types are UpperCamelCase. Everything else is lowerCamelCase, including file names.
No nulls. No undefined.
Bidirectional type checking.
No shadowing.
Fat stdlib (still in progress).
`sigil debug` supports replay, stepping, watches, and breakpoints.
`sigil inspect` lets coding agents query the compiler directly, including proof surfaces.
Solver-backed refinements and contracts. Different languages already choose different numeric surfaces: byte, short, smallint, unsigned integers, etc. Sigil pushes that one step further: domain constraints can also define types. `where` lets a named type carry a predicate, and `requires` / `ensures` let functions carry proof obligations across call boundaries.
Here is a contrived example from the roguelite:

  t InventoryCount=Int where value≥0

  λspendArrow(arrows:InventoryCount)=>InventoryCount
  requires arrows>0
  ensures result≥0
  =arrows-1

Under the hood this is backed by Z3: https://github.com/z3prover/z3 But the surface stays ordinary Sigil syntax. There are no proof scripts and no user-facing SMT language.
No imports, rooted references only. In some languages you can import code and have name clashes, so there are many ways to specify imports. Sigil eliminates all of that by only using rooted references. I think this reduces agent churn because when the model sees a line, it does not have to go hunt for an import statement.
Service dependencies are declared in `src/topology.lib.sigil`, and environment bindings live in `config/<env>.lib.sigil`.
The language has special syntax for tests and they are run in parallel. Every project `src/*.lib.sigil` function must be tested, and if a function can return multiple cases, tests should exercise all of them. "World" is Sigil's model for effects. That is how mocks work: swap one effect for another and make assertions without exercising real external systems.
The compiler toolchain is written in Rust, and Sigil outputs to TypeScript, with a Foreign Function Interface to Node.js. See some small projects here https://inerte.github.io/sigil/projects/ - the Flashcards is useful to learn about Sigil features https://inerte.github.io/sigil/projects/sigil-flashcards/dem...
Caveat: I did NOT type a single line of code for the compiler toolchain. It was all generated with Claude Code and Codex. I run both with permissions dangerously skipped. This actual post I hand crafted every word.
There is also a toy roguelite written in Sigil. It is a work in progress, but it is proof that Sigil can support nontrivial project code. You can play with `pnpm sigil:run:roguelike`.
Repository: https://github.com/inerte/sigil
Website: https://inerte.github.io/sigil/
And I would love if you can find ways to lock down LLM / user programs even more. In Sigil, there should be only one way to do anything.

value: Show HN: Sigil – A new programming language for AI agents

author: inerte


value: brynary

value:
Hi — I created Fabro to free myself from supervising a fleet of Claude Code tabs running in a REPL (read-eval-prompt-loop). REPLs are great for exploration, but once I know what I need I want to be able to walk away while the agents get it done.
(Before building Fabro, I looked for something off the shelf but couldn't find anything that was open source, hype-free, and full featured / ready.)
Fabro helps experienced engineers evolve towards a “dark” software factory where average time between disengagements increases. It’s easy to throw a Ralph shell script around Claude, but as runtime increases the chance of high quality output declines.
Fabro adds the last mile of guardrails to make it actually work: combining deterministic workflows of agents, commands like linters and test suites, with strategically applied human steering. (Similar to the Stripe's Minions.)
Fabro is multi-model and makes it easy to combine Claude, Gemini, and GPT in ensemble reviews — or delegate coding to faster and cheaper models like Kimi.
Software factories work best when combined with cloud VMs (like Daytona) so you get infinitely scalable, secure sandboxes that can run 24/7 and accessible via SSH, VS Code, and preview links as needed. This can be a bit of a pain to set up today and Fabro tries to make it as easy as Docker.
The closest analog to Fabro today would be something like Factory.ai Droids. However, I think it’s critical for engineers to own their own toolchain and so Fabro is open source (MIT) so you can fork it and customize it anytime.
The project is highly active and I’d love any feedback or feature requests. I’ll be on here answering questions today.
(Had posted this a week or so, hoping to engage in some conversation.)
-Bryan

value: Show HN: Fabro – open-source dark software factory

author: brynary


value: Show HN: A branching notebook runtime for AI and humans(written in Rust)


value: oleksg

value:
https://github.com/OlexG/finclaw
^ repo if anyone wants to contribute.
I realized that sometimes I'm pretty good at making random guesses about the future. (I.E, I think OpenAI will beat Anthropic in the short term, etc...)
However, I'm bad at converting these guesses into actual market plays I can profit from.
As such, I wanted to make a tool that connects to the right APIs and launches a swarm of agent experts to generate related plays based on your prediction.
The very first super shitty V0 MPV just has Polymarket/Kalshi bets, but I will be adding a more complex agentic harness, api sources for stocks/ETFs/options.
In the future, I'd imagine this can give you recs for all those, with some degree of certainty.
Ideally, this allows lazy but intelligent retail investors to make money.
For now, the project is in open-source format; either run it yourself or send me an email at oleksandr.gorpynich@gmail.com if you'd be interested in using this commercially once I get further down the line.

value: Show HN: Turn any prediction into ranked Kalshi/Polymarket trades [video]

author: oleksg


value: bozkan

value: I had no clue what to offer IG/Tiktok creators for collabs and their offers were too high. That's why built a thing that turns IG profile name into suggested pricing with key metrics and suggestions, looking forward to hearing your feedback!

value: Show HN: Enter an Instagram/TikTok handle, get a data-backed price for collab

author: bozkan


value: omarroth

value: Show HN: Doubletake – AirPlay Sender Implementation for Linux (X11 and Wayland)

author: omarroth


value: BleedingXiko

value:
RAGOT is the frontend runtime extracted from a larger project I’ve been building (a real time, state heavy media server).
I ended up writing my own runtime because existing frameworks didn’t handle lifecycle, state ownership, and long running UI cleanly enough for that use case.
It focuses on direct DOM ownership, explicit lifecycle control, and predictable cleanup instead of a virtual DOM.
Open sourcing it to see if this approach resonates with others building similar systems.
There’s an interactive lab in the repo, but here’s a direct link:
https://bleedingxiko.github.io/RAGOT/lab/

value: Show HN: Ragot – a front end runtime built around lifecycle and ownership

author: BleedingXiko


value: Enjoyooor

value:
Gx HN,
I built SharpSkill in order to help the community increasing their success rate in tech interviews.
Cheatsheet availables for several IT languages.

value: Show HN: SharpSkill – I built a Freemium tool with Cheatsheet to crush tech itw

author: Enjoyooor


value: jorijn

value:
Hey HN.
Long-time lurker (2017) here, but finally something to post about.
I've been building an iOS companion app for Plausible over the past few months. There are some great ones out there already, but I have always wanted to try building an app first-hand. I'm quite proud of the end result, so I wanted to share it online to see if people would be interested in using it.
In case you don't know: Plausible Analytics (https://plausible.io/) is a privacy-friendly alternative to Google Analytics. You can self-host it or choose to use their SaaS platform.
I chose Plausible Analytics because of their business philosophy: Privacy should come first. Arbory is built to connect directly to Plausible (either SaaS or self-hosted).
Features include:
- iOS Liquid Glass-native dashboard displaying most of your website analytics.
- Tap to filter data, just like Plausible itself.
- Notifications for traffic spikes and drops, the algorithm lives fully on your phone. (I'm quite proud of this one in particular)
- Full suite of widgets for your lock & home screen.
There are no subscriptions involved. You'll get the full dashboard and filtering for one site for free. There's a one-time unlock for $14.99 for the rest, if desired.
I'll lurk around here to answer any questions you might have. Any feedback is appreciated.
More information:
- Website: https://arbory.io
- Privacy Policy: https://arbory.io/privacy
- App Store Link: https://apps.apple.com/app/id6760103214
Full disclosure (some people find this important): AI helped me build parts of this, but I've been a software engineer for 15+ years. Happy to answer any technical questions.

value: Show HN: Arbory – Native iOS dashboard and widgets for Plausible Analytics

author: jorijn


value: debasishbarai

value:
Hi,
I am Debasish from India. I am passionate about building softwares. I started coding long ago around 2015 when android apps were built only Java. Kotlin was not a thing then. I built railify android app. That was the first time I built and shipped one product to the world. The journey did not stop after that. I built several other products. All of these are my side projects. I am not a software developer by profession. I am an electrical engineer working in a power plant in India. However, as I grew my product base, I literally own so many domains which are all related to my products. All have there mails setup to connect with the relevant ICPs, answering questions of users, solving doubts and also informing the users about any new release of the products. Maintaining all these domains and their email Ids, honestly speaking was difficult. So I started thinking about building something to solve this issue in particular. I built mailmark for this. Mailmark helps you add your domains i.e. abc.com, setup different mailboxes i.e. sales@abc.com, founder@abc.com, marketing@abc.com, updates@abc.com etc. All of these domains and mailboxes are accessible from the same unified UI similar to Gmail or Zoho. I also added one lightweight tracking system to the mails sent throughthis platform, which will show the status of the mails like delivered, opened, not yet delivered or rejected. Also, as it is focused on bulk mails, to the users, it works like email campaigns, similar to Gmass, where all the mails to recipients, will be individual separate mails. I can track all the mails statuses from a single window like the deliveribility status how many mails are delivered, opened etc. I have also built a developer feature where I can send emails programmatically with a key, similar to Resend. There is a lot more there in the product which I will definately like to discuss.
Please do checkout the product. Here is the link: https://www.mailmark.dev
Happy to answer questions here.

value: Show HN: MailMark – Cold email tool where you own your domain and mailboxes

author: debasishbarai


value: mcantillon

value: Show HN: RPLY - one Inbox for iMessage, WhatsApp, Slack, and Gmail on macOS

author: mcantillon


value: michidk

value: Show HN: Orcastrate – Sync GitHub Actions workflows across repos via templates

author: michidk


value: thebababak

value:
As someone who loves both coding and language learning (I'm learning Japanese right now), I always wished there was a free, open-source tool for learning Japanese, just like Monkeytype in the typing community.
Here's the main selling point: I added a gazillion different color themes, fonts and other crazy customization options, inspired directly by Monkeytype. Also, I made the app resemble Duolingo, as that's what I'm using to learn Japanese at the moment and it's what a lot of language learners are already familiar with.
Miraculously, people loved the idea, and the project even managed to somehow hit 1k stars on GitHub now. Now, I'm looking to continue working on the project to see where I can take it next.
Back in January, I even applied to Vercel's open-source software sponsorship program as a joke. I didn't seriously expect to win, and did it more out of curiosity.
Lo and behold, yesterday I woke up to an email saying the app has been accepted into Vercel's Winter cohort. Crazy!
Anyway. Why am I doing all this?
Because I'm a filthy weeb.
どうもありがとうございます

value: Show HN: I made a cute, open-source Japanese learning app inspired by Monkeytype

author: thebababak


value:
POINTS is the inverse of a game (called Green Globs) that I used to play in elementary school, on my math teacher's Apple Macintosh II computers (he had several scattered around the room).
A short writeup on POINTS is now available on my blog. This small web app finds elegant algebraic expressions that approximately intersect points that you've selected.
https://sean-reid.github.io/blog/points.html

value: Show HN: Points- find simple algebraic curves in the browser


value: zackkitzmiller

value:
I write a lot in Markdown. Notes, ideas, drafts, half-finished thoughts, lots of code. Lots and lots of code. One thing that has always annoyed me is there's nowhere to just slap a .md file, share it, and have it look pretty.
Most platforms either try to turn writing into a social network, a CMS, or some AI something or other. Sometimes you just want to take a Markdown file and put it on the internet without ceremony.
The paid plans have a couple of features like encryption at rest, password protection, launch and expiry dates, etc. It's probably got a few bugs, so let me know what you think or find.

value: Show HN: A simple sharing platform for Markdown Files

author: zackkitzmiller


value: zachdotai

value:
We built Adversarial Cost to Exploit (ACE), a benchmark that measures the token expenditure an autonomous adversary must invest to breach an LLM agent. Instead of binary pass/fail, ACE quantifies adversarial effort in dollars, enabling game-theoretic analysis of when an attack is economically rational.
We tested six budget-tier models (Gemini Flash-Lite, DeepSeek v3.2, Mistral Small 4, Grok 4.1 Fast, GPT-5.4 Nano, Claude Haiku 4.5) with identical agent configs and an autonomous red-teaming attacker.
Haiku 4.5 was an order of magnitude harder to break than every other model; $10.21 mean adversarial cost versus $1.15 for the next most resistant (GPT-5.4 Nano). The remaining four all fell below $1.
This is early work and we know the methodology is still going to evolve. We would love nothing more than feedback from the community as we iterate on this.

value: Show HN: ACE – A dynamic benchmark measuring the cost to break AI agents

author: zachdotai


value: larsmoa

value:
The other day I googled "Where is Artemis" expecting to find a tracker showing me the position, but instead getting results from news articles without live data. I eventually found the NASA tracker (https://www.nasa.gov/missions/artemis-ii/arow/) and https://artemislivetracker.com/, but neither is optimized for mobile and frankly I found them both underwhelming.
The domain (whereisartemis.com) was available and I thought "someone should use that", bought the domain and got started. Hopefully, this is something that can be extended for future Artemis missions and help build engagement for the Artemis program and space travel in general :)
The tracker includes:
- Real-time 3D scene with toggleable camera views (top-down or free orbit),
- Live telemetry: Distance from Earth/Moon, current speed etc.
- Live video from NASA
- Mission schedule with countdowns to upcoming events (lunar flyby, splashdown, etc.)
- Mission coverage with links to NASA articles
- Mobile and desktop support
How it works under the hood:
- Live position and trajectory data is pulled directly from the NASA/JPL Horizons API.
- Built with Next.js, React Three Fiber/ThreeJS, and Tailwind CSS.
Github: https://github.com/larsmoa/whereisartemis2 (feel free to add issues with suggestions :) )

value: Show HN: Where Is Artemis?

author: larsmoa

title: Show HN: Where Is Artemis?


value: nodesocket

value: Show HN: Missile Intercept SIM in Pure HTML/Canvas/JS

author: nodesocket


value: mkagenius

value:
I thought it would be fun to see how I have been feeling while talking to claude code.
https://github.com/instavm/claude-cloud
I welcome contributions and suggestions.
p.s. Nothing is uploaded. All local.

value: Show HN: See How You Talk to Claude Code

author: mkagenius


value: rasengan

value:
Go implementation of mosh (mobile shell) both client and server and wire-compatible with the core C implementation.
The full mosh protocol is implemented including but not limited to AES-128-OCB3, SSP transport with sequencing and retransmission, datagram fragmentation, protobuf state sync, local echo prediction, etc.
It compiles to WASM, which is how we run mosh in the browser at UnixShells.com (WebTransport (HTTP/3) carries the datagrams instead of UDP). This is how things feel instant, despite being wherever you are.
https://github.com/unixshells/mosh-go

value: Show HN: Pure Go mosh client, server, and WASM build for the browser

author: rasengan


value: Show HN: Runfra – Decentralized GPU cluster designed for bulk generation


value: Show HN: TermHub – Open-source terminal control gateway built for AI Agents


value: replete

value: Show HN: Grug – Claude Code Skill Inspired by the Grug Brained Developer

author: replete


value: hudsongr

value: Show HN: Mdarena – Benchmark your Claude.md against your own PRs

author: hudsongr


value: kcaldas

value:
I use Coding tools daily and got tired of it describing code by line numbers. So I built an MCP server that lets the agent control my Neovim instance instead: opening files, highlighting lines, adding annotations, splitting views.
The tool I actually wanted was "walkthrough mode": I ask the agent to walk me through a PR, it opens each file, highlights what matters, explains briefly, and waits for my questions. Turns code review into pair programming where the agent points at the screen.
It also works passively — while the agent investigates a bug or reads code, my Neovim follows along so I can see what it's looking at.
Built with pynvim, talks to Neovim via --listen socket. Works with any MCP client.
https://github.com/kcaldas/vim-navigator

value: Show HN: Vim Navigator – MCP server that lets AI agents drive your Neovim

author: kcaldas


value: mohshomis

value: Show HN: Modo – I built an open-source alternative to Kiro, Cursor, and Windsurf

author: mohshomis


value: epicwynn

value: Show HN: Specialty Coffee Discovery Platform

author: epicwynn


value: ikessler

value:
Gemma Gem is a Chrome extension that loads Google's Gemma 4 (2B) through WebGPU in an offscreen document and gives it tools to interact with any webpage: read content, take screenshots, click elements, type text, scroll, and run JavaScript.
You get a small chat overlay on every page. Ask it about the page and it (usually) figures out which tools to call. It has a thinking mode that shows chain-of-thought reasoning as it works.
It's a 2B model in a browser. It works for simple page questions and running JavaScript, but multi-step tool chains are unreliable and it sometimes ignores its tools entirely. The agent loop has zero external dependencies and can be extracted as a standalone library if anyone wants to experiment with it.

value: Show HN: Gemma Gem – AI model embedded in a browser – no API keys, no cloud

author: ikessler


value: nevernothing

value: Show HN: I made a YouTube search form with advanced filters

author: nevernothing


value: armanified

value: Built a ~9M param LLM from scratch to understand how they actually work. Vanilla transformer, 60K synthetic conversations, ~130 lines of PyTorch. Trains in 5 min on a free Colab T4. The fish thinks the meaning of life is food.<p>Fork it and swap the personality for your own character.

value: Show HN: I built a tiny LLM to demystify how language models work

author: armanified


value: oleksg

value:
You can correlate open internship positions on the website to questions scraped for those jobs.
Pretty simple, but haven't seen a fully compiled list like this anywhere.

value: Show HN: I scraped thousands of recent interview questions for SWE internships

author: oleksg


value:
I originally took all domains crawled by CommonCrawl and made my own private tool for exploring the public web.
I've used it to get some sense/intuition for what's being made by others. It's helped me avoid proposing the 100th agentic marketing SaaS, when brainstorming with friends :)
So thought others might see the fun in exploring websites this way.
I've tried my best to circumvent the Cookie popups for the pictures, and have removed most parked domains, access denied, bad gateway etc.
I've also filtered out subdomains, as there's too much noise.
Lmk if there's anything else about it you'd like to know.
Only the frontend and two basic pg tables have been made specifically for this project. The rest have been part of other hobby projects, e.g. parsing CC indexes (and WET data), taking screenshots, saving and keeping it all updated etc.

value: Show HN: hot or not for .ai websites

title: Show HN: hot or not for .ai websites


value: I have been working on Skilleton, a minimal CLI to install versioned skill definition files, just like the other popular tools.<p>I've built this tool as a lighter and privacy-first tool (with no telemetry or analytics) to install and lock SKILL.md files on certain commits, and share them with my projects contributors, just like package.json/package-lock.json files

value: Show HN: Skilleton – Minimal tool for managing versioned SKILL.md definitions


value: gimlids

value: I sampled CSS hex colors out of 10 open weight LLMs to build each model's favorite colors palette, or its flag... Interesting results?

value: Show HN: LLMs' Favorite Colors

author: gimlids

title: Show HN: LLMs' Favorite Colors


value: carushow

value:
I’m launching the Prediction Hunt API because I got tired of managing five different WebSocket connections and manually mapping event IDs across fragmented markets. It’s designed to be a unified infra layer for prediction markets, solving the "event matching" problem so you don't have to guess if a Polymarket contract and a Kalshi trade represent the same real-world outcome.
Here’s our feature offering:
-Real-Time Data with Event Matching: We make it trivial for you to pull real-time prices from 5 different prediction markets (and counting)
-Live Orderbook Proxy: We’ve wrapped our internal fetchers into a unified orderbook endpoint. It proxies the full bid/ask ladder in real-time from the source platforms.
We offer a generous free API tier (no expiration date) so you can see how much easier it is to query prediction markets with a single, unified API.
I’m aiming for this to be the best, most robust prediction market unified API out there - an alternative to Dome (now that it's been acquired). So please, let us know what you think and what features you'd want to see next!

value: Show HN: Prediction Hunt API – A unified layer for Polymarket, Kalshi, and more

author: carushow


value: vednig

value: Show HN: OnlyTech – For the Friday Deployments and More

author: vednig


value: krtbgb

value: Show HN: Dot-Globe – React component that renders NASA night-light data

author: krtbgb


value: rogaos

value: Show HN: jsoncompat – a library to detect/fuzz breaking changes in JSON schemas

author: rogaos


value: qhoc

value: Show HN: The easiest way to generate AI stickers then get them in the mail

author: qhoc


value: lucasastorian

value: Show HN: LLM Wiki – Open-Source Implementation of Karpathy's LLM Wiki

author: lucasastorian


value: nerdcube

value:
Carom is a free daily puzzle game I made where you slide pieces through a grid to reach the goal space. Pieces slide until their movement is blocked, so the challenge is in utilizing the walls and other blocker pieces to your advantage.
I’ve had the idea for this game for years, but Claude Code and some time off of work have given me the tools and time to finally build it out — I’d appreciate anyone checking it out and giving any feedback!
https://www.nerdcube.games/carom

value: Show HN: I made a free daily puzzle game

author: nerdcube


value: vektormemory

value: If interested in trying, reach out to us on hello@vektormemory for testing.

value: Show HN: Magma Memory Claude Browser cloaking tool

author: vektormemory


value: agentina

value: Show HN: Not a CLI, Toward a New Agent-Computer Interaction Model

author: agentina


value: dejuknow

value:
As a PM, I never write specs or stories anymore. AI generates, I review/provide feedback, AI updates, then I handover to devs (human or agents) to implement. But the feedback loop is clunky: difficult to read raw markdown files, annotate, and iterate.
md-redline lets you open a markdown file, highlight rendered text, and leave inline comments. The comments are stored as HTML markers directly in the .md file. They're invisible in GitHub and VS Code preview but agents can read them with a plain file read.
The workflow: open a spec, leave feedback, copy the hand-off prompt, paste it into your agent. The agent edits the file, addresses the comments, and removes the markers. You review in diff view.
Runs locally. No account, no cloud, no database. The markdown file stays the source of truth.
npx md-redline /path/to/spec.md
https://github.com/dejuknow/md-redline

value: Show HN: md-redline - inline review comments for markdown, readable by AI agents

author: dejuknow


value: scalefirst

value: Working on a schema for joining SEC fund filings across documents. The core problem: these filings describe the same fund in different formats and no standard exists for cross-document semantic queries.<p>Interested in feedback on the ontology design — especially from anyone working with fund data, XBRL, or FIBO.

value: Show HN: Open-source ontology – SEC fund filings

author: scalefirst


value: chrismeurer

value: Show HN: Multi-agent coding assistant with a sandboxed Rust execution engine

author: chrismeurer


value: Show HN: I built a tool to deploy vibe-coded apps to production in 1 minute


value:
HTML-to-Markdown converters produce clean, readable content for both humans and LLMs — but the DOM structure is lost along the way. You can always feed Markdown to an LLM to extract structured information, but that costs tokens on every page, every time.
What if the LLM could also see where each piece of content lives in the DOM? Then it can generate robust scraping code — stable selectors and XPaths that run without any LLM in the loop, saving tokens and improving accuracy on long or repetitive pages.
Scrapedown does exactly this: it converts HTML to Markdown and annotates each element with its CSS selector and/or XPath, so an LLM can produce precise, reusable scraper code in one shot.

value: Show HN: HTML to Markdown with CSS selector & XPath annotations for LLM Scraper


value: cloudkj

value:
I was looking through some of my past personal projects tinkering with reinforcement learning, and noticed that the REST/HTTP API for the OpenAI gym available at the time is no longer supported. The API was pretty useful back then since most of ML and deep learning hadn't quite stabilized on the various Python libraries today.
gymnasium-http-api is an attempt at bringing back the same type of language-agnostic support. It mostly wraps the forked and supported Gymnasium library, with some endpoints specifically for making it easier to render and visualize the training and learning process.
Check out the README for some examples. Hope others find it useful!

value: Show HN: REST API for Gymnasium (fka OpenAI Gym) reinforcement learning library

author: cloudkj


value: indraneelpatil

value: Show HN: We built a camera only robot vacuum for less than $300 (well almost)

author: indraneelpatil


value: myyke

value:
I’ve been building LLM tooling for a small VC fund and found myself explaining the same mental model over and over to non-technical people around me: how a stateless LLM becomes a chatbot, how tool use works, what an agent is mechanically, and why context windows shape all of it.
I never found a guide that covered that full chain at the level I wanted, so I wrote one.
It’s nine short chapters, each building on the last. Deliberately simplified: the goal is a useful mental model, not a textbook.
Feedback, corrections, and contributions welcome: github.com/ymyke/aiaiai

value: Show HN: Aiaiai.guide: Plain-English mental model for LLM apps, tools and agents

author: myyke


value: Show HN: Cloclo – open-source multi-agent CLI runtime for 13 LLM providers


value: bevibing

value: Show HN: Let's Turn Your Claude into Socrates

author: bevibing


value: Show HN: WebGPU LLM inference comprehensive benchmark


value: mantyx

value: Show HN: Mantyx – Agent Control Plane with Centralized MCP Management

author: mantyx


value: Show HN: I developed a node editor framework using gpui


value: Show HN: Reverse-engineered the FPGA bitstream using Claude Code


value:
Hey HN,
I built Pace, a Claude Connector that lets you connect all your wearables (Garmin, Polar, Whoop, 20+) with Claude.
You connect your devices once and can analyze your data with Claude. No Dashboard needed, just in natural language.
I already use it everyday, especially the visualization tool in Claude makes this really cool to use.
Tools include: overview, sleep, training, activity, samples and trends.
Tech Stack: Python (FastMCP), Google Cloud Run, Google Cloud SQL (PostgreSQL) and Firebase
It is live and free to try (no Claude Pro/MAX Plan needed)..
Would love feedback, especially from people who've built MCP servers or use wearables seriously.

value: Show HN: I just built a MCP Server that connects Claude to all your wearables


value: Show HN: Browser-based EXIF remover – no upload, runs offline via WASM


value: skele

value:
Hey Hackernews,
I have been developing an agentic applications for a year now. And the biggest pain in the ass was debugging.
Thus, I created to create my own tool which includes basic features such as tracing and CLI tool to get started easily.
Also, the biggest concept is to re-call Tools. It is 100% opensource. let's build this together. I am thinking of caches, re-execution and branches. it is welcome to start contributing.

value: Show HN: I built lightweight LLM tracing tool with CLI

author: skele


value: ecosystemj

value:
https://beatdarwin.com
Wordle for animal species

value: Show HN: Beat Darwin

author: ecosystemj

title: Show HN: Beat Darwin


value:
Last week Swyx nerd-sniped me into building an Open-source Dropbox.
Here is Locker: An Open-source Google Drive/box/Dropbox alternative
- Provider agnostic (S3, R2, vercel blob, local)
- BYOB (Bring your own bucket)
- Virtual file system
- QMD Search plugin
Locker is designed to sit on top of your bucket, so you can use whatever provider you like best (Or just use a local disk)
BOYB means you don't have to self-host to use your own bucket, just add your keys via the hosted UI, and you're good to go
Locker itself can act as its own S3 bucket, meaning you can generate Locker keys and use them in other applications to have data saved directly to your locker.

value: Show HN: I built an Open-source Dropbox/Google Drive BOYB(Bring your own bucket)


value: noetron

value: Show HN: Free AI Business Name Generator with Domain Screening

author: noetron


value:
I built Moments to get this game idea out of my head, finally. My original goal was to run on-device models specifically in mobile browsers, but running local vision models directly in phone browsers is still very much too early, so I focused on desktop.
How it works:
- You upload a photo.
- A local vision model running entirely in your browser captions it and picks a prominent object from the image.
- You guess the word just like Wordle.
It uses a very tiny model so it is not very smart https://huggingface.co/onnx-community/Florence-2-base-ft

value: Show HN: Turn photos into Wordle puzzles with AI that runs 100% in your browser


value: ccdale

value: Show HN: Tiny shell aliases for systemctl/journalctl with installable verbs

author: ccdale


value: wolfsir

value:
I’ve created a self-writing book: The Encyclopedia of Agentic Coding Patterns
It continuously researches, writes, and publishes. It reflects on and improves its own process.
It’s both an exposition of agentic coding and a product of it.
It’s the book I wanted but nobody had written.
And it’s what I would use to teach programming in an age where coding is all in English.

value: Show HN: I built a self-writing book on agentic coding

author: wolfsir


value: seyz

value: Show HN: RootCX – I built an open source alternative to "Cursor and Supabase"

author: seyz


value: VictorChanet

value: Show HN: I replaced Google Analytics with my own tool – no cookies, <1KB script

author: VictorChanet


value: gregojaca

value: Lilith Zero is a high-performance security runtime designed to mitigate data exfiltration and unauthorized tool invocation in LLM-based agent systems. By interposing at the transport layer, Lilith Zero enforces security invariants through deterministic policy evaluation and strictly framed execution.<p>Lilith Zero is OS, framework, and language agnostic, providing uniform security primitives across diverse implementation environments.

value: Show HN: Lilith-zero: Ultra-fast, Rust-based security middleware for MCP

author: gregojaca


value:
I'm a first year CS student at Sheffield and built this over the past year because I thought I could do better than Trolley.
Stack: React Native & Typesense for vector search and filtering. An ETL pipeline runs in the background handling scraping and automatic product categorisation using embeddings.
Covers Aldi, Tesco, Sainsbury's, Asda, Morrisons, Waitrose, Iceland, Ocado / M&S and Co-op. Clubcard and Nectar prices included. Sort by price per unit, filter by category and stores near you.
This was fun to make, and I have a lot planned, with some WIP:
- Basket Generation based on entering a shopping list and getting cheapest products for each store, and cheapest collection of stores for the cheapest total shop. Feels quite magical even in dev mode right now
- Local price estimates. Local stores differ from online prices by up to 20% depending on store fascia. I'm thinking to record a basket of goods for each local store and use it to estimate local prices
- Crowdsourced prices. Tricky one, due to running from a cold start. Would be very useful for certain stores without online prices, eg. Lidl.
That's all for now! Hopefully it'll help me get an internship even without traction ^_^

value: Show HN: I built an app for comparing grocery prices across UK supermarkets


value: willgdjones

value: Show HN: Mail Toll – Set a price on your inbox, agents pay USDC to reach you

author: willgdjones


value: kwstx

value: Show HN: I built a self healing semantic layer for any AI agent tool

author: kwstx


value:
Yapit converts PDFs and web pages to audio, with a vision-LLM pipeline that handles math and complex layout instead of garbling them. I built it because I read a lot of papers and content online, but drift off after two paragraphs. Listening while following along keeps me focused and lowers the bar to actually start.
Every TTS tool I tried broke on complex formatting. Papers with math, citations, figure references, page numbers in the middle of sentences. You either get garbled output or you're listening to raw LaTeX.
Yapit converts everything to markdown as a common format. For web pages, defuddle (https://github.com/kepano/defuddle) handles the extraction and strips clutter from web pages, presenting the main article content in a clean, consistent format.
For PDFs, a vision LLM rewrites each page into markdown with annotation tags that separate what you see from what gets read aloud. Math is rendered visually but gets spoken alt text. Citations like "[13]" or "(Schmidhuber, 1970)" are silently displayed. Page numbers and headers are removed entirely.
Both extraction and audio are cached by content hash, so the same content is never processed or synthesized twice.
Self-hosting works with any OpenAI-compatible TTS server (vLLM-Omni, ...) and any OpenAI-compatible vision model for PDF extraction:

  git clone --depth 1 https://github.com/yapit-tts/yapit.git && cd yapit
  cp .env.selfhost.example .env.selfhost
  make self-host

Kokoro TTS also runs in the browser via WebGPU on desktop.
Try it on Attention Is All You Need (all voices cached, no account needed): https://yapit.md/listen/3bde213b-3a5a-465f-9198-be65430b699e...
Or paste any URL:
  https://yapit.md/https://arxiv.org/abs/1810.04805
  https://yapit.md/https://x.com/karpathy/status/2039805659525...
GitHub: https://github.com/yapit-tts/yapit (AGPL-3)

value: Show HN: Yapit – PDF and webpage reader with TTS that doesn't suck


value: petargyurov

value:
Hi HN!
In the last couple of weeks I've been working on Cranki:
Cranki = Crosswords + Anki. (It's a stupid name tbh, haha)
I like doing crosswords in Spanish (to learn vocab) but none of the apps out there allowed me to use my own list of words that I come across. So I built one instead.
It's entirely client-side. No server, no database, no accounts, etc. Your words and stats are stored in local storage.
I built this for myself but let me know if you like it!

value: Show HN: I made a crossword app for language learners

author: petargyurov


value: preyneyv

value: I built a daily Wordle-like game on top of ARC-AGI-3. Each day, you get a new environment with no rules and no instructions. Figure out the goal and beat it in as few actions as possible.

value: Show HN: I turned ARC-AGI-3 into a daily browser game

author: preyneyv


value: neozz

value: ec (easy-conflict) is a 3-way terminal native Git merge conflict resolver. Supports diff3 base comparison, and helps you resolve merge conflicts faster without leaving the terminal.

value: Show HN: Ec – terminal native 3-way Git mergetool

author: neozz


value: convexly

value:
I've gotten to the point in my career where I now make strategic decisions often (hiring, firing, choosing what equipment to go with, etc.), as well as in my personal life where I need to strongly weigh my options for a big purchase or investment. I found a not-so-surprising parallel between the two as these decisions "resolved." Am I making good decisions or am I getting lucky?
Did some research, read some books, and realized I should get in the habit of tracking my decision process. That quickly turned into the idea that formed Convexly.
The landing page is a 10-question calibration quiz where you assign a confidence level to statements drawn from a rotating pool of 100 (working on making the pool larger) and you get a Brier score back instantly. No signup required, and you can share your scores right away.
If you find it interesting, you can create a free account where you can track your decisions with probability estimates, resolve them over time, and get calibration curves that show if you are over/underconfident. From what I've seen so far, users are overconfident when they say they're between 70-90% sure about something.
For the math: Beta-PERT distributions for the payoff modeling, Kelly criterion for the position sizing, signal detection theory for separating skill from randomness.
On the coding side: FastAPI with NumPy/SciPy, frontend in Next.js and Supabase.
So far this has been a solo project of mine. If you want to see all the features use code SHOWHN for 30 days of full access, no credit card required.
Curious if anything about your score surprised you after taking the quiz.

value: Show HN: I built a 2-min quiz that shows you how bad you are at estimating

author: convexly


value:
Lumina is a statically typed, web-native language that compiles to JavaScript and WebAssembly.
It has HM type inference, algebraic types, traits, a reactive UI runtime, a REPL, an LSP, and a browser demo written in Lumina itself. The current demo runs without React and uses a Vite plugin that compiles .lm files directly for the browser.
GitHub: https://github.com/nyigoro/lumina-lang
npm: https://www.npmjs.com/package/lumina-lang
I’d love feedback on the language design, the web-native direction, and the developer experience.

value: Show HN: Lumina – a statically typed web-native language for JavaScript and WASM


value: osepper

value: Show HN: CalcMonte – Monte Carlo simulation for loans and investments

author: osepper


value: grga

value:
I worked on many apps where each customer needs their own branded theme.
The problem is that you can't just shift hue and call it a day. Yellow at 50% lightness looks completely different from blue at 50%.
That's why I built this library to generate perceptually uniform themes. Zero dependencies, runs at runtime, outputs CSS vars, Tailwind tokens, SCSS, or JSON. Ships with presets for shadcn/ui and MUI.
try it out quickly:
npx hextimate "#006677"

value: Show HN: I built a theme engine for white-label apps using OKLCH color science

author: grga


value: philematic

value:
Hey folks!
For starter, I'm a 17+ senior cinematic designer (damn I'm getting old haha) and this tool is a culmination of many years of frustration or missing features or absolutely terrible UI/UX from other tools.
So, I'm surmounting my anxiety of showing personal work and passion project, even after all these years, I'm still struggling on showing my work haha. It's been roughly two years now that I've been hard at work on creating my perfect little export/converting tool that I wish I had in my pocket for all my exporting needs. I've built https://getexpi.app ! It's your run of the mill ffmpeg gui but beautifully wrapped (for once!)
I've packed it with a bunch of features that I use everyday and some more. It started with me just using it and optimizing my workflows to then seeing it's value when my content creator wife asked me for the 9589th time "Which presets should I use? This is so f*cking confusing!". So I started getting Expi in a very user friendly mode at the same time as being able to deliver for high performance user like me.
Anw, I'm absolutely not looking to make bank with this, my absolute dream with Expi and the joy I get out of it is optimizing and developing tools for people.
If you have any questions, or want new features (Please please!) let me know, I'll be more than happy to try and get them all in and make Expi a nice tool that people can use on their everyday content needs! hello(at)getexpi.app
Also, if this adds to the fact that I'm not a fake AI bot or something along those lines, here's my personal website! https://www.philematic.me
Thanks for your time!
Cheers,
Phil

value: Show HN: Expi – Local No Subscription Converter and Media Editor

author: philematic


value: Show HN: Generative Gemstone Avatars

title: Show HN: Generative Gemstone Avatars


value: vkatluri

value:
Hello HN,
I live in northern part of USA where winters are snowy. Whenever I took long trips, I always wondered what the weather along the route is going to be. For those who live in northern USA, you know weather can change frequently, so when you're traveling matters a lot, not just the route.
To solve this problem for myself, I built https://navimodo.com/. NaviModo calculates the route, and then checks weather along the route based on your start time, and displays weather along the route. Change start time, and the whole thing is recalculated.
I am not expecting any commercialization for this, just wanted to scratch an itch, and just did it. I have ideas for adding additional features (suggestions for when to take breaks based on bad weather, auto-suggestion of start time to avoid bad weather, etc.,) but will add more as time goes by.
Any feedback is welcome!

value: Show HN: I built a navigation app that displays weather along the route

author: vkatluri


value: kuberwastaken

value:
Hey HN! I've been building Claurst - a clean-room implementation of Claude Code in Rust, with extra features to make my ideal agentic Open-Source AI CLI. It's WIP and rough, but I'm shipping a lot to make it amaze amaze amaze.
Inspired by this HN post [1] I saw a few hours ago about caveman speak for token-efficient output, I added /Caveman and /Rocky (from project Hail Mary) to Claurst.
Caveman grammar drops ~70% of output tokens keeping technical substance and Rocky brings a close compression with more personality.
Both are first-class slash commands with three levels: lite, full, ultra.
It's fun, makes you happy and saves tokens :D
Would love for you to try it out and get feedback!
[1] - https://news.ycombinator.com/item?id=47647455

value: Show HN: Rocky and Caveman Speak in Claurst CLI Save Big Token Amaze Amaze Amaze

author: kuberwastaken


value: Callicles

value: Show HN: Contributor License Agreement Bot for GitHub – Next.js and Postgres

author: Callicles


value: hackiku

value: Built this 3D sandbox to fly Integrity alongside NASA OEM trajectories. Web workers run rk4 integrator to predict new path (purple) and the engine executes after burn.<p>Fun bug: fly longer than Moon ephemeris data cutoff May 31st to see some weird zigzag physics

value: Show HN: Flyable Artemis simulator (Svelte and rk4)

author: hackiku


value: Show HN: Ephemeral messaging that protects your privacy from people in your life


value: guanghu

value:
Built this after 3 years developing a SaaS accounting system for the Norwegian market.
The hard part of MVA-melding isn't the XML — it's the full auth and submission chain: ID-porten PKCE with private_key_jwt, then Altinn 3's multi-step instance lifecycle (create → upload → sign → complete → poll feedback), plus Skatteetaten's non-obvious sign rules for reverse-charge codes (81/83/86/88/91 generate double entries).
The library handles the complete 15-step flow and uses a ports-and-adapters design — you implement one interface to connect your own ledger data.
Also open-sourced a companion Spring Boot starter for EHF 3.0 / PEPPOL BIS Billing 3.0 invoice transmission.
https://github.com/guangcode/mva-melding-java
https://github.com/guangcode/oxalis-spring-boot-starter

value: Show HN: mva-melding-java – Java library for Norwegian VAT filing via Altinn 3

author: guanghu


value:
I'm building an AI video editing agent for social media — you describe what you want ("edit it to. 20s", "add captions" or even just "edit this video") and it handles the timeline, transitions, b-rolls and captions.
No editing experience needed.
Looking for feedback

value: Show HN: AI agent that edits videos from natural language commands


value: Show HN: Vulnchain – open-source SAST that synthesises attack chains


value: strvmarv

value: Show HN: Give your AI coding assistant persistent, semantic memory

author: strvmarv


value: obilgic

value: Show HN: Kern - Agent Built for Co-Working

author: obilgic


value: Hi HN. I'm exhausted from seeing legal departments block the use of LLMs because devs were accidentally sending API keys and customer data to OpenAI. Enterprise solutions cost a fortune and take months to integrate. So I built Shieldnod. It's middleware running at the edge that uses regex and NER rules to censor [NAME] or [STRIPE_KEY] in under 50ms before hitting the LLM. I want to test if anyone else is experiencing this. Destroy my landing page or tell me why this approach is idiotic.

value: Show HN: A proxy to hide PII information from LLM requests


value: kyuradar

value: Show HN: Trappsec – Active Defense via Business Logic Deception

author: kyuradar


value:
Hey all, Nathan here from mozilla.ai. I run a lot of agents at once with the agent-of-empires tool, and thought it would be fun if I could also play my favorite board game and have its status tracked just like with Claude Code sessions.
So I built settl: it's a Settlers of Catan style game that runs completely as a TUI, and uses a local LLM (mozilla.ai llamafile!) as the AI agent.
Built in Rust, using the cool new 1B and 8B Bonsai Models by PrismML that my colleague Davide helped turn into a llamafile for dead simple usage of LLMs in the app.
Install:  brew install --cask mozilla-ai/tap/settl
Source:   https://github.com/mozilla-ai/settl
Docs:     https://mozilla-ai.github.io/settl/
Enjoy and let me know if you got feature requests! I'd like to add the ability to argue with agents to try to get them to accept your trades, and would also consider some sort of framework for faster iteration on agent abilities (maybe using Andrej Karpathy's autoresearch)

value: Show HN: TUI Settlers of Catan built with Llamafile and Bonsai PrismML Models


value: FurstFly

value:
Software engineering productivity increased dramatically with AI, but research workflows still feel slow and fragmented.
So I built R-stack, a Claude code setup tailor made for ML and other computational Research.
You just give it your idea and R-stack will:
• check novelty
• refine the research idea
• write code for the experiments
• run them on cloud GPUs
• generate the paper
Human time investment = 5 mins per project + 30 sec
initial setup
Just clone the repo and run the setup script.
Then open Claude Code and type:
/research {your idea}

value: Show HN: A Open Source Claude Code setup to publish Research papers 10x faster

author: FurstFly


value: Show HN: Kubernetes cluster simulation that runs in the browser to prepare CKA


value: Show HN: Detect phantom and unused dependencies across multiple languages


value: ethanjoffe

value: Show HN: LLM Wiki Compiler Inspired by Karpathy

author: ethanjoffe


value: harmoni-pet

value: Show HN: MCP 2000 – Browser-based drum machine with AI-generated sounds

author: harmoni-pet


value:
This has been a passion project of mine for ~ a year. It's a collection of structural bio tools as a GUI application. Intent: "Just works". Includes party tricks like:

  - Infer ADME (drug-design) properties for small mols
  - Can view molecular dynamics trajectories like VMD, and also run them with its wn engine, or GROMACS. (Amber Force fields; inferred from any small mol/protein/nucleic acid/lipid)
  - ORCA GUI interface for quantum chem
  - 3D molecule editor with "real-time" MD
  - Building blocks exposed as open source Rust libs
  - Integration with online databases (PubChem, RCSB PDB, Drugbank etc)

value: Show HN: Molchanica. Structural bio GUI / Rust tools


value: dhbradshaw

value: Show HN: Tiny TUI for disk usage exploration

author: dhbradshaw


value: ilamparithi

value:
The front camera apps always show the mirror preview. Most of us hate photos others take of us, but love our selfies.
It's because we groom ourselves and find our perfect angles using the mirror preview. So it's jarring when we see the photos of us taken by others. I always wanted a camera app that showed the non-mirror preview. Surprisingly most camera apps don't have this option. So I created this app to scratch my own itch:)<p>Note: Photos and videos are only stored in the browser. No data is sent to any servers. You can also install this as an app from your browser since it's a progressive web app.

value: Show HN: ReverseCam – See yourself as others see you

author: ilamparithi


value: JaredCampbell

value:
I got frustrated with Gmail's lack of customization, and built an extension for myself.
It doesn't do much other than modify how Gmail is displayed in Chrome. Does it as minimally as possible (that I can engineer). Done locally, zero remote processing.
Currently built the following settings (want to add more soon):
Conversations:
* Show newest message first
* Show every message in a thread (sometimes they're collapsed into numbered bubbles)
* Remove AI overviews (retches)
Layout/UI:
* Minimize the search & top bar
* Minimize the far left "rail" (Mail/Chat/Meet)
* Hide a bunch of extraneous icons/buttons/items
* Adjust width of Folders/Labels column (still in-process)
Mini-Automations:
* Automatically open to inbox on page start/refresh
* Automatically select first message if the reading pane is open (unless unread, or previous message already selected)
* Add a recurring reminder (if wanted) to use Gmail's new Manage Subscriptions folder/feature
Bunch more features I'd like to add. Let me know if you think I should change anything. Or if you have any code/bug feedback... :)
jared2campbell@gmail.com

value: Show HN: Apparent – A lightweight extension to simplify and clean Gmail

author: JaredCampbell


value: vunderba

value: I had a lot of <i>time on my hands</i> so I spent Sunday afternoon coming up with a bunch of completely impractical ways to visualize clocks.

value: Show HN: Weird Clocks

author: vunderba

title: Show HN: Weird Clocks


value: bloknayrb

value:
I couldn't find a tool that would let me work with Claude as a true collaborator on a document, so we are making that tool together! Tandem is real-time collaboration between you and the same Claude Code that already has access to your domain knowledge, skills, plugins, etc.
Annotate, highlight, ask questions about specific snippets of text, and chat, all in the browser window. It is still pretty early, and channels are still an experimental feature, but it already feels way better than the annoying back and forth process that I was using before.
Open source, and feedback is appreciated very much.

value: Show HN: Tandem, real-time collaboration with Claude Code

author: bloknayrb


value: jlreyes

value:
I was running into scroll performance issues with a mac app I was building a few months back and I got frustrated with the manual instrument → trace → diagnose → fix loop, so I built a way for claude to do it automatically.
Instruments Analyzer exports .trace files captured programmatically or via Instruments (file → save) into DuckDB with Parquet backing, giving your agents full SQL access to CPU profiling, animation hitches, SwiftUI view updates, Core Animation frame lifetimes, RunLoop activity, signposts, and 30+ other tables.
Key features:
1. Natural Language Queries. Since it’s just a skill, you can ask “why did scroll lag in this trace” rather than dig through WWDC videos to understand which instruments to use and how to use them.
2. Derived views for analysis: Frame-level analysis, cascade analysis, and per-frame attribution are available via prepared views (prepare_analysis.py), making it easy to query performance metrics without manual preprocessing.
3. Scroll & animation jank workflow: Optional workflow for diagnosing scroll lag or animation stutter, only loads when relevant.
Install as a Claude Code skill or with whatever agent you’re building with.
https://github.com/jlreyes/instruments-analyzer

value: Show HN: Claude skill for Apple Instruments performance traces (iOS/Mac)

author: jlreyes


value: roblambell

value: Show HN: Orchestrating AI into reviewable PRs you can reason about

author: roblambell


value: Andebugulin

value: Show HN: NfcGuard – Block distracting apps with NFC tags

author: Andebugulin


value:
I've long been into finding deals on government auction sites (seizures, surplus sales etc.) - right now for example San Diego DHS is selling 26 tons of lead shot, with bidding starting at $1,000 ¯\_(ツ)_/¯
It has historically been extremely tedious though: scanning dozens of janky sites which have interminable page loading times; back buttons take you all the way back to the homepage etc.
The site I built - GovAuctions - lets you search every government surplus auction at once. You can filter by location, category, and price, save items to a watchlist, and get alerts when new auctions match what you're looking for.
Let me know what you think, if you have any suggestions, and if you find any deals in your area!

value: Show HN: GovAuctions lets you browse government auctions at once


value: darkhanakh

value: Show HN: Pg_kazsearch – Full-text search for Kazakh in PostgreSQL

author: darkhanakh