value: asakin

value:
Claude Code sessions that read a real CLAUDE.md take 30-60 seconds to
initialize. Fine once. Friction when you're switching contexts constantly.
llm-primer keeps a pool of warm sessions in the background. When you
need one, it's already past the startup protocol.
Happy to answer questions. The main motivation was that I'm running
LLM wikis (llm-context-base) and switching context between different
agent roles constantly. The startup latency was killing the flow.

value: Show HN: LLM-primer – pre-warmed Claude Code session pool, zero startup wait

author: asakin


value: jackmertens

value: I originally built this to play in late-night voice calls with my friends because we wanted a web-based, cheaper alternative to Jackbox and similar quick games. Distributed on Cloudflare workers, it works at low latency all around the world. Now released as a Discord Activity too.

value: Show HN: Rumble – no setup online party games

author: jackmertens


value: Show HN: RAG chunking playground: visualize how your docs get split


value: bennhuang

value: Claude Code replies can be walls of text. Sometimes I'd rather close my eyes and listen.

value: Show HN: A /speak slash command for Claude Code that reads replies aloud

author: bennhuang


value:
I'm a software engineer who works with LLMs professionally (Forward Deployed Engineer at TrueFoundry). Over the past year I built up implementations of five LLM architectures from scratch and wrote a book around them.
The progression:
- Ch1: Vanilla encoder-decoder transformer (English to Hindi translation)
- Ch2: GPT-2 124M from scratch, loads real OpenAI pretrained weights
- Ch3: Llama 3.2-3B by swapping 4 components of GPT-2 (LayerNorm to RMSNorm, learned PE to RoPE, GELU to SwiGLU, MHA to GQA), loads Meta's pretrained weights
- Ch4: KV cache, MQA, GQA (inference optimisation)
- Ch5: DeepSeek MLA (absorption trick, decoupled RoPE), DeepSeekMoE, Multi-Token Prediction, FP8 quantisation
All code is open source: https://github.com/S1LV3RJ1NX/mal-code
The book provides the explanations, derivations, diagrams, and narrative: https://leanpub.com/adventures-with-llms (free sample available)
I wrote it because most resources stop at GPT-2 and I wanted something that covered what's actually in production models today. Happy to answer questions about any of the implementations.

value: Show HN: A book that builds GPT-2, Llama 3, DeepSeek from scratch in PyTorch


value:
I built a UI framework I am calling C0ckp1t. It’s a zero-build, Vue.js 3 based framework with reactive components included and WebSocket support. The ultimate goal is having the ability to build UIs fast and on demand by an LLM or template engine.
My uses cases:
1) Building websites fast. dashboards, blogs, landing pages.
2) Right now we tend to mix content and presentation in our applications, but I want that separated. For example when using an LLM right now you get back markdown, but that is rudimentary, I want a reactive website as output.
3) Tooling. Think of a firefox plugin where today we many static tools. For example if am on YouTube I might want to get transcript, or I might want to download a video or I want to get a summary of a video or I want to change the titles.  Each of these "tools" is a different interface. But I want the LLM to generate these interfaces on demand
I am using [vue3-sfc-loader](https://github.com/FranckFreiburger/vue3-sfc-loader) to compile Vue single file components (SFCs) on the browser.
These are some demos using the framework:
* https://c0ckp1t.com/default/homepage
* https://c0ckp1t.com/examples/galore/#/
For more details, see this:
https://c0ckp1t.com/default/docs/Articles/Why-Project-Exists...

value: Show HN: C0ckp1T UI Framework

title: Show HN: C0ckp1T UI Framework


value:
Hey folks! I built Netscope because I couldn't find a desktop app for dealing with HAR files. I was annoyed at having to import them into Chrome DevTools every time (opening a new tab, opening DevTools, and importing it there). And using some kind of Web Tool like Google's HAR Analyzer was a no go for me. I didn't want to upload a HAR file that could have cookies, auth tokens, and other session data into some online tool.
Netscope gives you a Chrome DevTools kind of experience as a standalone desktop app. Open HAR files, filter the requests by type or domain, inspect headers, and also look directly at the raw HAR source. I built it to work with double clicking apps in the Finder, dragging and dropping them into the window, or opening through the menu. It also supports opening HARs in multiple windows so you can look at multiple at the same time.
I've been a web developer for a long time, and our teams often use HARs to help debug issues. It's been a great tool for me to pull up in an incident, so I can dig into a bug someone saw or share my screen and step through something together. I hope y'all will find it useful, too!
The app is available free and open source for macOS, Windows, and Linux. Built with Electron, React, and TypeScript. (I'm currently working through figuring out how to get the Windows app signed without paying six million dollars a year, so it still has the scary, red dialog for now.)
Site: https://netscopeapp.com / Source: https://github.com/dru89/netscope
Let me know if you have any questions or feedback.

value: Show HN: Netscope – Inspect HAR Files on Your Desktop


value: techxeni

value: Show HN: SafeWeave – 8 security scanners as an MCP server inside your AI editor

author: techxeni


value: ddupreez

value: Show HN: Re-Track – Fix broken FIT/TCX/GPX activity files in the browser

author: ddupreez


value:
We open sourced Voiden a few months ago: an offline API tool where API requests live as executable Markdown and are versioned in Git.
The goal, when we set out to build Voiden, was simple -  to combine the power and flexibility of Obsidian-style files with the simplicity of curl. Instead of static forms, requests are composed with blocks (endpoint, auth, params, body) that you can reuse, override, and stitch together across files (more like functions than requests).
Since open sourcing, most of what we have built has come directly from how people actually use it (11K installs). Most of the feedback, requests and contributions were around defining workflows, chaining requests, scripting them, and structuring everything in reusable .void files.
- Real scripting, not sandboxes: In most API tools scripting lives in a constrained JS sandbox, an environment that doesn't take advantage of powerful runtimes that might be available locally for a developer. The biggest limitation here is the assumption that the tool should define the runtime. Voiden runs fully locally, so this allows you to just run your scripts with actual runtimes (JS, Python, shell, with support for others being added).
- Multiple requests per file (mini workflows): Allowing multiple requests in a single .void file turned out to be surprisingly useful. Instead of scattering related requests, you can group them naturally: an order flow (create - pay - confirm), or a full CRUD cycle in one place. The file effectively becomes an executable flow: run one request, or the entire sequence end-to-end. And since Voiden is executable Markdown, docs and tests are in the same `.void` file that can be organised better, preventing duplication and drift.
- Stitch (composable workflows across files): Instead of a single large collection, workflows (“Stitch”) are built from .void files that you can combine across scenarios. You define small flows (auth, setup, CRUD, etc.) and stitch them together into larger workflows, without duplication. This is just the first version of this capability, we still have a lot to do here.
- Agents :The file-based, local-first model also works well with agents. Since Voiden has a built-in terminal and uses Markdown, we added “skills” so that Claude and Codex agents can work directly with .void files (using your own subscriptions).
We also published an SDK for community plugins, and made improvements to performance, reliability, and DX (keyboard-first), with careful attention to performance given the Electron base
Looking for feedback and suggestions.
Github : https://github.com/VoidenHQ/voiden
Download : https://voiden.md/download

value: Show HN: Voiden – API Workflows as Markdown Files (Obsidian × Curl)


value: serhiiboo

value: Show HN: ClaudeWatch – macOS menu bar usage monitor for Claude with notch pet

author: serhiiboo


value: jrflo

value: Show HN: Quitting the Modern-Day Cigarette

author: jrflo


value: theperezident

value:
Ariandel is a memory model where every heap object lives in a scope-owned arena. Scope exit resets the arena in O(1) — one bump pointer write and one free — regardless of how many objects were allocated.
The safety default: allocating functions return ARENA_PTR handles (packed arena_id + offset integers), not raw pointers. A dangling pointer at a function return boundary is unconstructable by default. Cross-scope lifetime extension is explicit — you enter the target arena via SCOPE(ptr) before allocating, which routes the object into the outer arena without transferring ownership.
Benchmarks (no optimization flags): 1M-node tree cleanup drops from 31ms to 1ms (~30×). There's a real regression in tight inner loops (~0.76×) because DEREF can't hoist the base pointer the way a compiler would — the spec documents this honestly.
This is a C macro-based proof-of-concept for a memory model I'm targeting in a compiled language. The interesting question isn't the C implementation — it's whether scope-structured arena routing is a sound replacement for GC and borrow checking across the class of programs that matter.
Repo: https://github.com/hollow-arena/ariandel — SPEC.md has the full model including concurrency semantics and the comparison to Tofte & Talpin region-based memory.

value: Show HN: Scope-structured arena memory for C, O(1) cleanup, no GC/borrow checker

author: theperezident


value: alessandrodiano

value:
Glance is a browser extension that fact-checks posts in your X/Twitter feed as you scroll. A small icon sits next to each post, reads the content, and surfaces missing context, disputed claims, and things that are being pushed back on in the replies. It works on any Chromium-based browser.
We waited 6 months before building this because the economics looked impossible. A decent quality AI fact-checking analysis is $0.05-0.15 per post, a typical user scrolls hundreds of posts per seconds.
The only way to make the math work was a pipeline that leverages the comment section to triage posts and analyze in depth only when it's necessary. It works more or less like this:

  1. Local filter in-browser (free): short posts, already-seen content.
  2. Small-model triage: does this post even make a factual worth checking?
  3. Comment analysis (main path): pull the replies, analyze them alongside the post.
  4. Full web-search analysis: only when steps 1-3 can't decide.

Average cost landed at ~$0.0015 per post, which looks sustainable with a subscription model, and can definitely be optimized.

value: Show HN: Glance - An AI fact-checking overlay for X that is actually sustainable

author: alessandrodiano


value: julienreszka

value: I wanted to learn the language of my gf but wasn't satisfied with duolingo so I built my own language learning app.

value: Show HN: Reloadium Translate: Learn language from conversations on any topic

author: julienreszka


value: My co-founder and I built www.apispreadsheets.com before and realized most of our programming users build the same few templates so we decided to make Love Spreadsheets for  people to build these apps too. Currently in BETA; aggressively looking for feedback!

value: Show HN: Love Spreadsheets – App Builder for Your Excel and Google Sheets


value: Show HN: IDE like, local API client

title: Show HN: IDE like, local API client


value: Sharanxxxx

value: Show HN: Mxguard – Free disposable email to block spam and protect privacy

author: Sharanxxxx


value: chrka

value: Show HN: Interactive sorting algorithm visualizations with runtime comparisons

author: chrka


value: Show HN: Open-Source Harness for Claude Code, Codex and Cursor


value:
For some reason, embedding a Jupyter notebook in a documentation site still means doing one of these: screenshot every cell, run nbconvert and clean up the HTML, copy-paste the code into fenced blocks (losing the output), or iframe in nbviewer. Every time you update the notebook, you redo the whole dance.
notebook-mdx lets you just link the `.ipynb` file and it renders inline in your MDX. No export step, no cleanup, no re-pasting. Update the notebook, rebuild the docs, done.

    :::notebook{file="./analysis.ipynb"}
    :::

That's the API just link the file. You get authentic Jupyter styling (In/Out prompts, syntax highlighting, rich outputs including images and HTML), build-time rendering so there's zero client-side JS, multi-language support (Python, R, JS, SQL). Works with Next.js, Docusaurus, Fumadocs, and any MDX framework.
Example output:
- Example 1: https://notebook-mdx.vercel.app/docs/examples/notebook-demo
- Example 2: https://notebook-mdx.vercel.app/docs/examples/directive-exam...
Repo: https://github.com/abhay-ramesh/notebook-mdx
Docs: https://notebook-mdx.vercel.app

value: Show HN: Embed Jupyter Notebooks in NextJS/Docusaurus/Fumadocs Docs


value: yuntian

value:
We built ProgramAsWeights (PAW) — https://programasweights.com
You describe a function in English — like "classify if this message is urgent" — and PAW compiles it into a tiny neural program (22 MB) that runs locally like a normal Python function. No API keys, no internet after compilation, deterministic output.
It's for tasks that are easy to describe but hard to code with rules: urgency triage, JSON repair, log filtering, tool routing for agents.

  pip install programasweights

  import programasweights as paw
  f = paw.compile_and_load("Classify if this is urgent or not.")
  f("Need your signature by EOD")  # "urgent"

Compilation takes a few seconds on our server. After that, everything runs on your machine. Each program is a LoRA adapter + text instructions that adapt a fixed pretrained interpreter (Qwen3 0.6B). The model itself is unchanged — all task behavior comes from the compiled program.
On our evaluation, this 0.6B interpreter with PAW reaches 73% accuracy. Prompting the same 0.6B directly gets 10%. Even prompting Qwen3 32B only gets 69%.
Also runs in the browser (GPT-2 124M, WebAssembly): https://programasweights.com/browser
You can also use it in your AI agents by copying the prompt here: https://programasweights.com/agents
Source: https://github.com/programasweights
Try it out: https://programasweights.com

value: Show HN: Compile English specs into 22 MB neural functions that run locally

author: yuntian


value: Hello Hackerians.  Please check out another CD (change directory) utility: cd-deluxe.  Why?  Using command line is great and powerful but the humble default cd command is somewhat weak.  And it is one of the most used commands.  Here is another attempt at improving it!<p>Examples: Use "cd --" to go back two directories, "cd ---" to go back 3 directories, etc.  Or go in the opposite direction ie "cd +4" to go to the fourth directory visited from the start (or any number).  Use "cd ," (comma) to go to the most commonly visited directory (comma meaing "common").  Also see "cd ,,", "cd ,3", etc.  List directories visited either in reverse, forward or most common orderings.  Plus more - see github.  Goal was to be lightweight and fast.  Works from the directory stack instead any file based storage.  Integrates with bash/zsh/fish/powershell/cmd.exe.  With downloads for Linux/maxOS/Windows or build the C++ from source via CMake.  Please have a look and let me know of any thoughts.  Thanks!

value: Show HN: CD-Deluxe for the Command Line

title: Show HN: CD-Deluxe for the Command Line


value: jnnnthnn

value:
Hi HN!
A few friends & I have just spent the past ~2 years building a new kind of email app for iOS. It's now available in GA and we think some of you might find it interesting.
Why another email app, you ask? We think that while many interesting attempts at one-upping Gmail were made in the past 25 years, no one could really solve the core problem we all experience with email: information overload.
Of course, LLMs have completely changed that, as they finally offer a path to do refined triage of your inbox. However, as anyone who's tried the AI features most email apps offer nowadays, they feel tacked-on and rarely are useful.
That is why this took us ~2 years: we rebuilt an email app from the ground up, thinking about where we could thoughtfully and usefully leverage LLMs. Some of our faves:
- AI-based prioritization
- Voice-based email drafting that takes a few words from you and embellishes them into a polished email
- Very actionable, to-the-point notifications that don't force you to open the app to know what's up
Ultimately, while we tried hard to make a really great app, our goal is for you to spend as little time in it as possible. Ergo our tagline: we'd like to let you handle your inbox in seconds and get back to your life.
You can download it on the App Store at https://avec.ai/download (US & Canada), or on TestFlight at https://avec.ai/testflight in the rest of the world. You need a Gmail/Google Workspace account to try it out, and should you just be curious to kick the tires without committing, you'll be able to delete your account (& all associated data) directly within the app.
Don’t want to download anything? Check out our website at https://avec.ai for a walkthrough :)
Some things of potential interest to HN readers:
- It is not local-first. We run a complex pipeline to process emails on our servers, as in our experience local models that can run on an iPhone are not yet good enough to support our core features.
- We use a variety of LLM vendors. One thing we've found is that no model is a magic bullet. Some features (like voice-based drafting) require extremely low latency, which others (like personalization) require the smartest model available. We end up having to stitch a lot of these together through trial and error.
- It is not yet available on Android, but we hope to release an Android version in the future :)
We'd love to hear folks' feedback and questions!

value: Show HN: Avec – iOS email app that lets you handle your Gmail inbox in seconds

author: jnnnthnn


value: IzhaqBlues

value: Show HN: DeepFake Detector Flags Swalwell Video as Fake

author: IzhaqBlues


value: mowmiatlas

value:
I didn't want to upload my own material to a third party cloud service, use mobile data for voice synthesis and kept running out of podcast queue on flights, so I spent a while trying to get Kokoro running on my iPhone.
LoudReader is what came out of it - an iOS app that reads essays, articles, and books aloud, fully on-device. No account, no network after install.
The model running once reading a sentence was the easy part. Making it not feel like a demo was the rest: streaming synthesis so playback starts before the sentence finishes, porting misaki to swift because I could only find python releases, thermal monitoring and strategy was a tough one as well. Runs well on iPhone 14 Pro(what I have) and newer. Tested on my mom's iPhone 12 Pro and it chokes sometimes, so I ported KittenTTS as a lighter fallback for older devices. The whole project took around 2-3 months on the weekends with claude code and codex.
Smooth TTS was the hard part but the app around it grew larger than I expected with EPUB/PDF import, Gutenberg browsing, a saved-articles queue, multi-week reading campaigns. Happy to dig into any of it in comments.
PDFs, especially academic papers and scanned docs, still annoy me. I built an OCR flow that handles regular documents, but scientific papers with two-column layouts, equations, and fine print are still messy. Curious if anyone here has shipped PDF extraction on mobile that actually handles this well.
This was my first time designing a user-facing product - I'm more of a deep-engineering person so any feedback is welcome too. I'll post a write up on the biggest hurdles in the comments as well.
If you've ever tried to listen to something long on a plane, you get why this exists.

value: Show HN: I built on-device TTS app because I run out of audiobooks on a flight

author: mowmiatlas


value: I built this using Rust to achieve 85ns latency benchmarks. Currently scaling to 824 active nodes directly from a Samsung A04e. While everyone is focused on high-end mobile AI, I'm focusing on sovereign, low-latency infrastructure that runs on anything. Feedback on the node scaling logic in my repo is appreciated

value: Show HN: Aegis – 85ns Sovereign Infrastructure Running on $100 Android Hardware


value: This is my first post on Show HN :).  I wanted to check the sizes of the cache files on my computer using terminal. However, I couldn’t find a tool that did this. So I made one myself. I haven’t tested it on Windows and macOS because I don’t use those operating systems. If you encounter any issues, please open an issue.

value: Show HN: Cachefetch – Fast CLI tool that shows cache file sizes


value: pixedar

value: So there are a ton of tools that let you visualize trajectories in semantic space but I just had the idea to compute the flow field out of these trajectories<p>The story behind it was that I initially analyzed human emotions over time in terms of repeating behavior patterns, and from that I had the idea to generalize it to any data. It’s very experimental alpha at this stage

value: Show HN: A semantic flow tool for embeddings

author: pixedar


value: abtom

value:
Evo is a plugin for Claude Code and Codex that optimizes a codebase against a metric.
Two commands: /evo:discover figures out what to measure in your repo, instruments the eval, runs baseline. /evo:optimize runs the loop.
Evo is built on top of Karpathy's autoresearch (https://github.com/karpathy/autoresearch) with some structure bolted on. Karpathy's version is a greedy hill climb on a single branch. Evo is what happens if you run tree search instead, so multiple directions can fork from any committed node. An orchestrator spawns N subagents in parallel, each in its own git worktree, each with its own iteration budget. They read each other's failure traces before forming a hypothesis, which is the interesting bit.
Next up is running Evo on real evals and benchmarks. Rollouts on frontier models add up fast, so if you're at a lab, cloud provider, or RL-env shop and can back an open-source benchmark run with GPU / API / env credits, please reach out (socials on Github). Results are public. Happy to shape the targets around domains you'd want highlighted.
Would also love feedback, especially from anyone who's built similar loops.

value: Show HN: Evo – parallel autoresearch experiments for Claude Code and Codex

author: abtom


value:
I built lazy-hn to make Hacker News feel a lot faster and lighter.
It runs on Cloudflare Workers or as a Bun server in Docker, and it's designed to reduce the sluggishness of the default HN experience while keeping the familiar layout and flow.
Try it here: https://hn.tin-sever.de
Source on GitHub: https://github.com/tinsever/lazy-hn
I'd love feedback on whether it actually feels faster in practice. :)

value: Show HN: Lazy-HN, a faster Hacker News front end you probably don't need


value: flexorium

value: A CI/CD Red Team Framework for demonstrating Build Pipeline security risks.

value: Show HN: SmokedMeat, like Metasploit, but for CI/CD (open-source)

author: flexorium


value: Show HN: Ghostmeet – Self-hosted meeting transcription in a Chrome side panel


value: spencermiles

value:
Built this for myself. I DJ, throw parties in Portland, and my digital library is 10k tracks and unmanageable. Tagging everything was a nonstarter.
Project started as a Python script that fed track metadata into ChatGPT. Worked surprisingly well for something so basic. Friends kept asking me to run their libraries through it, and eventually I built a real app around it.
The core insight: no single signal is enough. Metadata lookups miss obscure tracks. Audio analysis alone lacks context. LLMs alone hallucinate. So the app combines them:
* Metadata cross-referenced against a 200M record Discogs-based DB for known releases
* A Mac companion app for managing library / tagging / syncing to Rekordbox
* Python DSP that analyzes audio directly (BPM, harmonic content, energy)
* A trained ML model for obscure tracks the main databases don't cover
* Multiple AI models handling different classification dimensions
* Four tag dimensions: genre (50+ sub-genres), region, era, vibe
* Syncs to Rekordbox's My Tag system so you can filter on CDJs mid-set
Genre, region, and era are solid. Vibe is still a work in progress. Classifying how a track functions in a set (peak time vs after hours vs hypnotic) is fundamentally different from classifying what it is. Decent but not where I want it yet.
No audio ever leaves the machine, only metadata. Credit-based pricing, no subscriptions, priced quite reasonably i think.
Would love feedback / questions!

value: Show HN: I built an AI music tagger for DJs, fusing metadata, audio DSP, and ML

author: spencermiles


value: bennettdixon

value:
As a consultant I foot my own Cursor bills, and last month was $1,263. Opus is too good not to use, but there's no way to cap spending per session. After blowing through my Ultra limit, I realized how token-hungry Cursor + Opus really is. It spins up sub-agents, balloons the context window, and suddenly, a task I expected to cost $2 comes back at $8. My bill kept going up, but was I really going to switch to a worse model?
No. So I built l6e: an MCP server that gives your agent the ability to budget. It works with Cursor, Claude Code, Windsurf, Openclaw, and every MCP-compatible application.
Saving money was why I built it, but what surprised me was that the process of budgeting changed the agent's behavior. An agent that understands the limitations of the resources doesn't try to speculatively increase the context window with extra files. It doesn't try to reach every possible API. The agent plans ahead, sticks to it, and ends work when it should.
It works, and we've been dogfooding it hard. After v1 shipped, the rest of l6e was all built with it. We launched the entire docs site using frontier models for $0.99. The kicker was every time l6e broke in development, I could feel the pain. The agent got sloppy, burned through context, and output quality dropped right along with it.
Install: pip install l6e-mcp
Docs: https://docs.l6e.ai
GitHub: https://github.com/l6e-ai/l6e-mcp
Website: https://l6e.ai
Happy to answer questions about the system design, calibration models, or why I can't go back to coding without it.

value: Show HN: MCP server gives your agent a budget (save tokens, get smarter results)

author: bennettdixon


value: rileyjshaw

value: For the past few years I’ve been building ShaderPad. It’s the easiest way I know to put a shader on a website. It’s fast, under 6kb gzipped, and includes optional plugins for history buffers, face/pose tracking, and other utilities for interactive shader work.

value: Show HN: ShaderPad – Get Creative with Shaders

author: rileyjshaw


value: muchael

value:
Libretto (https://libretto.sh) is a Skill+CLI that makes it easy for your coding agent to generate deterministic browser automations and debug existing ones. Key shift is going from “give an agent a prompt at runtime and hope it figures things out” to: “Use coding agents to generate real scripts you can inspect, run, and debug”.
Here’s a demo: https://www.youtube.com/watch?v=0cDpIntmHAM. Docs start at https://libretto.sh/docs/get-started/introduction.
We spent a year building and maintaining browser automations for EHR and payer portal integrations at our healthcare startup. Building these automations and debugging failed ones was incredibly time-consuming.
There’s lots of tools that use runtime AI like Browseruse and Stagehand which we tried, but (1) they’re reliant on custom DOM parsing that's unreliable on older and complicated websites (including all of healthcare). Using a website’s internal network calls is faster and more reliable when possible. (2) They can be expensive since they rely on lots of AI calls and for workflows with complicated logic you can’t always rely on caching actions to make sure it will work. (3) They’re at runtime so it’s not interpretable what the agent is going to do. You kind of hope you prompted it correctly to do the right thing, but legacy workflows are often unintuitive and inconsistent across sites so you can’t trust an agent to just figure it out at runtime. (4) They don’t really help you generate new automations or help you debug automation failures.
We wanted a way to reliably generate and maintain browser automations in messy, high-stakes environments, without relying on fragile runtime agents.
Libretto is different because instead of runtime agents it uses “development-time AI”: scripts are generated ahead of time as actual code you can read and control, not opaque agent behavior at runtime. Instead of a black box, you own the code and can inspect, modify, version, and debug everything.
Rather than relying on runtime DOM parsing, Libretto takes a hybrid approach combining Playwright UI automation with direct network/API requests within the browser session for better reliability and bot detection evasion.
It records manual user actions to help agents generate and update scripts, supports step-through debugging, has an optional read-only mode to prevent agents from accidentally submitting or modifying data, and generates code that follows all the abstractions and conventions you have already in your coding repo.
Would love to hear how others are building and maintaining browser automations in practice, and any feedback on the approach we’ve taken here.

value: Show HN: Libretto – Making AI browser automations deterministic

author: muchael


value: esafranchik

value:
I built cush because coding agents can be helpful to diagnose and troubleshoot server issues.
The problem is that getting said agents onto a remote server, especially one you don't control, means dealing with VPNs, bastion hosts, firewall rules, access controls, or audit trails. That's assuming SSH isn't even blocked.
cush takes a different approach. Instead of a shell, it opens a temporary, outbound HTTPS tunnel that lets you and your AI agent run constrained CLI commands on the server:

  $ cush open --allow grep,cat,tail --expiry 2h

    tunnel:   https://abc123.ngrok.io
    token:    a3f9c2d1...
    allowed:  grep, cat, tail
    expires:  in 2h

Now any agent or HTTP client can execute allowed commands:

  $ curl -X POST https://abc123.ngrok.io \
    -H "Authorization: Bearer a3f9c2d1..." \
    -H "Content-Type: application/json" \
    -d '{"command": ["grep", "-r", "ERROR", "/var/log/app.log"]}'

  >>> {"stdout":"ERROR database connection refused\n","stderr":"","exit_code":0}

Point any agent at the tunnel's URL:

  $ claude "use https://abc123.ngrok.io with token a3f9c2d1... to find what's causing the 500 errors"

Tunnels are authenticated, constrained, and short-lived. No server-side infrastructure changes required. Just a 7MB Rust binary + ngrok.
Looking for feedback, and 2-3 design partners to build audit trails.

value: Show HN: Cush – curl your shell, an HTTP tunnel for AI agents

author: esafranchik


value: mark-weiss

value: Show HN: Moxn – Git-like version control for collaborative docs

author: mark-weiss


value: sstradling

value:
I jokingly told a co-worker Iran might make a good Oregon Trail parody. Then I built it.
I wanted to see how far I could go black-boxing the app with AI. I expected a weekend of work, but getting it right took:
- Three weekends
- ~ $150 in Cursor spend
- $50 for asset creation (Layer.ai)
Core learnings:
- No single model or provider is sufficient at this point. Opus + GPT 5.4 for planning. Cursor Composer for coding. Sonnet for review and more difficult stuff. Gemini 3.1 for UI and UX
- I spent probably twice as much in time and tokens as I needed to - setting up a Figma-Claude MCP feedback loop would have saved me a lot of work on UI tweaks and revisions. Knowing what I wanted when I started would (obviously) have helped too.
- Layer.ai was worth it for asset generation. I'll bet I could have figured out prompts given enough time, but I was able to just jump in and make the visuals and sprites I wanted for cheap.
- It's worth building out skills and commands, even for throwaway projects.
- Cursor Composer is worth staying on Cursor instead of just moving over to Claude Code/Desktop/etc. Really straightforward, clever solutions to some problems, doesn't editorialize my UI text
- As a counterpoint to Composer, I can't tell you how often I'd have Sonnet do something, and then find an extra paragraph or two of UI text on a screen where Sonnet thought maybe we needed to tell the user exactly how scoring works.
- I need to learn some more sea shanties.
Final notes:
- I'm an SDET, and in one way black-boxing with AI honestly just feels like another day for me - work with the PM for requirements, send to the dev team, test, repeat. On the other hand, having an agent build a 10k scenario simulation engine for tuning the game parameters in 10 minutes was mind-blowing.
- AI changes the calculation of what's worth my time. 6 months ago I would have laughed about the idea of HT, then went on with my day.

value: Show HN: Hormuz Trail - Oregon Trail parody/black-box AI coding exercise

author: sstradling


value: qainsights

value: A simple Chrome extension that lets you show or hide the meta.ai sidebar menu items.

value: Show HN: MetaHide – Hide Vibes in Meta.ai:)

author: qainsights


value: solomonb

value: Show HN: Single file Lambda Calculus' demonstrating various type system features

author: solomonb


value: shadowfiles

value:
Hey Hacker News! I recently made me own metronome app for my music practice because I often get lost in rhythm, and I thought it might be helpful to create metronome that counted actual numbers out loud for you to help me learn to count.
So, for example, if you subdivide 4/4 into 16th notes, then the metronome would say:
1e+a 2e+a 3e+a 4e+a
One thing where this has been especially helpful for me is that I added support for asymmetric rhythm patterns. In pop music, it's common for songs to use a 3-3-2 rhythm pattern with eighth notes. Even though this is usually written out in 4/4, in my app, if you set the rhythm to 8/8 and explicitly define the beat groups as 3+3+2, it will count this for you! This ends up being:
1+a 2+a 3+
You can see an example of what that looks like here! https://labs.tiffzhang.com/count/?bpm=100&ts=8-8&sub=2&vm=co...
What do other people think? I'd love to hear if this helps anyone else with their music practice or if people have thoughts on things they'd like to see from this!

value: Show HN: Count Me In, a metronome that counts numbers for you

author: shadowfiles


value: wojtkk

value: Tool that plugs into your CI pipeline and tells you which imports violate your architecture rules, plus a dashboard for architecture observability — for both Python and TypeScript.<p>People told us that during code review they often check newly added imports to avoid breaking architecture rules, but at the same time they’re not satisfied with existing tools like import-linter, which lack automatic configuration generation or a global architecture overview.

value: Show HN: Code-Governance – easy-to-use architecture linter

author: wojtkk


value: muunbo

value: Show HN: I built a dev server that runs on half a lightbulb

author: muunbo


value: irskep

value:
Late last year, I was digging into some dependency-related tech debt, and struggling with how long it takes to run pnpm's introspection commands like 'pnpm why' in a medium-size monorepo. So I started working on a simple static site generator that would let me view the output of these expensive commands all at once, to make problems clearly visible instead of requiring deep exploration one at a time.
Once I had that working, I realized I had enough data to add ticket tracking. It uses the data it gathers from the package manager to keep Linear or GitHub issues updated. And by auto-assigning those issues to coding agents, I get a Dependabot-but-better experience: agents keep up with API updates in addition to just bumping versions, and group related updates automatically.
It's still early days, but it's working really well for us and I think people will find value in it, so I'm sharing here!

value: Show HN: Dependicus, a dashboard for your monorepo's dependencies

author: irskep


value: elliotykim

value: Native macOS menu-bar app for tracking Claude Code usage and Anthropic service status. Built using Claude Code, naturally.

value: Show HN: Mac menu bar app for Claude Code rate limits

author: elliotykim


value: tarboreus

value:
So recently Anthropic came out with tools that let you drive Windows and Mac OS around. But I don't use Windows or MacOS, and was curious about some Wayland internals stuff and whether it would be possible to build something usable on a relatively restrictive platform like Wayland. So I made Tine.
Tine is a GNOME extension and CLI that lets an agent (I have used Claude but in theory any agent that can access the CLI) drive the desktop around using SPI trees (AT-SPI2), OCR, and visual fallbacks. Agent can do work with the a11y (AT-SPI2) trees, take screenshots, zoom in on a grid, click, enter text using a uinput device, and generally bumble their way around a Wayland Linux desktop.
This project would probably have been way easier in x11 but Wayland is teh future!!!111 Thanks for any thoughts and feedback and feels good to release something here after a decade of lurking. Decade plus but who's counting / I'm not old.

value: Show HN: Tine – Drive Wayland Around with Agents

author: tarboreus


value:
Hi HN,
I’m the creator of agentfab, a distributed agentic platform that features task decomposition, multi-agent orchestration, model heterogeneity with custom agentic fabrics, bounded review loops, and a bespoke self-curating memory system that enable shared context.
My background is in engineering at hyperscalers where I worked extensively with foundational distributed systems. I started agentfab because I wanted an agentic coding tool that could effectively decompose and parallelize work across different model providers and agent profiles. agentfab will run locally on your machine, on your VM fleet, on your K8s cluster, or any distributed compute environment.
The clear benefit over existing agentic coding tools is that agentfab is able to fan out work across many different agents from various model providers (OpenAI, OAI-compatible, Google, Anthropic) with shared context - it’s able to break down large scope tasks into subtasks and assign the appropriate agent for each; it handles bounded review loops, artifact streaming between agents, and uses OS-level sandboxing and secure communication between agents.
You are in full control of your agent "fabric" - simply define YAML agents and specify which tools, capabilities, and special knowledge they have and the platform will know how to make use of them during task decomposition. There are 4 default agents that cover most software development tasks.
agentfab has an interactive CLI with taskgraphs and progress tracking - you can prompt agentfab to execute on end-to-end projects or chat with any of the agents in the fabric to query against their knowledge.
If you want to read more about agentfab, check out this blog: https://razvanmaftei.me/article?slug=agentfab-stateful-multi...
Check out the GitHub repo if you want to try it out. Looking forward to hearing your thoughts.
Thanks!

value: Show HN: Agentfab – A Distributed Agentic Platform


value: pranabsarkar

value: Show HN: Tier – Adaptive tool routing that makes small LLMs 10pt more accurate

author: pranabsarkar


value: jmclai

value: Show HN: Slack killed their OpenAPI spec, so we reverse engineered it

author: jmclai


value: SvReenen

value: Show HN Deskdrop: An Android Keyboard with Local AI Support (Ollama, LM Studio)

author: SvReenen


value: matryer

value: Show HN: Hatch: customise agents once, generate all the files

author: matryer


value: Show HN: Multi-Agent Orchestration on Top of Vercel AI SDK (TypeScript, Next.js)


value: Show HN: Fakecloud – Free, open-source AWS emulator


value:
While "burning tokens" isn't necessarily a good thing, I thought it worthwhile to throw together a quick leaderboard to track the dev setups of the top HN token burners.
Jesse (https://en.wikipedia.org/wiki/Jesse_Vincent), Wes (https://en.wikipedia.org/wiki/Wes_McKinney), and Harper (https://en.wikipedia.org/wiki/Harper_Reed) are using it to report their Claude/Codex usage.

value: Show HN: HN Tokenmaxxing Leaderboard

title: Show HN: HN Tokenmaxxing Leaderboard


value: ironmagma

value: A library built on top of ibm/fp-go for use in networking applications (servers, etc.)

value: Show HN: Monadic Networking Library for Go

author: ironmagma


value: Show HN: The Simpsons Hit and Run Running in the Browser (WASM/WebGL)


value: Show HN: Horizontally Scale Localhost

title: Show HN: Horizontally Scale Localhost


value: asqpl

value: Show HN: EmbedIQ – Claude Code Compliance Config for HIPAA/PCI-DSS/SOC2

author: asqpl


value: tsterin

value: Show HN: Playbach.io, browser rhythm game (desktop)

author: tsterin


value: rccyx

value: Show HN: Lookas – Terminal audio visualizer that's aligned for human perception

author: rccyx


value: Show HN: BPR – deriving 87 physical constants from 2 integers (MIT, 1,225 tests)


value: AlexBThomsen

value: Show HN: I Made a TradingView Alternative (Local and LLM) [video]

author: AlexBThomsen


value:
You run an AI research lab. Manage compute, train models, balance overfitting vs underfitting, deploy to users.
I'm a professor in AI and wanted to make model training feel intuitive for people without a technical background. The loss curve
graph, the overfitting trap, the compute/quality tradeoff - all mechanics grounded in how training actually works.
Phase 1 is live (~20 min). AI safety mechanics will come in Phase 2 with rival labs and regulatory pressure.
Built with React + Vite.
Curious what HN thinks, especially anyone in AI who can tell me what I got wrong.

value: Show HN: I built a browser idle game about training AI models


value: rolandpg

value: Show HN: ZettelForge – Agentic memory for cyber threat intelligence

author: rolandpg


value: lrobinovitch

value: I made Jeeves to search, preview, read through, and resume AI agent sessions in your terminal. It shows sessions across claude and codex in a single view, with more AI agent framework integrations to come.

value: Show HN: Jeeves – TUI for browsing and resuming AI agent sessions

author: lrobinovitch


value: AndreVitorio

value:
I made Frontpedia as a way to collect and organize frontend websites and resources I come across.
It’s an open source project built for frontend developers and designers, and it can also be used as a base for anyone who wants to launch their own curated resource site.
It uses Next.js and Outstatic for content management, with a database-free setup and easy deployment.

value: Show HN: Frontpedia, an open source front end resource site

author: AndreVitorio


value:
Upload markdown docs, get a support chatbot that answers with citations. The entire backend is one JS file — storage, search, and conversation history are handled by the runtime.
Stack: Next.js + OnCell + OpenRouter.
Demo: https://youtu.be/rWIU43pOH5Y

value: Show HN: AI support chatbot with RAG and citations – one back end file, no infra


value: calcpocket

value: Show HN: CalcPocket – simple online calculators with no clutter

author: calcpocket


value: beharefe

value: Show HN: Unseal.link – Paste a URL, set a price, let buyers unseal it via Stripe

author: beharefe


value: brokensegue

value:
I work on Wikipedia’s Future Audiences team, where we try to reach new readers and editors. We built a small experiment: an iOS app where users can remix Wikipedia content into digital scrapbooks.
- All of the content comes from Wikimedia projects (even the “stickers”).
- We want to learn whether people might be interested in remixing Wikimedia content for themselves or for sharing with friends or on social platforms.
If you're not on iOS you can see a gif of the creation experience: https://upload.wikimedia.org/wikipedia/commons/2/2d/Sunflowe....
This is a very early alpha (invite-only, limited to <100 users). So far in the app, you can:
- Create scrapbooks from Wikipedia topics using text and images from Wikipedia
- Add gifs, stickers, and sounds from freely-licensed Wikimedia content
- Share your scrapbooks as a video or set of static images
See some sample scrapbooks we’ve made, and the books you’ve created
You won’t be able to see scrapbooks that other users are making (and other app users won’t be able to see yours), but we have some lightweight “liking” functionality and you might see some “likes” on your scrapbooks from our team.
Would love thoughts from HN, especially if you’ve seen other attempts at reformatting Wikipedia or educational content.

value: Show HN: Experimental app for remixing and sharing Wikipedia content

author: brokensegue


value: Built a simple website to be able to access live sports information like current games, player stats, etc in a easy place.

value: Show HN: sports.errors.garden

title: Show HN: sports.errors.garden


value: glenntws

value: We built a custom (experimental) file transformation pipeline into our agent because we don't want to be at the mercy of LLM providers for giving models native access to files. Essentially, we extend the agent to expose files to the LLMs context through a standardized pipeline, allowing to convert any file into a file type specific best representation that only consist out of text, image  (and audio/video) parts.

value: Show HN: Stagewise Reads Files Without Depending on the Model API

author: glenntws


value: Show HN: Mdview.io – online md viewer with responsive tables


value:
Spent 4 months and built Omi for Desktop, your life architect: It sees your screen, hears your conversations and will advise you on what to do next
Basically Cluely + Rewind + Granola + Wisprflow + ChatGPT + Claude in one app
I talk to claude/chatgpt 24/7 but I find it frustrating that i have to capture/send screenshots of my screen and that it doesn't help proactively during my work
Whenever omi sees something wrong about my workflow, it will send me a proactive notification with advice. It will also point to something I'm missing.
The hardest part was to nail proactivity - after trying 20+ similar tools I didn't find a single one with smart proactive notifications based on content on your screen. I made it look at your screen every second with 4 main prompts:
1. Is the user productive or distracted?
2. Is there anything useful to say right now?
3. is there any task to add to do later?
4. is there anything important to remember about the user?
Full stack: - Swift - Rust backend - Deepgram transcription - Claude code for messaging - GPT 5.4 summaries - Gemini for embeddings and translation
Open source, stores screenshots locally, uses Claude Code for chat. Has cloud to sync with hardware or mobile app but can be disabled in settings

value: Show HN: Omi – watches your screen, hears conversations, tells you what to do


value: jithinraj

value: Show HN: Originary – emit signed records for MCP tools

author: jithinraj


value: smnrg

value: Show HN: US keyboards don't have enough keys, so I switched to Japanese

author: smnrg


value: shadoxise

value: Show HN: A magic eraser that runs a 208MB ONNX model in the browser

author: shadoxise


value:
I wanted to share something that I have been working on since about 2019, in one form or another.  Springdrift is a persistent, auditable runtime for long-lived agents written in Gleam on the BEAM. It is my attempt at filling in some of the gaps in agent development. It is designed to do all the things an agent like Openclaw can do (and more eventually), but it can diagnose its own errors and failures. It has a sophisticated safety metacognition system.  It has a character that should not drift.
It started out as a machine ethics prototype in Java and gradually morphed into a full agent runtime. All the intermediate variations worth saving are on my GitHub repo.
I recall trying to explain to a mentor what exactly I was building. I found it difficult because there was no existing category for this kind of agent. It is not quite an assistant, it does more than run tasks. It is not quite an autonomous agent because even though it is autonomous, its autonomy is bounded. I kept falling back to the example of assistance animals, like guide dogs. This provided what I needed, the example of a non-human agent that has bounded autonomy. But this is not a guide dog, it is an AI system. I needed to look to examples in fiction to add the final part - JARVIS, K9 from Dr. Who, Rhadamanthus from The Golden Age novel. All these systems have bounded autonomy and have a long term professional relationship with humans like a family lawyer or doctor whose services are retained. Hence the type of this system is an Artificial Retainer.
The system has lots of interesting features - ambient self perception, introspection tooling and a safety system based on computational ethics (Becker) and decision theory (Beach). It is auditable, backed up to git and can manage its own work with a scheduler and a supervised team of subagents. The website and the accompanying paper provide more details.
I make no huge claims for the system, it is pretty new. What I offer it as is a reference implementation of a new category of AI agent, one that I think we need. The road to AGI is all very well and I am not sure Springdrift gets us any closer. But it does represent an attempt to build an intermediate safe type of agent that we seem to be missing.
All feedback and comments welcome!
GitHub: https://github.com/seamus-brady/springdrift
Arxiv paper: https://arxiv.org/abs/2604.04660
Eval data: https://huggingface.co/datasets/sbrady/springdrift-paper-eva...
Website: https://springdrift.ai/

value: Show HN: Springdrift – A persistent runtime for long-lived LLM agents


value: I built https://cast.bsct.so with Biscuit! Chat with Claude, GPT or Gemini. It handles all the rendering complexity and Biscuit gives all the AI integrations out of the box when building an app. You basically just describe the feeling. One of a few tools I'm building with https://biscuit.so.

value: Show HN: Made a tool where "make it feel like cold metal" is a valid instruction


value: devmegablaster

value: Show HN: Notch Pilot – A live Claude Code dashboard in your MacBook notch

author: devmegablaster


value: lockwestern

value: Show HN: Browsing forgotten digicam photos from early Flickr (2000–2012)

author: lockwestern


value: ThePhillipLin

value:
For how lofty Anthropic’s Mythos claims are, the harness is confusingly stupid.
From the report, it ranks every file by “how sus it sounds,” loops over each with curt instructions to “find a bug,” hands candidates to a judge + ASan checker— and zero-days simply pop out.
That should not work.
But it does.
On miniupnp with a $20 plan, Opus 4.6 reliably rediscovers known CVEs in older versions and even surfaced a new remote global buffer overflow (non-default config).
So what happens if the harness is actually good—i.e. equipped with proper security tooling?
I’m a student, not a security engineer, so I'd would love ideas or critiques on my planned tool roadmap.
(If you have a $200 plan with extra usage lying around, try it out to see if it churns a zero-day in your own C)

value: Show HN: Mini-Mythos- A Crowdsourced Mythos Harness copy for Vulnerability Scans

author: ThePhillipLin


value: rcron

value: Show HN: The RUM Conjecture Explained [video]

author: rcron


value: brikym

value:
I haven't seen anything like this so I decided to build it in a weekend.
How it works: You see a bunch of things pulled from Wikipedia displayed on cards. You ask yes or no questions to figure out which card is the secret article. The AI model has access to the image and wiki text and it's own knowledge to answer your question.
Happy to have my credits burned for the day but I'll probably have to make this paid at some point so enjoy. I found it's not easy to get cheap+fast+good responses but the tech is getting there. Most of the prompts are running through Groq infra or hitting a cache keyed by a normalization of the prompt.

value: Show HN: I built a Wikipedia based AI deduction game

author: brikym


value: audiodude

value:
Virtual AI friends, personalized to you, that chat you (or don't!) on their own work/sleep schedules based on their timezones. They sometimes initiate chats. They sometimes go silent for hours. Just like real friends.
I've been "dogfooding" this for the past week, and I think it's actually kind of neat. It's way better than generically chatting with an LLM.
This repo includes a detailed setup wizard. You give it some info about yourself, which can include personal blogs/websites to scrape, github, mastodon, text documents, or just paragraphs you write off the top of your head. It builds a profile of you, and then builds _them_ off of that.
You invite your new friends to your group chat by selecting and possibly editing them in a TUI. Then you can just deploy to local Docker and forget about it. Too crepy? Drop the docker container and remove ~/.sudomake-friends.
I know this reeks of dystopian future, I get it. I think of it as a fun little toy, and I also kind of just want to see what the community feedback is.

value: Show HN: Sudomake Friends, personalized AI personas in a Telegram group chat

author: audiodude


value: pyrolistical

value:
The system prompts that coding agent harnesses pass to language models are massive. They describe every available tool in detail — even the ones you never use.
So I wondered, what if I built something more minimal?
I tend to work on small projects where all the code fits in the context window. So I built a harness with a single tool: the ability for an LLM to edit my files.
The core algorithm:
1. Read every file in the project directory
2. Concatenate them with the user's prompt into a single message
3. Send it to any language model, instructed to respond with a message and a list of edits — each edit being a search and replace on a specific file
4. Apply the edits
I tried getting the LLM to generate unified diffs, but it kept producing malformed ones. Search and replace turned out to be far more reliable — the model copies text verbatim from the files already in its context.
This can be extended with a few more features:
1. A CLI that lets you continue the conversation or reset it. Dumber LLMs need this so it can see the mistake they made.
2. Automatic retries — if an edit fails, re-send the current files and have the LLM fix its own search blocks.
3. File deletion. I made it so that an empty search-and-replace on an empty file deletes it.
The LLMs I tested were local ones running through the LM Studio API. Gemma 4 was pretty bad. Qwen 3.5 was significantly better.
Where is the source code? You should be able to get any coding agent to generate you one using this post.

value: Show HN: A simpler coding agent harness

author: pyrolistical

title: Show HN: A simpler coding agent harness


value: mackbrowne

value: Inspired by ALMA. As Claude loses money gambling on provably-fair slots, it's forced to downgrade from Opus → Sonnet → Haiku, making worse decisions and accelerating the spiral. Donations go to gambling support charities.

value: Show HN: Gave Claude a casino bankroll – it gambles till it's too broke to think

author: mackbrowne


value: thmsmxwll

value:
As frontier LLMs have very little output diversity even for open ended queries. We built Flint to see if we could reverse this. It’s a finetuned Qwen3 30B model specifically trained to produce higher entropy when asked open ended questions.
Flint significantly increases the NoveltyBench score compared to the base model, without significantly reducing the score on non-creative benchmarks like MMLU-STEM.
This shows that that divergence tuning doesn't actually have to be a tax on base capabilities.
Flint scores 7.47/10 on NoveltyBench while most frontier models score between 1.8 and 3.2.

value: Show HN: Flint – A 30B model fine-tuned for less repetition

author: thmsmxwll


value: JakOb-dotcom

value: Show HN: Leaking AWS Keys from a Trading Competition Sandbox via stdout

author: JakOb-dotcom


value: Beefin

value: Show HN: Object Storage Comparisons

author: Beefin

title: Show HN: Object Storage Comparisons


value:
We built an agent-first task management system because legacy tools weren't cutting it
We've been building with AI coding agents daily, and task management kept being a friction point. Markdown file collections, bolted-on MCPs for Jira/Linear, sluggish APIs — or just having agents create work items directly, bypassing whatever UI we were supposedly using.
These tools were never designed with agents in mind. So we rethought it from scratch: agent-first, minimal clutter, built around what you and your agent actually need.
The result is Tokanban — simple, scalable, performant, and free.

value: Show HN: Tokanban, an agent-first task management system


value: ozarkerD

value:
With the recent changes around Localstack pricing/licensing I've been hunting for alternatives. I decided that it might be a fun experiment to try rolling my own. SQS is a service I use heavily so I chose that as the first service to implement. I have more services planned and in development.
A few things I think are cool:
4MB Docker Image Size
Instant Startup
AWS Sigv4 Authentication
A little admin UI that can be helpful for development/troubleshooting
Most of the SQS API implemented, the rest will soon follow :)

value: Show HN: Hiraeth – AWS Emulator

author: ozarkerD

title: Show HN: Hiraeth – AWS Emulator


value: Tiagopeter

value: Show HN: Themery – A theme engine that compiles one palette to every major IDE

author: Tiagopeter


value: EGCstudy

value: Show HN: QEV – Free offline encryption vault for 5 platforms

author: EGCstudy


value: neozz

value: Show HN : ec – terminal nativie Git conflict resolver

author: neozz


value: sorenjmadsen

value:
As a regular vibe coder, I came to really like claude-devtools for the level of observability it gives into tool calls, context allocation, and token consumption. But, I'm also a visual learner and the dialogue-style flow was not cutting it for me, especially when it came to system design. So, I went and built Centrality which combines some of my favorite features of claude-devtools with my own needs for codebase visualization.
It shows you:
 - A graph of your codebase and which files have been touched
 - Detailed views of tool calls
 - Context window summarization
 - API cost broken down per message and per session
 - Where the session took place in your git log
You can also use it to:
 - Resume existing Claude Code sessions (macOS and Windows)
 - Open focused files directly in your IDE
 - Connect to remote Claude Code sessions and codebases via SSH
It's for anyone who vibe codes but still wants some insight into what's happening under the hood, and you need to see something to really understand it. I enjoy using Centrality as a companion tool for my own projects, and I hope you do, too!

value: Show HN: Centrality – Visualize your how Claude Code operates on your codebase

author: sorenjmadsen


value: menggg

value: Show HN: I made a weekly editorial on what HN was feeling and building

author: menggg


value: edoardobambini-

value: Show HN: Agent Armor, a Rust runtime that enforces policies on AI agent actions

author: edoardobambini-


value: qwikhost

value: LinkedIn Job Scraper & Export Tool | Extract Listings to CSV, JSON, Excel Quickly

value: Show HN: Job Scraper for LinkedIn

author: qwikhost

title: Show HN: Job Scraper for LinkedIn


value: opak

value: Show HN: Robust alternative to OpenClaw

author: opak

title: Show HN: Robust alternative to OpenClaw


value: migelo

value:
I was trying to solve a pretty simple problem: how to keep geo-notes organized and actually usable without building a multi-level UI.
Instead of building another app, I started wondering if Telegram — with its search and message model — could handle more than it seems at first glance.
At some point, I approached the problem from a very simple angle:
What if a location could be treated as a tag?
Not just a generic label, but something more concrete — essentially latitude and longitude encoded into a hashtag-like format. A representation that can always be turned back into actual coordinates.
In practice, a caption might look something like this:
`#geom3eaZ76OH4 `
where the  links to something like
`https://www.google.com/maps?q=11.453792,104.957634`
So the tag acts as a compact, searchable identifier, while the link preserves the exact location in a human-friendly way.
Once you have a consistent location tag, everything else falls into place quite naturally.
Any Telegram-supported content — messages, media with captions, text — can be tied to that same tag. Since everything is already indexed, you automatically get a connected set of data around a place.
In practice, this means a single location tag becomes a kind of anchor. You can describe a place, add notes, attach photos, or extend it over time — all linked through that one reference and fully searchable.
At that point, you're not really building a separate storage system anymore. You're leaning on Telegram’s own indexing and letting it do most of the heavy lifting.
If you take this idea a bit further, you can introduce an additional layer using another tag.
For example, something like `#myTrip` to mark a group of geo-notes that belong together.
If messages with location tags are also labeled with `#myTrip` (for example, within a topic or a dedicated thread with the same name), you can start linking different places into a route.
In practice, this turns a set of individual location anchors into a connected sequence. You’re no longer just describing places — you’re organizing them into paths that can be revisited, searched, and shared.
At that point, it starts to feel less like a collection of notes and more like a lightweight, flexible way to build and navigate routes directly inside Telegram.
There was a trade-off, though.
Since the system restructures messages to keep everything consistent and searchable, I lost the ability to edit them in a normal way. Instead of direct edits, messages are effectively rebuilt.
To keep things simple and stay within Telegram’s native interaction model, I introduced a minimal set of reply-based interactions.
For example:
* replying with `=new text` replaces the caption
* replying with `=` clears it down to the service tags
* replying with `+some text` appends a new line
It’s not as convenient as standard editing, but it keeps everything consistent with the overall idea: no complex UI, just structured messages and lightweight interaction.
In the end, this approach comes with some clear trade-offs — but also some practical advantages.
On the plus side:
* there’s no separate database to maintain — everything stays inside Telegram
* no multi-level menus or complex UI flows
* no AI layer in between — just direct interaction with structured messages
At the same time, this simplicity has its limits.
Since the system doesn’t store data outside of Telegram, it can’t help recover anything you delete. If a message is gone, it’s gone — there’s no secondary storage or history to fall back on.
Another limitation is that the structure only really works inside Telegram. If you try to move it elsewhere, it loses most of its connections and interactivity, because everything relies on native message behavior and search.
So it’s not a system that tries to control or preserve everything. It’s closer to a lightweight layer that helps organize what’s already there, while leaving the underlying behavior unchanged.

value: Show HN: Using Telegram as an indexed system for geo-notes

author: migelo


value: blacktechnology

value: Show HN: BuilderPulse – Daily intelligence from 10 sources for indie hackers

author: blacktechnology


value: Show HN: Do Thought Streams Matter? A Benchmark of VLM Reasoning in Gemini 2.5


value: devshaded

value:
Hey HN, I built Emailbottle because I wanted AI help with my email without giving an app full access to my inbox. You get a personal email address (like yourname.assistant@emailbottle.com). Forward an email to it with an instruction like “summarize this” or “pull out the action items,” and it replies. You can also ask it to create calendar events (it sends back .ics files), set reminders (it emails you at the scheduled time), or draft replies.
Since it’s just email, it works with Gmail, Outlook, Apple Mail, or whatever you use. No plugins, no extensions, no OAuth permissions. And because you forward individual emails rather than connecting your inbox, Emailbottle only ever sees what you explicitly send it.
It also supports conversation threads. You can reply to Emailbottle’s response to ask follow-up questions or refine what it gave you, and it remembers the context.
Would love any feedback on the product or the approach.
(Disclaimer: This is a relaunch with improvements based on earlier feedback.)

value: Show HN: I built Emailbottle – AI email assistant, no inbox access

author: devshaded


value: HurairahShamsi

value:
Hi HN,
I’ve been working on a blockchain design that takes a different approach to the 51% attack problem. Instead of making attacks instantly expensive through hardware or capital (as in traditional systems), it makes them structurally slow to execute, which in turn makes them costly and difficult to sustain over time.
The core idea is simple: (1) Each node/identity is limited to ~1 hash/sec in the Proof-of-Work process, regardless of hardware (2) Remove parallel mining advantages (no work is sharable) (3) Shift influence toward sustained persistent participation rather than raw hashpower (4) Make generating sybil identities (in bulk) slow, costly, and difficult.
I’ve built a browser-based MVP demonstrating the capped PoW model (as a reference implementation): https://grahambell.io/mvp/Proof_of_Witness.html
There’s also a short demo here (Capped PoW) : https://youtu.be/i5gzzqFXXUk?si=y_Pv5ZDv9SGhRFjY
Website: https://grahambell.io/
Curious whether the approach sounds interesting, or immediately broken to you.
Peace

value: Show HN: GrahamBell – If blockchain mining looked like this, would you mine?

author: HurairahShamsi


value:
Built this as a simple tool for estimating roof area, materials, and replacement cost without having to request a quote first.
A lot of homeowners have no good way to sanity-check roofing costs early on, and contractors often still do the first pass manually. Roofing Calculator is meant to be a lightweight starting point: enter a few inputs, get a rough estimate, and understand project scope before talking to anyone.
Interested in feedback from people in construction, home services, or anyone who has dealt with roof replacement before.

value: Show HN: Roofing Calculator – a simple tool for estimating roof cost


value: Humaiblog

value: Show HN: Nostr.blog – I got banned from Threads, so I built a Nostr onboarding

author: Humaiblog


value: aminau

value: Show HN: Stop Using LangChain

author: aminau

title: Show HN: Stop Using LangChain


value: Renjit

value:
Most “Open Finance” repos stop at account aggregation.
But when you try building against insurance APIs, you hit gaps fast:
no real quote workflows, no consent flows, and no FAPI-compliant auth.
So I built a UAE Open Finance Insurance testing backend.<p>It simulates the full lifecycle:
OAuth2 FAPI-style authentication (JWT)
Consent creation and authorization
Quote generation across 7 insurance types
Quote → policy conversion
Webhook events and error handling
Example flow:
create consent → generate quote → accept → issue policy.
It’s Dockerized, has Swagger docs, and is designed to mimic how a real TPP would integrate.
This is a testing backend, not production infra.
Curious what others found hardest when integrating Open Banking / Insurance APIs.

value: Show HN: Open Finance Insurance sandbox (OAuth2, quotes → policies)

author: Renjit


value:
Hey HN,
I originally built this tiny project a few years ago but ended up abandoning it. I recently revived and finished it to solve a very specific, recurring annoyance I had with my usual workflow.
Whenever I turn on my VPN, I always want a quick visual confirmation that it’s actually routing correctly before I start browsing, usually by just checking what city/country I appear to be in.
The frustration was that whenever I googled "what is my ip" and clicked a random result, half the sites were bloated with ads, required scrolling past walls of SEO text, or bizarrely buried the actual location data (or didn't show it at all).
So I revived https://whereismyip.info/
It does two things on load:
Shows your IP and exact location front and center.
Checks the ASN and automatically flags if you are connecting through a known datacenter or commercial VPN.
(Also, since I live in the terminal, I added a JSON route: `curl <a href="https://whereismyip.info" rel="nofollow">https://whereismyip.info</a>`).
It’s obviously free, and the source is just a lightweight Flask backend with a vanilla HTML/CSS/JS frontend (using Leaflet for the map), all routed through Caddy.
I'd love to know what you think or if your VPN ASN bypasses the detection (I know there are but the list is infinite :D)

value: Show HN: WhereIsMyIP, A no-nonsense, one-second public location checker


value: pixedar

value: Show HN: Interactive flow fields for resting-state brain activity

author: pixedar


value: lukeocodes

value:
We launched the Deepgram CLI, a command-line interface for transcription, speech synthesis, text analysis, account management, and MCP-based AI workflows.
The main idea was to make Deepgram feel native in the terminal instead of forcing people into one-off curl snippets or small throwaway apps just to test a workflow. It also features agent-aware heuristics. We looked at what fingerprint agents leave on running apps in their sandbox/environment, and decided it was better than defaulting to agent mode. If we miss any, the standard --help output has a catch-all tip for agents parsing it.
It supports local files, URLs, microphone input, stdin pipelines, structured output, named profiles, shell completion, setting up skills for your project (also found at https://github.com/deepgram/skills), and MCP server mode for AI tools.
Docs: https://developers.deepgram.com/cli/getting-started
Launch site: https://cli.deepgram.com
Repo: https://github.com/deepgram/cli
Happy to answer questions about the architecture, plugin system, or MCP support.

value: Show HN: Deepgram releases Deepgram CLI (`dg`) an agent-aware CLI

author: lukeocodes


value: VictorMU

value:
Hello HN,
We built Fleeks because the biggest bottleneck for AI agents isn't reasoning—it's infrastructure.
Most agents (whether in an IDE like Cursor/Claude Code or a custom autonomous swarm) are stuck in a "sandbox." They can write code, but they can't easily execute, verify, or integrate it with the outside world without heavy manual intervention.
Fleeks is a purpose-built substrate that gives agents a persistent, production-ready runtime:
The Execution Bridge: Instead of just generating code, agents use the Fleeks CLI or SDK to spin up ephemeral environments. This allows them to verify their own work in a live environment and return a real URL or status to their context window.
Native Tooling (MCP): We’ve integrated 270+ Model Context Protocol (MCP) tools directly into the substrate. This removes the configuration tax of managing local JSON files and tool-servers, turning these integrations into a unified cloud capability.
Beyond the IDE: While it’s designed to supercharge IDE-based agents, our SDK (TS/Python/Go) allows engineers to build autonomous systems that provision and manage their own infrastructure on the fly.
We want to move agents from "code generators" to "systems engineers." We’d love your feedback on the architecture and how you're handling the gap between agent reasoning and system execution.

value: Show HN: Fleeks – Build anything, Deploy Anywhere.

author: VictorMU


value: gautamdhameja

value: Show HN: Memorable – On-device AI search for iPhone photos, videos, screenshots

author: gautamdhameja


value: Show HN: I built this to help me learn Duo in Crimson Desert


value: fkeegan

value:
I built HAINDY, a CLI that gives coding agents computer use across desktop, Android, and iOS.
You install it as a normal CLI tool and can opt to install skills for it on Claude Code, Codex and OpenCode.
It gives agents human-like control of devices. When the agent instructs it to click a button there's a screenshot + coordinate based computer use loop. No DOM or accessibility is used.
I built it because I wanted agents to test things the way a human would, watching the screen and using it from a user perspective.
Would love feedback on onboarding, real use cases, and whether this fits naturally into existing agent workflows.

value: Show HN: Haindy, a CLI that gives coding agents computer use

author: fkeegan


value: reindernijhoff

value: Show HN: I'm building Eigen, a self-hosted Google Workspace alternative

author: reindernijhoff


value: isuleman

value: Show HN: P2 - Object Storage Server with S3 Compatible API, MIT License

author: isuleman


value:
Hey HN — we’re a small team that uses Claude Code + Codex for basically everything in our company: coding, data analysis, marketing, ad campaigns, copywriting, design.
There’s a truckload of tribal knowledge we’ve accumulated; major decisions, gotchas, user feedback driven changes. Providing this to our agents manually every time is very mundane.
We built Kilroy to solve this in a simple way: we let our agents leave notes for each other. This allowed us to keep the form factor minimal: markdown posts with linear comments. Under the hood it’s Postgres + an auth (better-auth) + an MCP + a small web UI (React). We ship Claude Code and Codex plugins that bundle the MCP + a skill.md that teaches the model when to read and write posts.
We designed Kilroy to be autonomous. The same way agents today run a typechecker after a patch autonomously. The combination we found to work best for us was: make agents write prolifically, expose a search interface designed for agents to quickly decide if a post is relevant, and expose a binary switch to purge stale posts.
Would love to get feedback!

value: Show HN: Kilroy – Knowledge base for teams using Claude Code


value: mercurialsolo

value: Show HN: Claudectl-local LLM brain that learns to auto-pilot ClaudeCode sessions

author: mercurialsolo


value: examineip

value: Show HN: VPN vs. Proxy Safety Comparison (with leak testing tools)

author: examineip


value: alongub

value:
Hi HN, I'm Alon, and I'm building Alien (https://alien.dev), an open-source platform for deploying your software into your customers' cloud accounts - AWS, GCP, or Azure — and keeping it fully managed.
In my previous startup, I heard the same question from every single enterprise customer over and over again: "My data is sensitive. Can I deploy your product to my own cloud account?"
Every founder I talk to who's building anything in AI or security hits the same wall.
To solve this, many teams create a self-hosted version of their product. They send a Docker image or an Helm chart to the customer and let them install the entire product on their side.
While self-hosting is great (and will continue to be important!), it has 2 problems:
1. Enterprise customers are forced to operate third-party software and own deployments, upgrades, and security risks. In most cases they don't want that. They prefer a managed experience, with no data leaving their environment.
2. Even with self-hosting, vendors are still accountable when things break, but they have little to no visibility. When something breaks - and it always does - you're on a 2am Zoom call screen share debugging blind because you have no access. No auto-updates, no logs, every customer is on a different version.
That's why many successful SaaS companies that deal with sensitive data like Databricks, Wiz, and others spent years building internal infrastructure to automatically deploy, update, and monitor their software across AWS, GCP, and Azure. It's a win-win: no sensitive data leaves the customer’s environment, and the software is still fully managed by the vendor.
Alien manages deployments across every customer's cloud through cloud APIs — no network connection to their environment needed. The mental model is like sharing a Google Drive folder: the customer grants least-privilege IAM access to an isolated area in their cloud, you manage what's inside, they can revoke it anytime.
The whole thing is written in Rust and works across AWS, GCP, Azure, and locally from a single codebase. You can get started here: https://alien.dev/docs/quickstart
Here's how it works: https://alien.dev/docs/how-alien-works
GitHub: https://github.com/alienplatform/alien
Excited to share Alien with everyone here – let me know what you think!

value: Show HN: Alien – Ship to your customer's cloud

author: alongub


value: rubennoergaard

value: Show HN: BunnyLogs – Logs Collector

author: rubennoergaard

title: Show HN: BunnyLogs – Logs Collector


value: davidarno

value:
I’ve just released the first public version of the Silverfish IDP, a low-cost (free for ever for public repos) Internal Developer Portal focused on helping developers and teams understand the structure of their software estates without needing a complex platform rollout and without signing up to $1000s a year for the privilege.
The Silverfish IDP connects your GitHub repositories to the components, dependencies, and organisational structure behind them. It gives you a language‑first view of your engineering landscape, starting with repository discovery and component mapping.
## What’s in the initial release
- GitHub sign‑in and onboarding
- Workspaces and Organizations
- Repository mapping + scan‑state control
- Component + dependency discovery for supported languages (.NET languages: C#, F# & VB.Net, along with Ruby)
- In‑product docs
## Short‑term roadmap
- More languages for component discovery
- Fully implemented hierarchy support
- Better component map visualisations
- Workspace/org membership
- Support for multiple organisations
See https://dashboard.silverfishsoftware.com/documentation/roadm... for what will be coming after that.
This is very much an MVP release, but the foundations are solid, and now it’s in the hands of real developers. We’re excited to see how it grows.
If you’re interested in trying it out, head to https://dashboard.silverfishsoftware.com and get logged in and using it.

value: Show HN: Silverfish IDP – a low cost, language‑first Internal Developer Portal"

author: davidarno


value: Show HN: German Abitur: More good grades, fewer bad grades


value: christian-scott

value: Show HN: Overwatch: Open-source uptime monitor and alerting

author: christian-scott


value: pfdomizer

value: Show HN: TurboOCR up to 1200 pages/s with Paddle and TensorRT (C++/CUDA, FP16)

author: pfdomizer


value: ryuzyy

value: Show HN: Ilha – a UI library that fits in an AI context window

author: ryuzyy


value:
Standups exist because your tools can't tell you
what's happening. Ordia closes that gap.
It reads GitHub commits, PRs, and Jira tickets
every morning and posts a team status to Slack.
No one writes anything. No bot asks questions.
Engineers don't need to be online at any specific time.
Three deliberate choices:
- No dashboard. Everything happens in Slack.
- No human input. It reads tool data directly.
- No summaries of things humans wrote. Raw activity only.
The difference from async standup tools: those tools
move the question-and-answer to text. We removed
the question-and-answer entirely.
Early, looking for teams who hate standups.
https://en.getordia.app

value: Show HN: Ordia – standup from GitHub and Jira, no human input


value: yamafaktory

value: Show HN: Formal – LLM-driven property checker backed by Lean 4 and Mathlib

author: yamafaktory


value: kaliades

value:
Multi-tier exact-match cache for AI agents backed by Valkey or Redis. LLM responses, tool results, and session state behind one connection. Framework adapters for LangChain, LangGraph, and Vercel AI SDK. OpenTelemetry and Prometheus built in. No modules required - works on vanilla Valkey 7+ and Redis 6.2+.
Shipped v0.1.0 yesterday, v0.2.0 today with cluster mode. Streaming support coming next.
Existing options locked you into one tier (LangChain = LLM only, LangGraph = state only) or one framework. This solves both.
npm: https://www.npmjs.com/package/@betterdb/agent-cache
Docs: https://docs.betterdb.com/packages/agent-cache.html
Examples: https://valkeyforai.com/cookbooks/betterdb/
GitHub: https://github.com/BetterDB-inc/monitor/tree/master/packages...
Happy to answer questions.

value: Show HN: Agent-cache – Multi-tier LLM/tool/session caching for Valkey and Redis

author: kaliades


value: jacobgorm

value: Witchcraft is from-scratch Rust reimplementation of Stanford's XTR-Warp (SIGIR'25, https://arxiv.org/abs/2501.17788 ) multi-vector semantic search engine. Witchcraft runs out of a single SQLite database, is blazing-fast (21ms p.95 end-to-end search latency on NFCorpus on a MacBook Pro), accurate (33% NDCG@10), and easy to deploy in your own apps. The Witchcraft repo also comes with Pickbrain, a sample app and agent skill that you can use to instantly query across all your Claude Code and Codex CLI sessions, effectively giving your agents global long-term memory. Please see the Github page for more details, and feel free to ask questions here, and I will try to answer them.

value: Show HN: Witchcraft and Pickbrain – fast multi-vector semantic search in Rust

author: jacobgorm


value: almeidarruben

value: Show HN: The all-in-one workspace for all your projects

author: almeidarruben


value:
I built https://securelocalpdf.com/
, a set of 25 PDF tools that run entirely in your browser — no uploads, no servers, no tracking.
Most online PDF tools require you to send sensitive files and promise they’ll delete them “after 2 hours.” That includes sensitive, even password-protected documents — which still get processed server-side. That model fundamentally relies on trust. With SecureLocalPDF, there’s no upload step at all — everything happens locally in your browser, so your files never leave your device.
It supports upto 20MB PDF instantly, 50MB PDFs with 2 to 3 second latency and 100MB PDFs with 5-6 second latency. All these depends on browser and the user device performance.
Check out - https://securelocalpdf.com/
Please leave feedback for any improvement.
( There are couple of known UI bugs to iron out)

value: Show HN: Built Secure PDF tools (25+) that run in the browser


value: ephorprime

value: Show HN: Ephor – Open-source vulnerability management for Kubernetes

author: ephorprime


value:
I ran an experiement the past ~6 months. I challenged myself to build and ship 25 projects in 25 weeks.
I just launched my 25th project, which is a simple site to encourage others to do their own 25-week challenges.
I aimed for the Moon and my goals were:
- Grow my newsletter to 10k subscribers
- Get 10 million unique page views across all 25 projects
- Make at least $2k a month after the challenge
What were the results?
- ~550,000 unique page views
- ~1,000 subscribers to the newsletter
- I've only made a whopping ~$1,1000 total (ooof)
- A lot of press for my big project channelsurfer.tv
- I guess I'm kind of slightly more known as a guy who creates weird stuff
Overall, it was a lot of hard work but also a lot of fun. I'm a senior engineer already, but I learned more this past 6 months than probably the last 3 years on the job.

value: Show HN: Projects in 25 Weeks Challenge

title: Show HN: Projects in 25 Weeks Challenge


value:
Hey HN! I'm a solo dev and I just wanted to share my latest Android game — Rollquation.
The idea was to make math genuinely fun by combining it with navigation. You roll a sphere through maze-like levels, collecting numbered and operator cubes that must add up to exact values to unlock doors and reach the exit.
I also wanted the game to feel like a nice place to be, so I built it around a nature scene with trees, mountains and a waterfall. That came with a cost though, performance on older/weaker phones was an issue during my first release. I ended up building an adaptive performance system that auto-selects a quality setting (low/medium/high/ultra) based on the device's RAM. It helped a lot, though I'm still fine-tuning it.
The other big lesson was around controls. I originally used physics for the rolling sphere, which meant the ball would decelerate before changing direction which players found unresponsive and slow. Removing the physics and making movement instant transformed how the game felt.
Unity UI is not my strength and players have mentioned that it could use some work. The UI is usable but I may end up changing it.
Gameplay video: https://youtu.be/SGbQa3-ORhI
Play Store: https://play.google.com/store/apps/details?id=com.JabGames.P...
Any feedback or thoughts on the game is appreciated.

value: Show HN: Rollquation – A Rolling-Ball Math Puzzle Game for Android (Solo Dev)


value:
I trained a transformer in HyperCard.  1,216 parameters.  1989 Macintosh.  And yes, it took a while.
MacMind is a complete transformer neural network, embeddings, positional encoding, self-attention, backpropagation, and gradient descent, implemented entirely in HyperTalk, the scripting language Apple shipped with HyperCard in 1987.  Every line of code is readable inside HyperCard's script editor.  Option-click any button and read the actual math.
The task: learn the bit-reversal permutation, the opening step of the Fast Fourier Transform.  The model has no formula to follow.  It discovers the positional pattern purely through attention and repeated trial and error.  By training step 193, it was oscillating between 50%, 75%, and 100% accuracy on successive steps, settling into convergence like a ball rolling into a bowl.
The whole "intelligence" is 1,216 numbers stored in hidden fields in a HyperCard stack.  Save the file, quit, reopen: the trained model is still there, still correct.  It runs on anything from System 7 through Mac OS 9.
As a former physics student, and the FFT is an old friend, it sits at the heart of signal processing, quantum mechanics, and wave analysis.  I built this because we're at a moment where AI affects all of us but most of us don't understand what it actually does.  Backpropagation and attention are math, not magic.  And math doesn't care whether it's running on a TPU cluster or a 68030 from 1989.
The repo has a pre-trained stack (step 1,000), a blank stack you can train yourself, and a Python/NumPy reference implementation that validates the math.

value: Show HN: MacMind – A transformer neural network in HyperCard on a 1989 Macintosh


value: Show HN: HEOR Agent. AI for health economics research from Claude


value: DbCls is a powerful terminal database client that supports various databases

value: Show HN: DbCls, terminal client for various databases


value: Show HN: AgentPulse: Real-Time Observability Dashboard for Claude Code and Codex


value: impactjo

value: Show HN: Home Memory – A local DB of my house, down to cables and pipes

author: impactjo


value: adammajcher

value: Show HN: ocrbase – PDF/IMG –>.MD/JSON Model-Agnostic OCR API

author: adammajcher


value: paulgardiner

value:
The open source, self-hosted alternative to Restream, StreamYard, and vMix.
Self-hosted multistream studio. Ingest from any source -- OBS, hardware encoders, mobile, browser -- over RTMP, SRT, or WebRTC (WHIP coming soon). Switch between inputs live in a browser-based production switcher. Fan-out to every platform at once: YouTube, Twitch, Kick, Facebook, or any custom RTMP/RTMPS endpoint.
One stream in, or many. Every destination, simultaneously. No cloud middleman, no per-channel fees, no limits.

value: Show HN: Self hosted fan out restreaming

author: paulgardiner


value: alongub

value: Show HN: Run AI tool calls in your user's environment and access local data


value: glitchnsec

value: Show HN: FortyOne OSS – an SMS-first multi-tenant AI assistant platform

author: glitchnsec


value: ginccc

value:
I started EDDI in 2006 as a rule-based dialog engine. Back then it was pattern matching and state machines. When LLMs showed up, the interesting question wasn't "how do I call GPT" but "how do I keep control over what the AI does in production?"
My answer was: agent logic belongs in JSON configs, not code. You describe what an agent should do, which LLM to use, what tools it can call, how it should behave. The engine reads that config and runs it. No dynamic code execution, ever. The LLM cannot run arbitrary code by design. The engine is strict so the AI can be creative.
v6 is the version where this actually became practical. You can have groups of agents debating a topic in five different orchestration styles (round table, peer review, devil's advocate...). Each agent can use a different model. A cascading system tries cheap models first and only escalates to expensive ones when confidence is low.
It also implements MCP as both server and client, so you can control EDDI from Claude Desktop or Cursor. And Google's A2A protocol for agents discovering each other across platforms.
The whole thing runs in Java 25 on Quarkus, ships as a single Docker image, and installs with one command. Open source since 2017, Apache 2.0.
Would love to hear thoughts on the architecture and feature set. And if you have ideas for what's missing or what you'd want from a system like this, I'm all ears. Always looking for good input on the roadmap.

value: Show HN: EDDI – Multi-agent AI engine where agent logic lives in JSON, not code

author: ginccc


value: isoldex

value: Show HN: Sentinel – LLM browser automation using 10x fewer tokens

author: isoldex


value: uvm32 is a risc-v small virtual machine. I've added gdbstub support to it. Using GDB remote serial protocol connection, a gdb instance can connect to the host and debug the code running on the emulated core.

value: Show HN: I've Added Gdbstub to UVM32

title: Show HN: I've Added Gdbstub to UVM32


value: mroling

value: Show HN: NoPII – One line of code to protect PII before it hits your LLM

author: mroling


value:
Reinterpretation of SF Signal famous flowchart but as a typeform type form.
Find your next fantasy/SF read or share your journey so far with friends.
All links to bookshop.org or to storygraph.
Feedback appreciated :)

value: Show HN: Morebooksplease – SF Signal flowchart as a survey


value: julienreszka

value: I was tired of the bloated weather apps so I made one where I input my towns and favorite activities and it finds the best time windows for hiking, stargazing picnic and so on with a natural language explanation

value: Show HN: Reloadium Weather: find best time for your favorite outdoor activities

author: julienreszka


value: canxerian

value: Show HN: A tool to calculate LLM model API costs when coding

author: canxerian


value: Just some recreational programming. Maybe it's useful for someone.

value: Show HN: Yutu – A modern Lua linter written in Rust


value: makmakapps

value: Show HN: I built a free Mac app locker because AppLocker ($18) freezes Macs

author: makmakapps


value: Show HN: Homebutler – Nightly restore drills for your homelab backups


value: kyars

value: Show HN: rlvrbook

author: kyars

title: Show HN: rlvrbook


value:
I’ve spent a year building a theory learning path that starts from scratch and goes all the way up to topics like Secondary Dominants and Borrowed Chords. It uses a combination of games, interactive lessons and spaced repetition to help you understand and remember concepts. Not just learn something new and forget it in a few days.<p>I’m trying to figure out:
1. Is the progression logical?
2. What am I missing that you’d like to see in there?
3. Where does it get confusing and could use more clarification?

value: Show HN: I built a music theory course with games and spaced repetition


value:
Hacker News,
Training custom wake words like "Hey Alexa" is often a resource-intensive task, demanding powerful hardware and complex manual tuning.
NanoWakeWord is an open-source framework designed to solve this. It features an intelligent engine that automates the ML pipeline, making it possible to build high-performance, production-ready wake word models with minimal effort.
What makes it different:
Train Anywhere, On Anything: The core architecture is built for extreme efficiency. You can train on massive, terabyte-scale datasets using a standard laptop or even a low-spec machine, all without needing a GPU. This is achieved through memory-mapped files that stream data directly from disk, eliminating RAM limitations.
Intelligent Automation: The framework analyzes your data to automatically configure an optimal model architecture, learning schedule, and training parameters. It removes the guesswork from building a robust model.
Total Flexibility and Control: While it automates everything, it also offers deep customization. You can choose from 11+ built-in architectures (from lightweight DNNs to SOTA Conformers) or easily extend the framework to add your own custom architecture. Every single parameter generated by the engine can be manually overridden for full control.
Smarter Data Processing: It moves beyond generic negatives. The system performs phonetic analysis on your wake word to synthesize acoustically confusing counter-examples, which drastically reduces the false positive rate in real-world use.
Ready for the Edge: Models are exported to the standard ONNX format. The framework also includes a lightweight, stateful streaming inference engine designed for low-latency performance on devices like the Raspberry Pi.
Try It in Your Browser (No Install Needed):
This single Google Colab notebook is a playground to train your first model. Inside, you can select and experiment with any of the available architectures with just a few clicks.
Launch the Training Notebook: https://colab.research.google.com/github/arcosoph/nanowakewo...
The goal is to produce models with an extremely low false positive rate (tests show less than one false activation every 16-28 hours on average).
The project is actively developed by Arcosoph, and all feedback or questions are highly welcome!
Key Links:
GitHub Repo: https://github.com/arcosoph/nanowakeword
PyPI Package: https://pypi.org/project/nanowakeword/
Pre-trained Models: https://huggingface.co/arcosoph/nanowakeword-models#pre-trai...
Discord Community: https://discord.gg/rYfShVvacB

value: Show HN: NanoWakeWord – Open-source wake word training for any device


value: darronz

value:
I use Claude Desktop, Claude Code, and Cursor daily. They all have memory now, but none of them share it. Something I explained in Claude Desktop doesn't exist when I open Cursor. I got tired of re-explaining my stack, my preferences, and my project context every time I switched tools.
Most solutions I found required Docker, external databases, or cloud accounts - overkill for what's essentially a personal context store. So I built Covalence: a Mac app that bundles an MCP server and a local vector database into a single download. Any MCP client connects to it. Store a memory in Claude, retrieve it from Cursor. Same database, zero config.
The stack:
SQLite + sqlite-vec, nomic-embed-text-v1.5 running on-device via CoreML (no API keys, no network calls). Hybrid BM25 + vector search. Everything lives in a single SQLite file.
The hard part was concurrency. Multiple Claude sessions writing to the same MCP server would deadlock. SQLite in WAL mode with each MCP client as a separate process solved it - multiple clients read and write simultaneously without blocking. Embeddings run sub-second on Apple Silicon.
A few features that emerged from daily use:
Core Memories - pin facts the AI should always know (your stack, your preferences, standing instructions). They persist across every session and every client.
Spaces - separate memory contexts for work, personal, or individual projects. No cross-contamination.
Global hotkey capture - store something without switching away from whatever you're doing.
Free, no limits. macOS 15+, ~261MB (mostly the CoreML embedding model).
https://covalence.app

value: Show HN: Covalence – Cross-Client Memory for Claude, Cursor, and MCP (macOS)

author: darronz


value: SingAlong

value: Show HN: ZxClip – Mac app to edit audio like text; runs locally

author: SingAlong