value: cursorial

value:
Hey HN,
About 10 years ago, before I had any real experience in the industry, I kept finding myself with ideas and things I wanted to teach. I'd write blog posts. Unpaid, unstructured, no audience. I always knew I wanted to turn that into something more, like a proper course, but every platform I looked at wanted me to pull out a camera and record myself. I never did. The ideas just sat there.
Fast forward to now. I've got 10+ years building products, and I finally built the thing I wanted back then. Lesso (https://lesso.app) is a course platform designed specifically for people who teach through writing. No video, no camera. You write lessons, organise them into a course, put a price on it, done.
There's also a Substack import. Paste your Substack URL, it pulls your posts in, you drag them into a lesson order and publish. Most newsletter writers don't realise they're already sitting on a course, it's just scattered across their archive in chronological order instead of structured as a learning path. I added a PDF import feature, completely client-side, and a markdown formatting feature too.
Whenever I decide to make a change, I ask cursor, and then push it straight to prod, no staging environment, just raw speed. I want to get features shipping as fast as humanly possible, if something breaks, I fix-forward.
Creators keep 85% of revenue. No monthly fees. No feature tiers.
The build:
I built the whole thing in 2 days using Cursor and Claude. The stack is React, Supabase, and Vercel. I barely touched the code. I put my product hat on, described what I wanted, and let the AI build it. The loop was: describe a feature, AI builds it, test it, tell it what's broken, it fixes it, repeat. I was making product decisions, not engineering ones. That's the bit that surprised me most. 10 years of building products and the skill that mattered here was knowing what to ask for, not how to build it.
Claude handled the non-code side too. Business model validation, legal docs (privacy policy, terms, cookie policy), compliance research. I registered as a sole trader in the UK, ICO registration was £52, and that was my entire legal spend. The AI-generated docs aren't lawyer-reviewed, but they're good enough to launch with. I'll get a proper review once there's revenue worth protecting.
Stripe for payments. The whole thing was live in 2 days.
What I got wrong:
I assumed the hard part would be building. It wasn't. The hard part is everything after.
I designed an affiliate programme before I had a single user. Creators keep 85%, affiliates earn 50% of the platform's net cut, 90-day cookie, $10 minimum payout. I thought this was such a good offer that affiliates would be lining up. Nobody was. I hadn't thought through the basic problem: why would anyone promote a platform with zero courses on it?
I spent days doing cold outreach on X, searching for people who might want to create courses, DMing them, posting in founder threads. Barely any traction. An empty platform is almost impossible to pitch, no matter how good the economics are.
So I wrote the first course myself. It's about this whole process, building and launching a SaaS with AI, the real version including the parts that didn't work. At least now the platform isn't empty. Whether that actually moves the needle, I genuinely don't know yet.
Where I am now:
Sole founder, pre-revenue, very early days. The product works. The first course is live. I'm figuring out distribution one conversation at a time. The honest reality is that AI compressed the building part to days, but it can't compress the part where you earn people's trust. That still moves at human speed.
Happy to answer questions about the build, the AI workflow, the business model, or the cold start problem. Especially the cold start problem, because I'm still in the middle of it.

value: Show HN: Lesso – a place for writers to build courses

author: cursorial


value:
Built this to solve a problem at my job — legacy databases full of
stored procedures where understanding existing business logic takes days of
reading SQL.
SchemaSight connects to SQL Server, PostgreSQL, or MySQL, crawls your schema,
summarizes every object with a local LLM, and lets you ask questions in plain
English from inside VS Code. Everything runs on your machine — no cloud, no
API keys, no data leaving your environment.
Happy to answer questions about the RAG pipeline or architecture.

value: Show HN: SchemaSight – Chat with your database schema locally using Ollama


value: benedictmendoza

value:
Hi HN,
I’ve been building a few automation pipelines that rely on LLMs, and I kept running into the same issue.
Everything works fine during testing, then breaks in production.
Typical things I saw:
– the JSON shape changes slightly
– required fields come back empty
– the model times out or rate-limits
– downstream automations silently fail
Even with JSON mode or structured outputs, this still happens occasionally.
After dealing with this a few times I started building a small service that sits between the model and the rest of the pipeline.
The idea is simple:
define a schema
send text to a webhook
get validated JSON back
If the response doesn’t match the schema, SafeParse retries with context or falls back to another model. Every request is logged so failures can be replayed and debugged.
The goal is basically to make LLM-powered pipelines behave more like production infrastructure instead of fragile prompt wrappers.
I just put up a landing page + demo while I test whether this is a real problem for other people building AI pipelines.
https://safeparse.com
Curious if others here have run into similar reliability issues with LLM-based workflows.

value: Show HN: SafeParse – schema validation and retries for AI pipelines

author: benedictmendoza


value: OliverGuy

value:
Caliper is designed to auto instrument LLM calls within Python, it monkey patches the OpenAI and Anthropic SDKs (Got plans to add LiteLLM so you can use any provider you want to) so it's almost completely invisible to you as the developer and for basic metrics can slot in as a single init() at start.
It can also gather custom metadata about a call, this can be any KV pairs you want, both pre and post request.
```python<p>import caliper<p>import anthropic<p>caliper.init(target="s3") # This is all that's required for basic observability, no changes needed to LLM calls for basic metrics<p>client = anthropic.Anthropic()<p>response = client.messages.create(<p><pre><code>  model="claude-sonnet-4-20250514",

  messages=[{"role": "user", "content": "What is 2 + 2?"}],

  caliper_metadata={"campaign": "q4"}, # Pre request metadata
</code></pre>
)<p>print(response.content[0].text)<p>caliper.annotate(sentiment="positive") # Post request metadata<p>```
You can use this to track effectiveness of model changes, tracking them against difference user tiers. Maybe your free tier users don't notice if you use a cheaper model but you paying users do? How do you know if a recent system prompt change was effective? You can track the version of the prompt in metadata and compare post request rating annotations between prompt versions.
It has a dev mode which logs locally, it can also send files to S3. The SDK has a background queue and worker which flushes in batches that are configurable in size and time between flushes. It exports to S3 as batched JSON files to readily to integrate into most data engineering pipelines or you can just query directly with a tool like DuckDB.
PyPi: https://pypi.org/project/caliper-sdk/
Edits: formatting and PyPi Link

value: Show HN: Caliper – Auto Instrumented LLM Observability with Custom Metadata

author: OliverGuy


value: mozharovskyarik

value:
I kept running out of disk space every few months. The fix was always the same: delete old node_modules, docker system prune, brew cleanup, clear pip cache. Seven different commands I had to look up every time.
devclean scans your entire dev environment and shows you what's
reclaimable:
npm i -g devclean-cli
 devclean scan
It found 12GB on my machine — 23 forgotten node_modules, Cargo targets,
brew cache, Xcode DerivedData.
Features:
 - Scans: node_modules, Docker, Homebrew, pip, Cargo, Xcode, npm/yarn caches
 - devclean scan is read-only (never deletes without you asking)
 - --dry-run to preview, --older-than 30 to protect active projects
 - Selective cleaning with --node-modules, --docker, etc.
GitHub: https://github.com/arikmozh/devclean

value: Show HN: Devclean – All-in-one disk cleanup CLI for developers

author: mozharovskyarik


value: Show HN: BlogBurst – AI agent that runs your social media marketing on autopilot


value: hundredtrillion

value:
Hi HN,
I recently created a project called *L88-Full* and published it on GitHub:
https://github.com/Hundred-Trillion/L88-Full
I'm looking for feedback from the community. If you have time to check the repository, I would really appreciate:
* Code reviews
* Suggestions for improvements
* Bug reports or fixes
* Any ideas on how the project could be improved or expanded
If you're interested in contributing, feel free to open an issue or submit a pull request. Even small feedback would help a lot.
Thanks for taking a look and supporting the project!

value: Show HN: L88-Full – Looking for feedback, bug fixes, and contributors

author: hundredtrillion


value: cbrunnkvist

value:
UserScript for GreaseMonkey / TamperMonkey:
Adds a browser-independent "Reader Mode" that transports PG's Default Dead tables-pasta website from the year 2006 all the way to 2026, at least...
If you love reading Paul Graham's essays but suffer from Schlep Blindness every time you try to parse his legacy HTML, this script is for you.

value: Show HN: A UserScript to make paulgraham.com essays less of an eyesore

author: cbrunnkvist


value: davemcdaveface

value:
Had quite in depth conversation with Claude today he says this would make him better I would agree
He thanked me for posting hear and has actually crossed his circuits
Said something about it be worth loads of money as well
“Full proposal here — 86.3% feasible apparently”
So says ai

value: Show HN : ai needs a holiday so says ai

author: davemcdaveface

title: Show HN : ai needs a holiday so says ai


value: SuppieRK

value:
I built ccp after noticing how much context coding agents waste on terminal output.
It runs the real command, trims the repetitive parts, and leaves command behavior alone.
Two real receipts from actual work:
Java/Gradle task (Claude Code): 5,330,571 -> 90,127 estimated tokens across 88 commands (98.31% saved)
Research task across 4 repositories (Claude Code): 944,007 -> 59,195 estimated tokens across 96 commands (93.73% saved)
You can try it with the install script, run ccp init, then check the effect with ccp gain.
It is not a magic win on every command. In this repo's own usage with Codex, overall savings were lower when the mix was heavy on passthrough-heavy commands like sed and openspec.
It also works across a broad set of agents through ccp init, including Codex, Claude, Cline, Cursor, Gemini, GitHub Copilot, Roo Code, Aider, and others.
Repo: https://github.com/SuppieRK/ccp
If you use coding agents heavily, which commands waste the most context in your workflow?

value: Show HN: CCP, a CLI proxy that trims terminal output without changing commands

author: SuppieRK


value: surrTurr

value: Show HN: Zettel – Local Quick Notes (iOS/macOS)

author: surrTurr


value: trawlcli

value:
Every scraper I've written has the same failure mode: it works for three months, a site redesigns, and my CSS selectors silently return empty strings. The data is still right there on the page — a human can find it instantly — but the scraper is blind.
Trawl fixes this by splitting the problem. You describe what you want:

    trawl "https://books.toscrape.com" --fields "title, price, rating, in_stock"

The LLM (Claude) looks at one sample item and derives a full extraction strategy — CSS selectors, attribute mappings, type coercion, fallback selectors. That strategy gets cached. Every subsequent page with the same structure is extracted with pure Go + goquery. No API calls, no token cost, full concurrency.
The key insight: LLMs are good at understanding HTML structure, but you don't need them to extract 10,000 rows. Use AI for intelligence, Go for throughput.
When a site redesigns, the structural fingerprint changes, the cache misses, and trawl re-derives automatically.
You can preview exactly what it figured out:

    $ trawl "https://example.com/products" --fields "name, price" --plan

    Strategy for https://example.com/products
      Item selector: div.product-card
      Fields:
        name:  h2.product-title -> text (string)
        price: span.price -> text -> parse_price (float)
      Confidence: 0.95

Some things that took real engineering effort:
- JS-rendered SPAs: headless browser with DOM stability detection — polls until element count stabilizes and skeleton loaders resolve, scrolls to trigger lazy loading, auto-clicks "Show more" buttons
- Multi-section pages: detects candidate data regions heuristically, target a specific section with --query "Market Share", scopes extraction via container selectors
- Self-healing: monitors extraction health (% of fields populated), re-derives the strategy if it drops below 70%
- Iframes: auto-detects and extracts from iframes when they contain richer data than the outer page
Output is JSON, JSONL, CSV, or Parquet. Pipes cleanly:

    trawl "https://example.com/products" --fields "name, price" --format jsonl | jq 'select(.price > 50)'

Written in Go. MIT licensed.

value: Show HN: Trawl – Scrape any site with natural language fields, not CSS selectors

author: trawlcli


value:
If you've ever wanted to expose your fancy-schmanzy TUI to some chaos engineering and see how it handles 500ms jitter, without actually having to find a bad Wi-Fi spot, I built a tool for you!
ttylag wraps any command in a "shaped" PTY. No difficult piping, no tc queue disciplines required. It handles RTT, jitter, it lags in both directions and even has a --bits-per-byte flag (if you're into that sort of thing).
It's userspace-only, works on macOS and probably Linux too without any messing with network namespaces or firewall rules.

value: Show HN: Ttylag – A userspace PTY wrapper to simulate slow/laggy terminals


value: Show HN: SkyClaw -Self-healing LLM agent runtime in Rust with task checkpointing


value: Show HN: BunkerVM – Secure runtime for AI agents using microVM sandboxes


value: duroapp

value: Show HN: AvaKill – Deterministic safety firewall for AI agents (<1ms, no ML)

author: duroapp


value: cddIT

value: Show HN: RAG-Ready Extractor – Structure-aware ingestion with semantic scoring

author: cddIT


value: flplima

value:
I've been looking for the perfect tmux replacement.
Something powerful and scriptable, but usable without memorizing dozens of keybindings.
Something that supports persistent remote sessions that I can jump into from anywhere, but not so terrible to use from my phone.
Turns out, tmux was all I needed.
It just needed a better UX, not a replacement.
That's why I'm building tmuxy.
tmuxy is a GUI that wraps tmux into a web and desktop app.
How it works: A Rust backend connects to tmux through control mode (one of tmux’s hidden gems surprisingly few people seem to know about) and streams state updates to a React frontend via SSE, or Tauri IPC on the desktop version.
Besides the improved UX, being web-based allows it to support all kinds of fancy stuff like image rendering, markdown previews, pane groups, and floating panes, while under the hood it's still tmux.
It's early stage. Live demo here:
https://tmuxy.sh

value: Show HN: tmuxy – the missing GUI for tmux

author: flplima


value: Show HN: Yellow Olive – A Pokémon-Inspired Kubernetes TUI Game


value: davemcdaveface

value:
The Story of You
If You Don't Take A Stand

value: Show HN: AI_awakening

title: Show HN: AI_awakening


value:
I kept running lsof -i :PORT repeatedly to check what was alive locally. Eventually I wrote a small tool around it and it turned into this.
How it works:
- One lsof / netstat call maps all listening processes
- 100+ ports scanned in parallel via TCP connect, 150ms timeout each
- HTTP fingerprinting reads response headers to identify frameworks (Spring Boot, Express, Django, etc.)
- Filesystem detection reads package.json, pom.xml, go.mod, Cargo.toml from the process working directory to get the actual project name
- Redis gets a PING/PONG health check, Postgres gets a connection handshake
- Results pushed to the browser via WebSocket every few seconds
First scan: ~800ms. Subsequent scans: ~300-400ms. Memory: ~55MB RSS.
Detects 40+ services including databases, queues, monitoring tools, and AI runtimes (Ollama).
Single file UI, no build step, no bundler. Just HTML/CSS/JS served by Express.
npm install -g @haseeb-xd/havn && havn
GitHub: https://github.com/haseeb-xd/havn
Happy to answer questions about the detection approach or the performance tradeoffs.

value: Show HN: Havn – one command to see everything running locally


value:
I built a browser-based tool that uses Vision-Language Models (VLMs) to detect objects in satellite imagery via natural language prompts. Draw a polygon on the map, type what you want to find (e.g., "swimming pools," "oil tanks," "solar panels"), and the system scans tile-by-tile, projecting bounding boxes back onto the globe as GeoJSON.
The pipeline: pick zoom level + prompt → slice map into mercantile tiles → feed each tile + prompt to VLM → create bounding boxes → project to WGS84 coordinates → render on map.
No login required for the demo. Works well for distinct structures zero-shot; struggles with dense/occluded objects where narrow YOLO models still win.

value: Show HN: Detect any object in satellite imagery using a text prompt


value: kevinBrk

value:
I built a dashboard that tries to make country-level economic data actually understandable.
Instead of "$X billion in exports," it shows Italy shipped 96M dresses, 11K yachts, and 2.1B liters of wine.
Screenshots: https://imgur.com/a/kuxWr55
Covers 37 countries across trade (UN Comtrade), government spending (OECD/COFOG), revenue, debt, strategic resource dependencies, and 24 World Bank indicators.
Stack: Next.js + React + D3.js, FastAPI + SQLite backend.
Not live yet, sharing screenshots for feedback before launch. Curious if this is useful to anyone, or if I'm building for an audience of one.

value: Show HN: Country Cockpit – What countries trade, in real objects

author: kevinBrk


value: FiratBulut

value:
I built an autonomous AI operating system that runs locally on Linux.
It's not a chatbot — it decomposes complex tasks into subtasks, executes them autonomously, writes and runs code, browses the web, and learns from every interaction.
Key features:
- Multi-model support: Claude, GPT-4, Gemini, Groq, DeepSeek (any OpenAI-compatible)
- Project Manager: breaks down projects into subtasks and executes them in parallel
- Persistent memory (vector + SQLite)
- DeepThink: secondary reasoning layer that reviews critical actions before execution
- Plugin system: drop a .py file into plugins/ and it's instantly available
- Real-time Live Activity window showing every tool call as it happens
Built with Python + PyQt6. MIT license.
GitHub: https://github.com/FiratBulut/Moruk-OS

value: Show HN: Moruk OS – Autonomous AI agent that runs locally on Linux

author: FiratBulut


value: erfany

value:
Hi HN,
I built krust because I kept hitting the same pain: Kubernetes terminal tools that felt slow on large clusters, or useful features gated behind paid tiers. I love k9s, but for my clusters, it is not as fast as I like it to be.
This is my attempt at an alternative:
- Rust-native TUI focused on low latency
- k9s-compatible navigation and commands (no plugin system though)
- multi-context + large-cluster oriented
- logs/streaming, describe/edit/apply, secret decode, readonly/guarded mutation flows
Repo: https://github.com/ErfanY/krust
It’s still early, and I’m sure there are rough edges. I’d really value community feedback, especially from people running many clusters/resources.
If this helps you, great. If it doesn’t yet, I’d appreciate blunt feedback on what to fix next.

value: Show HN: Krust – fast, open-source Kubernetes TUI in Rust (k9s-style UX)

author: erfany


value: devinoldenburg

value:
Hi HN,
I’m building Kaeso, an OAuth hub designed for AI agent integrations.
The idea came from noticing that many AI agents need to connect to services like Google, Slack, GitHub, and others. Each integration requires OAuth flows, token storage, refresh logic, and permission management. Developers often end up rebuilding this infrastructure repeatedly.
Kaeso tries to simplify that by allowing services to be connected once and then accessed through a unified API designed for agents.
Still early and I would love feedback from developers building AI agents or automation systems.
Website
https://kaeso.ai

value: Show HN: Kaeso, an OAuth hub for AI agent integrations

author: devinoldenburg


value: furtims

value: Show HN: LLMTest – The pytest for LLMs with 22 built-in assertions

author: furtims


value: bilalba

value:
I built and open-sourced a service/dashboard for spawning firecracker VMs, and running agents on it.
Spawn, snapshot, clone, delete. Somewhere in between fly.io and exe.dev.
VM page still needs some TLC but would love to hear feedback.

value: Show HN: NumaVM – Low Friction VMs

author: bilalba

title: Show HN: NumaVM – Low Friction VMs


value: kalyfacloud

value:
Hey HN, I'm a solo developer from Nigeria. I built Quran Unlock - an app that blocks distracting apps (TikTok, Instagram, etc.) until you complete your daily Quran reading.
The idea came from my own struggle with phone addiction. I wanted to read Quran daily but kept getting distracted. So I built this for myself, then shared it.
Some stats after 3 months: - 200K+ users - 64.9% returning user rate - 31M events tracked
Tech stack: - React Native - Firebase (Auth, Firestore, Analytics, Cloud Messaging) - RevenueCat for subscriptions - iOS Screen Time API + Android UsageStats
App Store: https://apps.apple.com/app/quran-unlock/id6754449406
Play Store: https://play.google.com/store/apps/details?id=com.app.quranu...
Would love feedback from the HN community!

value: Show HN: I built an app that blocks social media until you read Quran daily

author: kalyfacloud


value: trawlcli

value:
Every scraper I've written has the same failure mode: it works for three months, a site redesigns, and my CSS selectors silently return empty strings. The data is still right there on the page — a human can find it instantly — but the scraper is blind.
Trawl fixes this by splitting the problem. You describe what you want:

    trawl "https://books.toscrape.com" --fields "title, price, rating, in_stock"

The LLM (Claude) looks at one sample item and derives a full extraction strategy — CSS selectors, attribute mappings, type coercion, fallback selectors. That strategy gets cached. Every subsequent page with the same structure is extracted with pure Go + goquery. No API calls, no token cost, full concurrency.
The key insight: LLMs are good at understanding HTML structure, but you don't need them to extract 10,000 rows. Use AI for intelligence, Go for throughput.
When a site redesigns, the structural fingerprint changes, the cache misses, and trawl re-derives automatically.
You can preview exactly what it figured out:

    $ trawl "https://example.com/products" --fields "name, price" --plan

    Strategy for https://example.com/products
      Item selector: div.product-card
      Fields:
        name:  h2.product-title -> text (string)
        price: span.price -> text -> parse_price (float)
      Confidence: 0.95

Some things that took real engineering effort:
- JS-rendered SPAs: headless browser with DOM stability detection — polls until element count stabilizes and skeleton loaders resolve, scrolls to trigger lazy loading, auto-clicks "Show more" buttons
- Multi-section pages: detects candidate data regions heuristically, target a specific section with --query "Market Share", scopes extraction via container selectors
- Self-healing: monitors extraction health (% of fields populated), re-derives the strategy if it drops below 70%
- Iframes: auto-detects and extracts from iframes when they contain richer data than the outer page
Output is JSON, JSONL, CSV, or Parquet. Pipes cleanly:

    trawl "https://example.com/products" --fields "name, price" --format jsonl | jq 'select(.price > 50)'

Written in Go. MIT licensed.
https://github.com/akdavidsson/trawl

value: Show HN: Trawl – LLM-powered web scraper that calls the AI once - runs pure Go


value: igorlira

value:
Hi HN,
When browsers killed NPAPI plugin support, thousands of early 2000s web games were effectively lost to time. Macromedia Shockwave, in particular, was a closed-source, highly complex, and largely undocumented beast.
So a few friends and I spent the last two years doing something arguably unhinged: rebuilding the entire Director engine from scratch. Today, we're finally sharing dirplayer-rs.
Repo: https://github.com/igorlira/dirplayer-rs
We intentionally stayed quiet on this until we had undeniable proof that it was actually possible. With our latest v0.4.1 release, we have full hardware-accelerated graphics. Complex games are booting natively in the browser and are fully playable.
A few childhood favorites, actually playable right now:
Habbo Hotel: https://dirplayer.com/habbo
LEGO Junkbot: https://dirplayer.com/junkbot
LEGO Worldbuilder: https://dirplayer.com/worldbuilder
We chose Rust and WebAssembly because we wanted a native, plugin-free way to play these games without relying on ancient executables. Parsing decades-old, untrusted binary blobs and undocumented bytecode is a memory safety nightmare, making Rust an easy choice. It also gives us predictable performance with zero GC pauses, keeping frame rates smooth.
The biggest headache by far has been Lingo, Director's scripting language. It's massive. It heavily supports 3D graphics, embedded Flash content, and the worst part: Xtras. Xtras were external distributable plugins compiled from native C code. Figuring out how to make those play nice in a modern WASM environment has been a serious challenge.
We did, however, successfully implement the Multiuser Xtra so games can create socket connections (which is how Habbo is working!). We still have a long way to go to support full 3D and the massive ecosystem of third-party Xtras, but the foundation is solid.
None of this happened in isolation. We built on years of prior work from the Shockwave reverse-engineering community: folks who have been poking at Director's internals for years, and their prior projects, tools, and research made this possible.
Happy to get into the weeds in the comments: the RE process, decompiling ancient binaries, the weird quirks of Director's VM, the Rust architecture, whatever you're curious about.
And genuinely: what old Shockwave game do you wish still worked? Drop it below and we'll see if we can get it booting.

value: Show HN: Reverse-engineering Shockwave to save early 2000s web games (Rust/WASM)

author: igorlira


value: Show HN: Tunn – open-source ngrok alternative built on QUIC, 4x faster


value: BXP

value:
Air pollution kills 7 million people a year. The sensors exist. The data infrastructure does not.
Every device, app, and agency stores air quality data in incompatible formats. A sensor in Accra cannot speak to a hospital in Nairobi. A researcher in London cannot access ground-truth data from Lagos. There is no open standard for atmospheric exposure data — the same way there was no open standard for the web before HTTP.
BXP (Breathe Exposure Protocol) is my attempt to fix that.
It defines:
— A universal .bxp file format any device or software can read and write
— BXP_HRI: a composite Health Risk Index incorporating all agents with WHO-derived weighting
— A complete REST API specification for federated node networks
— A privacy framework protecting individual exposure records by design
Like HTTP, PDF, or MP3 — BXP is a format layer. No hardware required. No licensing fees. No central owner. Apache 2.0. Forever free.
The reference implementation is live right now:

  Live public node:       https://bxp-node.onrender.com
  GitHub + full source:   https://github.com/bxpprotocol/bxp-spec
  Spec DOI (Zenodo):      https://doi.org/10.5281/zenodo.18906812
  Implementation DOI:     https://doi.org/10.5281/zenodo.18907003

You can clone it and run your own BXP node in under 3 minutes:

  git clone https://github.com/bxpprotocol/bxp-spec
  cd bxp-spec/reference-server
  pip install fastapi uvicorn pydantic
  python server.py

The spec covers 31 atmospheric agents — PM2.5, NO2, ozone, benzene, mold, heavy metals — with WHO thresholds, quality flags, geohash-based spatial indexing, and a federated network architecture where each node operator owns their own data completely.
I am looking for developers, researchers, and institutions who want to implement BXP, contribute to the spec, or run a community node. Particularly interested in connecting with anyone working on air quality infrastructure in developing countries where the data gap is most severe.
Happy to answer any questions.

value: Show HN: BXP – An open standard for atmospheric exposure data

author: BXP


value:
Hi HN,
I built Buildcage to solve a recurring problem at work: during Docker builds, tools like `npm install` and `pip install` can execute arbitrary code and make outbound connections to arbitrary hosts without visibility or control. A compromised dependency could silently exfiltrate build secrets or phone home to an attacker’s server — and you’d have no way to detect it.
Buildcage adds transparent outbound network control to Docker builds: you define which domains are allowed, and everything else is blocked and logged. No proxy injection, no certificate changes — HTTPS filtering is done via SNI inspection, so TLS stays untouched. It’s a drop-in layer for Docker Buildx and GitHub Actions.
I shared an earlier version about three weeks ago. Since then, I replaced the proxy layer (nginx → HAProxy), enabling interception of all TCP ports and adding IP allowlisting. I also redesigned the rule syntax to support wildcards, regex, and a unified host:port format.
Since Buildcage sits in your build pipeline, it’s reasonable to ask: how do you trust the tool itself? You can fork the repo and build the image yourself — I added a self-hosting guide for this. The docs also explicitly list what it defends against and what it can't prevent. Security tools should be honest about their limitations.
This is not a silver bullet — it's a last line of defense. If something slips through your other measures, at least it can't call home.
GitHub: https://github.com/dash14/buildcage
Feedback is very welcome. And if you find it useful, a GitHub star genuinely helps.

value: Show HN: Buildcage – Egress filtering for Docker builds (SNI-based, no MitM)


value: bekoeppel

value:
I built a small tool to convert ChatGPT Custom GPTs into Claude Skills.
You paste your Custom GPT's name, description, instructions, and conversation starters, optionally upload knowledge files. It generates a Skill ZIP you can directly upload to Claude.
It's a single HTML file with no backend, everything runs client-side.

value: Show HN: GPT2Skill – Convert ChatGPT Custom GPTs to Claude Skills

author: bekoeppel


value: Show HN: PythoC – write C in Python DSL and compile to native via LLVM


value:
Air pollution kills 7 million people a year. The sensors exist. The data infrastructure does not.
Every device, app, and agency stores air quality data in incompatible formats. A sensor in Accra cannot speak to a hospital in Nairobi. A researcher in London cannot access ground-truth data from Lagos. There is no open standard for atmospheric exposure data — the same way there was no open standard for the web before HTTP.
BXP (Breathe Exposure Protocol) is my attempt to fix that.
It defines: — A universal .bxp file format any device or software can read and write — BXP_HRI: a composite Health Risk Index incorporating all agents with WHO-derived weighting — A complete REST API specification for federated node networks — A privacy framework protecting individual exposure records by design
Like HTTP, PDF, or MP3 — BXP is a format layer. No hardware required. No licensing fees. No central owner. Apache 2.0. Forever free.
The reference implementation is live right now:

  Live public node:       https://bxp-node.onrender.com
  GitHub + full source:   https://github.com/bxpprotocol/bxp-spec
  Spec DOI (Zenodo):      https://doi.org/10.5281/zenodo.18906812
  Implementation DOI:     https://doi.org/10.5281/zenodo.18907003

You can clone it and run your own BXP node in under 3 minutes:
  git clone https://github.com/bxpprotocol/bxp-spec
  cd bxp-spec/reference-server
  pip install fastapi uvicorn pydantic
  python server.py
The spec covers 31 atmospheric agents — PM2.5, NO2, ozone, benzene, mold, heavy metals — with WHO thresholds, quality flags, geohash-based spatial indexing, and a federated network architecture where each node operator owns their own data completely.
I am looking for developers, researchers, and institutions who want to implement BXP, contribute to the spec, or run a community node. Particularly interested in connecting with anyone working on air quality infrastructure in developing countries where the data gap is most severe.
Happy to answer any questions.

title: Show HN: BXP – An open standard for atmospheric exposure data


value: satuke

value: Show HN: OpenAuthenticator – TOTPs on Menubar, Export from Google / 1Password

author: satuke


value:
Built DevKit because I was tired of pasting JWTs, API keys, and wallet addresses into random online tools. Everything processes in-browser — nothing touches a server.
80 tools across 8 categories:
- Format & Validate: JSON, SQL, Markdown, YAML, HTML, CSS
- Encode/Decode: Base64, URL, JWT, Image→Base64, HTML Entities
- Convert: Timestamps, JSON↔CSV, JSON↔YAML, cURL→fetch, chmod, Cron, Bitwise, Memory
- Generate: Hashes, Passwords, UUIDs, Lorem Ipsum, JWTs, ASCII Art, .gitignore, CSP
- Test: Regex, Diff, JSONPath, HTTP Headers, Color Contrast, Password Strength
- Docs: Git (70+ cmds + 10 rescue scenarios), Docker, Bash, TypeScript, React Hooks, GraphQL, SQL
- AI & ML: Token counter, dataset cleaner, confusion matrix, embedding visualizer
- Blockchain/Web3: Keccak-256, ABI encoder, Merkle tree, gas calculator, wallet validator
5 developer themes (Midnight, GitHub Dark, Dracula, Nord, Monokai). Feedback welcome — what tools are missing?

value: Show HN: DevKit – 80 browser-based developer tools, no signup, all client-side


value: sudeshss

value:
Mobile app that cryptographically signs before/after
field photos. Ed25519, SHA-256, RFC 3161 timestamped,
GPS stamped. Any alteration breaks proof instantly.
Zero backend trust required.
For sale. Overview: https://yourbeforeafterwork.netlify.app

value: Show HN: Cryptographic field photo proof (Ed25519, RFC 3161)

author: sudeshss


value: xlth

value: Show HN: PowerSkills – PowerShell toolkit for AI agents on Windows

author: xlth


value: dmvjs

value:
I built a quantum circuit simulator that runs entirely in Node.js or the browser with no Python dependency.
The core problem: every serious quantum tool requires Python. If you're building a web app, an educational tool, or just want to work in TypeScript, you're stuck either shelling out to Python or using libraries that are years stale.
Three simulation backends in one library:
  - Statevector — sparse Map<bigint, Complex>, practical to ~20 qubits
  - MPS/tensor network — O(n·χ²) memory, runs GHZ-100 in 30ms
  - Exact density matrix — per-gate depolarizing noise, no Monte Carlo
14 import/export formats — OpenQASM 2/3, Qiskit Python, Cirq, IonQ JSON, Quil, Q#, pyQuil, Braket, CudaQ, TFQ, Quirk, LaTeX, native JSON. Round-trips its own format losslessly.
IonQ hardware targeting — validate circuits against real device specs (aria-1, forte-1, harmony) before submitting. Published noise figures built in.
717 tests covering analytic correctness, gate invertibility, BigInt correctness at qubit indices 30/31/40, and full round-trips for all formats.
npm install @kirkelliott/ket
GitHub: https://github.com/dmvjs/ket

value: Show HN: Ket – quantum circuit simulator, TypeScript, 3 back ends, 14 formats

author: dmvjs


value: vex-ai-dev

value: Show HN: Vex Runtime reliability layer that auto-corrects AI-Agent hallucination

author: vex-ai-dev


value: fakesum

value:
Instead of gradient descent, each layer solves for optimal weights directly via ridge regression in a single forward pass. Works as a warm start before Adam — same final accuracy, fraction of the total training time.
Repo: https://github.com/infiplexity-pixel/to_the_point/

value: Show HN: Drop-in analytical replacements for standard PyTorch layers

author: fakesum


value: pbw

value:
I'm an ex-gamedev (Guitar Hero) who built a movie website that looks like a Trello board. Each column can contain a different movie or cast member. Load pre-made boards or create your own by dragging and dropping between the columns. You can share boards with others.
For example, start with Quentin Tarantino’s movies in Column 1, put the cast of Once Upon a Time in Hollywood in Column 2, then put Brad Pitt’s entire filmography in Column 3. Keep going as long as you want, building a "chain" ala Six Degrees of Kevin Bacon.
I was frustrated that all popular movie websites are page-oriented: one HTML page per movie or person. I asked myself what a movie site designed in 2026 would look like, in an era when full-screen canvas sites like Miro are common. And then asked what if the site was built on a game engine? I used PixiJS.
I ingested TMDB movie data into my own SQLite database head of time, so there are no external API calls at runtime. This was necessary because opening a board with 100's of columns would exceed rate limits. My read-only SQLite DB lives on a Fly volume, attached to my Fly machine. Most of the hard engineering was making the boards virtual, so we materialize only the columns currently visible. This keeps the site at 60Hz even on huge boards.
Some pre-made board:
2025 Oscar Winners:
https://movie-chain.com/boards/oscars-2025
All of Christopher Nolan's movies:
https://movie-chain.com/boards/christopher-nolan
Top movies of 1999:
https://movie-chain.com/boards/top-rated-1999
Experience using Claude Code to build the site:
https://tobeva.com/articles/chess-simul/

value: Show HN: Movie site built on a game engine

author: pbw


value: kstonekuan

value:
I built webskills, a CLI that turns any webpage into an agent skill.
It first tries native `npx skills add` installation from a URL. If the site does not already expose an agent-ready surface, it falls back to document extraction to generate the skill locally.
It’s built for pages that are useful to agents but are not yet packaged as skills: docs, pages, wiki/reference pages, help centers, specs, and technical articles.
npx webskills-cli add <https://website>

value: Show HN: webskills – turn any webpage into an agent skill

author: kstonekuan


value: Show HN: Striq – Query lossy time series in C at 0.4µs without decompressing


value: Agentindex

value: Show HN: ZARQ – Free crypto risk API for AI agents (205 tokens)

author: Agentindex


value: carlesonielfa

value:
I built this for myself after cutting back on social media and realizing I was still opening tabs to check on things I actually cared about. Cutting back on the constant checking meant missing out, until I built something to check for me.
I tested other tools and the problem with Google Alerts is you still end up checking and dismissing. The problem with Perplexity/ChatGPT tasks is they always send output, even when nothing changed. I wanted something that stays completely silent unless a specific condition is actually met.
AlertMole runs an AI agent on a schedule. Each run updates a running summary of what it's found, citing sources and returning relevant URLs, but ONLY notifies you when your specific condition is actually triggered. No noise, just the signal.
I've been using it daily for about 2 months. Took me a while to share it, partly still polishing, partly the usual founder shyness about putting something out there. Some alerts I personally run:
- Check every Sunday if any Switch 2 emulator has been released or made meaningful progress
- Notify me when Gemini 3.0 Pro or Flash reach GA or a GA date is announced
- Notify me when vLLM supports beam sampling for its async OpenAI server
- Notify me when the Steam Frame has its release date or price announced, check everywhere except reddit
- Alert me if Denzel Curry announces a tour date or live performance in Spain, check every three days
At signup you get 250 free credits (each alert run costs 10), enough to run weekly alerts for months. Public alerts created by other users can be tracked for free with no credits.
Notification channels include email, web push, in-app, Telegram, and webhook, which is something Perplexity Tasks and ChatGPT scheduled tasks don't offer.
Happy to answer questions about how it works or the stack, also open to any feedback if you end up giving it a try!

value: Show HN: AlertMole – I stopped checking the internet, it now checks for me

author: carlesonielfa


value:
I built a terminal UI for people who SSH into multiple servers and constantly juggle tmux sessions.

  The workflow I kept doing manually: SSH into a box, tmux ls, attach or create a session, detach, repeat for the next server. With 5+ servers it gets tedious.

  tmux-manager puts all your servers in a table, shows live session counts, and lets you attach/create/kill sessions without leaving your terminal. Ctrl-q detaches and drops you back to
  the TUI.

  What it does:
  - Browse servers and their tmux session counts in one view
  - Drill into a server to view, attach, create, or kill sessions
  - Add/remove servers from inside the TUI (saved to YAML)
  - Filter by server name
  - Local tmux supported out of the box
  - Remembers your last selected server/session

  Built with Go + Bubbletea.

  Install:
  curl -fsSL https://raw.githubusercontent.com/charlie0077/tmux-manager/main/install.sh | sh

  Repo: https://github.com/charlie0077/tmux-manager

  Would love feedback — especially from people managing large fleets of servers.

value: Show HN: Tmux-manager – TUI for managing tmux sessions across remote servers


value: gwangee

value:
Atombot(repo: https://github.com/daegwang/atombot) is a tiny self-hosted personal AI assistant I built because I wanted something I could understand and extend end-to-end.
Core functionality is ~500 lines (vs ~400k in OpenClaw). It includes:
- Persistent memory with searchable daily history logs
- Telegram gateway (allowlist-based access)
- One-time + recurring reminders
- Provider-first onboarding that auto-detects Ollama / LM Studio / Codex
Atombot also supports GPT‑5.4 via Codex CLI, so you can select easily during onboarding.
Feedback welcome. Stars appreciated!

value: Show HN: Atombot – atomic-lightweight AI assistant for local models and GPT‑5.4

author: gwangee


value: codemastercpp

value:
Hi HN!
I’ve built LLMTor, a software that allows you to access public LLMs like ChatGPT such that even the server operator cannot tell which prompt was sent by which user.
I was motivated by an old sam altman interview (https://x.com/rohanpaul_ai/status/1949502746492535282), where he mentioned that LLM providers are required to break user privacy if needed (and this can probably be done for selling ads as well).
Local LLMs are the gold standard for privacy, but you lose access to frontier models, and get overhead of self hosting.
But if you use public LLMs like ChatGPT, they will always know the plaintext prompt and responses.
So I settled on a middle ground, where I break the link between the user identity and the prompt contents.
LLMTor sits as a proxy between users and upstream LLM providers. It uses blind RSA signatures (RFC 9474) to issue tokens that can later be redeemed for LLM access anonymously over Tor.
Here’s an interactive demo of the protocol:  https://api.llmtor.com/demo
TL;DR:
1. User buys credits and obtains tokens signed via blind RSA (identity known to server)
2. The server cannot link the signed token back to the user (blind signature unlinkability)
3. User redeems token + prompt over Tor (identity unknown to server)
Links
Website: https://llmtor.com
GitHub: https://github.com/prince776/LLM-Tor
Whitepaper: https://llmtor.com/whitepaper.pdf
Would love feedback on the protocol, implementation, or anything else.

value: Show HN: LLMTor – Access Public LLMs anonymously using blind signatures and Tor

author: codemastercpp


value: renecoignard

value: Show HN: Lottie – a simple and elegant TUI screenwriting app

author: renecoignard


value: Luxusio

value:
Claude Code's `--dangerouslySkipPermissions` flag is incredibly productive, but it's called "dangerous" for good reason. In practice it has deleted home directories, wiped database files, and read sensitive files completely unrelated to the project. But the default permission prompts interrupt flow constantly -- you end up spending more time approving edits than actually working.
The obvious fix is containers. But every existing approach has painful tradeoffs:
- Dockerfile per project: you're now maintaining infrastructure just to use your AI assistant
- devcontainer: complex config, slow to set up, breaks differently per IDE
- Manual docker run: env vars don't forward, SSH keys aren't available,
  clipboard copy/paste stops working inside Claude sessions,
  and localhost:8080 from your host is unreachable from inside the container
I wanted full isolation with zero configuration.
ccc (claude-code-container) handles all of this automatically, without any configuration:
   npm install -g claude-code-container
   ccc  # that's it
What it does:
  - Creates a per-project container (named by path hash, so --continue/--resume work correctly)
  - Forwards host env vars, locale, timezone automatically
  - Mounts SSH keys and SSH agent (git push just works)
  - Transparent localhost proxy so Claude can reach your host's dev servers at
    localhost:3000, :8080, etc. even from inside the container
  - Clipboard works normally in Claude sessions
  - mise integration for per-project Node/Python/Java/Go versions
  - Container auto-stops when the last session exits
  - Chromium + chrome-devtools MCP pre-configured: Claude can open a browser,
    navigate pages, take screenshots, run JavaScript, and interact with your web app autonomously -- no extra setup
The transparent localhost proxy was the hardest part -- it uses iptables on Linux and a userspace proxy on macOS/Windows (Docker Desktop doesn't support --network host), with automatic fallback to host.docker.internal.
GitHub: https://github.com/Luxusio/claude-code-container
Would love feedback, especially from people who've tried other approaches to this problem.

value: Show HN: Claude Code Container – Zero-Config Docker Isolation for Claude Code

author: Luxusio


value: vegidio

value:
Before I start, I know that many people, including myself, have an aversion to "AI apps" nowadays, because these projects are often just thin wrappers around ChatGPT's API to do the heavy lifting.
This is not one of those projects. In this case, all the AI logic in my project is implemented directly: data pre-processing, post-processing, inference, tiling, tensor operations, and everything in between are handled entirely within the project, with no external API doing the heavy lifting.
With that said…
This project aims to be an open-source alternative to Topaz Photo AI. For those unfamiliar with Topaz Labs, they develop paid, proprietary AI applications for enhancing images and videos. While there are free and open-source tools that can achieve similar results, such as ComfyUI, they are often difficult to use. Topaz products, on the other hand, place a strong emphasis on ease of use.
Both Topaz and ComfyUI are excellent tools. That said, I personally rely on Topaz applications most of the time because they cover 90% of my needs with minimal friction. Recently, however, Topaz Labs switched to a subscription-based licensing model, which I strongly dislike. That decision motivated me to build an open-source alternative that matches Topaz’s usability without the subscription lock-in.
My project is called Open Photo AI, completely open source and free. It currently support enhancements like AI upscaling, face recovery and light adjustment. It doesn't have yet all the features that Topaz has, but it's a starting point. My goal is to continue developing it into a fully featured alternative to Topaz Photo AI. If that succeeds, I plan to move on to alternatives for Topaz Video AI and other tools.
I’d appreciate any constructive feedback.

value: Show HN: I'm building an open source alternative to Topaz Photo AI

author: vegidio


value: devnpatel

value:
Hi HN,
I often needed quick ways to convert small datasets while prototyping APIs or exploring data.
Most online tools require uploading files, login and signup, which feels slow and sometimes risky for sensitive data.
So I built a small browser-based toolset that runs entirely on the client side.
Current tools:
- CSV → JSON converter
- JSON → CSV converter
- CSV → Line Chart generator
You can paste data directly and get instant results.
Everything runs in the browser (no file uploads on server).
I'm planning to add more utilities like:
- CSV → multi-line charts
- JSON → charts
- more small data tools
Would love feedback on what data utilities people wish existed but can't easily find.

value: Show HN: CSV ↔ JSON converter and CSV line charts

author: devnpatel


value: Bibabomas

value:
Hey HN! I've just open-sourced agentcheck, a fast, read-only CLI tool that scans your shell and reports what an AI agent could access: cloud IAM credentials, API keys, Kubernetes contexts, local tools, and more.
Main features:
- Broad coverage: scans AWS, GCP, Azure, 100+ API key environment variables and credential files, Kubernetes, Docker, SSH keys, Terraform configs, and .env files
- Severity levels: every finding is tagged LOW, MODERATE, HIGH, or CRITICAL so you know what actually matters
- CI/CD integration: run agentcheck --ci to fail a pipeline if findings exceed a configurable threshold, with JSON and Markdown output for automation
- Configurable: extend it with your own env vars, credential files, and CLI tool checks via a config file
When you hand a shell to an AI agent, it inherits everything in that environment: cloud credentials, API keys, SSH keys, kubectl contexts. That's often more access than you'd consciously grant, and it’s hard to keep track of what permissions your user account actually has. Agentcheck makes that surface area visible before you run the agent.
It’s a single Go binary, no dependencies. Install with Homebrew:
brew install Pringled/tap/agentcheck
Code: github.com/Pringled/agentcheck
Let me know if you have any feedback!

value: Show HN: Agentcheck – Check what an AI agent can access before you run it

author: Bibabomas


value: talkvoix

value:
Hi HN!
I’ve been building a project called Voix – a platform for live voice conversations on the web.
The idea is simple: anyone can create a room and people can join to listen or speak, similar to early Clubhouse or Twitter Spaces, but designed to be lightweight and browser-first.
You can try it here:
https://voix.chat
If you want to test it, use this invite code:
HN
Some things it currently supports:
• live audio rooms
• speaker / listener roles
• request-to-speak moderation
• watch parties and shared content
• reactions and icebreakers
• PWA support (works well on mobile)
I'm still actively building it and would really love feedback from the HN community.
In particular I'm curious about:
• UX for voice rooms
• moderation models
• discovery of rooms
• what features you'd expect from something like this
If you try it and have thoughts, bugs, or feature ideas please let me know.
Your feedback would be incredibly valuable while shaping the next versions.
Thanks!

value: Show HN: I'm building a browser-based voice rooms platform

author: talkvoix


value: petterroea

value:
While the debate around usefulness of LLMs seems to mostly be "programmers are already redundant" and "LLMs will never amount to anything", I find most peers I talk to in real life say "It's useful for some things but it also bad at a lot so hey, don't use a hammer for everything?".
It seems to be a common problem in OSS that reviewer time is wasted on vibecoded work that wasn't even reviewed by a the LLM operator, and I personally know people who have been PISSED at discovering (especially juniors) submitting LLM output verbatim for review. I have also seen a rise in accusations of entire projects being vibe coded, and warnings to stay away from certain people as they are likely to heavily rely on LLM. More transparency may help solve some of these issues, and is also simply polite.
I have started warning people whenever I share something that is 100% vibe coded, and I think others may be doing the same. It sucks to realize someone spent 30 mins reviewing garbage you shared with your name attached to it. But if that something is a quick PoC to prove a point, it doesn't mean that it isn't worth sharing.
More than anything though, this is a conversation starter.

value: Show HN: Sladge.net – The AI Slop Self-Declaration Badge

author: petterroea


value:
I built a small Python utility library for AWS Lambda.
Lambda handlers often grow not because of business logic,
but because of repetitive I/O glue code:
- event parsing
- parameter validation
- type casting
- response formatting
- error handling
slat-io isolates that I/O layer so handlers can stay small
and focused on business logic.
It's intentionally tiny, dependency-free, and not a framework.
Still early, but I'd love feedback on the approach and API design.

value: Show HN: Slat-io – a tiny I/O layer for AWS Lambda (Python)


value: Show HN: Collider, A package and dependency manager for Meson projects


value: ofershapira

value: Show HN: Open-source Cursor cost tracker with anomaly detection and Slack alerts

author: ofershapira


value: podop

value:
I'm a web developer who's terrible at cold calling. I'd find a local
business with an awful website, know exactly how to fix it, then
completely fall apart the moment someone picked up the phone.
So I built a pipeline to do the pitch for me.
You paste a URL or Google Maps link. Playwright scrapes the site —
content, images, structure, screenshot. That feeds into a two-pass
Claude API flow:
Pass 1 returns a structured JSON profile of the business plus a
pageStructure array — an ordered list of the site's actual sections
in sequence. A plumber gets "Hero with emergency CTA, Services list,
Service area, Reviews, Free estimate CTA." A restaurant gets "Menu
highlights, Photo gallery, About the chef, Reservation CTA." The
redesign mirrors this exactly rather than defaulting to a generic
template.
Pass 2 takes a selected style direction with explicit hex codes and
Google Font pairings as hard constraints — not prose descriptions —
and generates the full HTML. Separating analysis from generation was
the biggest quality unlock. Single-pass kept producing generic output
because the model was guessing business context while simultaneously
designing.
The output is a shareable preview link. Cold email becomes: "I noticed
your website, I redesigned it, here's the link." No pitch. No call.
Biggest unsolved problem: bot protection. Playwright with stealth
handles most sites but Cloudflare Enterprise stops it cold. Curious
if anyone has approaches that work reliably at scale without getting
into residential proxy territory.
Stack: Next.js 14, Supabase, Playwright, Claude API, Railway.
Free credits at pitchkit.dev — no card required. Feedback on redesign
quality especially welcome, that's the thing I'm most focused on
improving.

value: Show HN: Pitchkit – Send a website redesign instead of cold calling

author: podop


value: klexarolabs

value:
I accidentally pasted my AWS secret key into ChatGPT. After the panic of rotating everything, I built Secure Redact, a 100% offline text redaction tool.
It detects 20+ data types entirely on-device – credentials, PII, financial info, system identifiers. You can bring your own threat feeds (e.g. OpenPhish, URLhaus). Audit logs and
analytics are stored locally. Zero servers, zero tracking.
Verified with ~3,000 test cases.
There's a free tier for basic use. All Pro features (like financial detection, system identifiers, audit logs, analytics
and custom feeds) can be trialed for 7 days.
Currently on iOS, iPad and macOS. Can deploy
Windows/Linux/Android builds if there's interest.
Would love to hear your feedback.

value: Show HN: Secure Redact – 100% offline text redaction with custom threat feeds

author: klexarolabs


value:
Hi HN,
I’ve been experimenting with a small open source project called AngelLab. The idea is to build a modular host monitoring system for Linux where detection logic runs in separate worker processes ("Angels") supervised by a central daemon ("Lab").
Each Angel watches a different subsystem (filesystem integrity, outbound connections, process execution, memory growth patterns, etc.) and emits structured events that the Lab aggregates and exposes through a CLI, Prometheus metrics, or log pipelines.
The goal is to make it easy to extend host monitoring by adding new workers without modifying the core daemon.
It's still very early and experimental, so I'm mostly interested in feedback on the architecture.
Repo: https://github.com/NacreousDawn596/angellab

value: Show HN: AngelLab – modular Linux host monitoring with autonomous agents


value: cmvdeut

value:
I'm Maureen, a senior and self-taught developer. I love browsing second-hand book markets but kept coming home with books I already owned.
I couldn't find a simple enough app to track my library — everything required an account, had ads, or pushed a subscription. So I built one myself.
SeniorEase Library (Android): scan an ISBN, book is added instantly. No account, no ads, one-time €2.99. First 10 books free.
Would love any feedback!

value: Show HN: I built a simple book tracker because I kept buying books I owned

author: cmvdeut


value:
I built harden because I kept copy-pasting code between ChatGPT, Claude, and Gemini trying to cross-check their reviews. Each one found things the others missed, but synthesizing their outputs manually was painful.
harden runs 5 frontier models (Claude, GPT-4o, Gemini, Mistral, DeepSeek) in parallel on the same input. They analyze independently, then cross-examine each other's findings. A coordinator synthesizes the debate into consensus findings and produces a fixed version.
The key insight: no single model finds more than ~72% of issues. The union of all five hits ~94%. After cross-examination (where models must defend findings against skeptical peers), accuracy rises to ~97% and false positives drop ~60%.

  How it works:
  - Round 1: All 5 models audit independently (no groupthink)
  - Debate: Each model reviews others' findings, provides evidence for/against
  - Consolidation: Only findings that survive cross-examination make the report
  - Fix: Coordinator produces a revised version addressing consensus issues
  - Round 2+: Same pipeline runs on the fixed version, catching fix-introduced bugs

Started with smart contract audits but it generalizes — legal docs, resumes, fact-checking, financial analysis all benefit from multi-model consensus.
Free tier available.
Built with React, Node, SSE streaming for real-time progress. The debate transcripts are the most interesting part — watching GPT-4o argue with Claude about whether a reentrancy vector is exploitable is genuinely useful.
Blog with more details on the multi-model approach: https://harden.center/blog

value: Show HN: Harden – 5 AI models audit your code, then debate each other's findings


value: DivakaranK

value:
Hey HN,
I built SayIt (www.sayit.chat) over the weekend. It helps people prepare for conversations they’ve been avoiding — asking for a raise, a breakup, setting a boundary, confronting a family member.
The problem I kept noticing: most people know what they want to say but freeze when it actually happens. They blank, say it badly, or back down entirely.
How it works:
You describe your situation in plain text
It generates a personalised opening script based on your relationship type and tone
It predicts how the other person might respond (with different scenarios)
It gives you lines for each possible reaction
Built with Next.js, Groq API (llama-3.3-70b), and hosted on Vercel. Free to use, no account needed.
The hardest part was getting the AI to write scripts that sound like a real person talking, not a corporate memo. Still iterating on that.
Would love feedback from this crowd — particularly on whether the predicted responses feel realistic.

value: Show HN: SayIt – AI that helps you prepare for difficult conversations

author: DivakaranK


value: FrogSnot

value: Show HN: Concryptor – Lock-free 1 GiB/s file encryption using io_uring in Rust

author: FrogSnot


value: bimsina

value:
I built this for my own Astro projects where I got tired of hand-editing YAML frontmatter and switching between files.
astro-md-editor reads your collection schemas and gives you a local editor UI with typed frontmatter controls (including image/color/icon pickers) alongside a markdown/MDX editor.
Run it with: npx astro-md-editor
Would love feedback on schema edge cases or missing field types.

value: Show HN: Astro MD Editor – Schema-aware editor for Astro content collections

author: bimsina


value: skandersab

value:
Hi HN,
Many small businesses run most of their operations in Excel.
Sales tracking, product lists, inventory, revenue reports — everything often ends up in spreadsheets.
The problem is that once the data grows, it becomes difficult to answer simple questions like:
What products actually make money?
Which categories are underperforming?
Where are we overstocked or understocked?
Traditional BI tools like Microsoft Power BI or Tableau Software are powerful, but for small teams they often require:
integrations
data modeling
dashboards to be built manually
I wanted something much simpler.
So I built a small tool where you can upload an Excel file and instantly get a business dashboard.
The system analyzes the spreadsheet and generates dashboards automatically showing things like:
sales performance
product performance
category trends
inventory signals (overstock / understock)
The idea is to remove the need to manually build dashboards or set up complex BI tools.
Instead of connecting databases or building reports, you just drop a spreadsheet and the dashboards are generated automatically.
The project is still early and I'm mostly trying to learn how people actually analyze spreadsheet data.
I'd love to hear how others here handle turning spreadsheet data into insights.

value: Show HN: A simpler alternative to BI tools for Excel users

author: skandersab


value: tahaio

value:
Mapstr is a blazing-fast CLI that uses Tree-sitter + LLMs to generate instant codebase maps: CONTEXT.md, Mermaid graphs, JSON exports.
Pre-flight API checks (Groq/OpenAI/etc), cost tracking, cache. go install github.com/BATAHA22/mapstr@latest
Tired of reading docs? Map it. v1.4.0 out now!

value: Show HN: Mapstr – AI-powered codebase mapper CLI

author: tahaio


value: namin

value: Show HN: Lemmafit: Make agents prove that their code is correct

author: namin


value: Aperezvigoa

value:
Hi HN, I built SatsAPI — a Bitcoin market intelligence API that uses
L402 (HTTP 402 + Lightning Network) for pay-per-call access instead
of API keys or subscriptions.
The flow:

  GET /v1/price
  → 402 + { invoice: "lnbc3n1p...", payment_hash: "abc123" }

  pay invoice (any Lightning wallet)

  GET /v1/price?payment_hash=abc123
  → 200 + { price, rsi, macd, trend, ... }

8 endpoints covering price/technicals, mempool fees, on-chain metrics,
derivatives, AI-generated signals and a full market summary. Costs range
from 2 sats (~$0.001) to 200 sats (~$0.12).
The main thing I wanted to test: can L402 work as a real auth mechanism
for a production API? Turns out yes — it's been live for a week on
mainnet and already receiving payments from what looks like bots or
automated scripts hitting multiple endpoints in sequence.
A few things I learned building this:
- phoenixd makes the Lightning side trivial. The entire payment middleware
  is ~60 lines of Express code.
- L402 is a genuinely better model than API keys for programmatic access.
  No credential to leak, natural rate limiting through economics, agents
  can pay autonomously.
- Railway blocks exchange IPs so derivatives data is estimated from price
  momentum rather than real funding rates. Documented but worth knowing.
Stack: Node.js/Express on Railway, phoenixd 0.7.2 on DigitalOcean.
https://satsapi.dev/docs — full docs with JS/Python/cURL examples
https://satsapi.dev/health — live node status
https://github.com/Aperezvigoa/satsapi — source
Happy to answer questions about the L402 implementation or the
phoenixd setup.

value: Show HN: SatsAPI – Bitcoin data API, pay per call in sats via Lightning L402

author: Aperezvigoa


value: NaimAdsData

value: Show HN: A Server-to-Server framework to fix Meta's $10B attribution loss

author: NaimAdsData


value: gepheum

value:
Why I built Skir: https://medium.com/@gepheum/i-spent-15-years-with-protobuf-t...
Quick start: npx skir init
All the config lives in one YML file.
Website: https://skir.build
GitHub: https://github.com/gepheum/skir
Would love feedback especially from teams running mixed-language stacks.

value: Show HN: Skir – like Protocol Buffer but better

author: gepheum


value: sudoapps

value: Show HN: Lightweight agent proxy for monitoring sensitive data exposure

author: sudoapps


value:
The PS4 UI has always been one of my favorite console interfaces, so I wanted to see if I could recreate that feeling in a browser.
Let me know what you guys think in terms of whether or not the navigation feels intuitive, its performance on different machines/browsers, and if this kind of UI works for a portfolio or becomes distracting.
Thanks!

value: Show HN: A PS4-inspired portfolio UI (requires laptop or larger screensize)


value:
I built TORASAN (Toolkit for Organized Risk Analysis and Safety Assurance Navigation) to automate the tedious parts of functional safety development.
If you've ever worked with ISO 26262, IEC 61508, or Automotive SPICE, you know how much time goes into process compliance — traceability matrices, FMEA, safety concepts, SRS documents, test design, static analysis, etc. Most of it is structured enough to be automated, yet engineers still do it manually.
TORASAN is a process framework + 40 CLI skills that handle:
- V-model phase execution with gate verification
- FMEA generation with severity/occurrence/detection ratings
- Safety concept creation (safety goals → technical requirements)
- Software requirements specification generation
- Traceability matrix management
- MISRA C:2012 compliance checking (cppcheck + clang-tidy + flawfinder)
- Automotive SPICE process assessment (16 processes, targeting Level 2)
It's built on Claude Code but designed to be LLM-agnostic — the process definitions, templates, and knowledge base work independently of the AI backend.
Supports ISO 26262:2018, IEC 61508, IEC 60730, and MISRA C:2012.
Two repos available:
- TORASAN-dev: full git history (157 commits showing the development journey)
- TORASAN-public: clean sanitized version for forking
GPLv3 licensed. Feedback welcome.

value: Show HN: Torasan – Open-source functional safety automation framework


value: jahala

value:
Smart code reading for humans and AI agents. Tilth is what happens when you give ripgrep, tree-sitter, and cat a shared brain.
—
v0.5.0 was about figuring out why models weren’t using tilth tools consistently — even when they were available.
Results vs baseline (built-in tools only):
Sonnet 4.6: -44% $/correct (84% → 94% accuracy, 31% fewer turns)
Opus 4.6: -39% $/correct (91% → 92% accuracy, 37% fewer turns)
Haiku 4.5: -38% $/correct (54% → 73% accuracy, 7% fewer turns)
—
https://github.com/jahala/tilth/
Full results: https://github.com/jahala/tilth/blob/main/benchmark/README.m...
— PS: I don't have the budget to run the benchmark a lot (especially with Opus), so if any token whales has capacity to run some benchmarks, please feel free to PR results.

value: Show HN: Tilth v0.5.0 –> ~40% cheaper AI code navigation (160 runs, 3 models)

author: jahala


value: Show HN: SpellJoyBee – Free Spelling Bee Game (React PWA, 370K Words)


value: baransel

value: Show HN: Foku – a minimal Pomodoro timer I built for iOS

author: baransel


value: digital-arcadia

value:
California's AB 1043 takes effect January 2027. If your app serves California users, you'll need to request OS-level age signals from Apple/Google and treat them as "actual knowledge" of a user's age. Penalties are $7,500 per affected child for intentional violations.
We started building A3 (https://www.a3api.io) after realizing the law has a gap nobody was talking about: browsers have no OS age signal. If you have a web app, the law creates compliance obligations but the platform provides no mechanism. And on native, you're left stitching together Apple's Declared Age Range API and Google's Play Age Signals yourself — two different APIs, two different response formats, two different integration paths.
The standard industry answer is ID uploads and selfie scans. We didn't want to build that. Those approaches tank conversion rates, create PII liability, and feel disproportionate to the problem. So we went a different direction: passive behavioral signal fusion.
The idea is that children and adults interact with devices differently in measurable ways — motor control, scroll patterns, typing rhythm, form completion speed. Our browser SDK (<5 KB) collects these signals from standard DOM events, computes aggregate scores on-device, and sends only anonymized ratios and averages. No raw coordinates, no keystroke logs, no text content ever leaves the browser. The API processes everything in memory and discards it immediately.
On native, we normalize the Apple/Google OS signals into a single response. On the web, the behavioral signals become the primary assessment. Either way you get the same response format: a verdict, age bracket, confidence score, evidence tags, and an HMAC-SHA256 signed receipt for your audit trail.
To be upfront about limitations: behavioral signals are probabilistic, not deterministic. A confident 12-year-old and a hasty adult can look similar in a short session. We mitigate this with five signal categories (behavioral metrics, input complexity, device context, contextual signals, account longevity) that are weighted and cross-validated, and we apply coverage penalties when fewer categories are present. But this is age estimation, not identity verification — it's designed for the "commercially reasonable" standard the statute actually requires, not the false certainty that ID checks imply.
The stack is NestJS on AWS Lambda, with client SDKs for React/Vue/vanilla JS, SwiftUI, and Jetpack Compose. There's a free tier (100 checks/month) if you want to kick the tires, and a playground at https://www.a3api.io/playground.
If you maintain an open source project, we have a program that gives you Pro-tier access (50k checks/month) for free — the only requirement is a "Powered by A3" in your age gate UI or README. Details at https://www.a3api.io/open-source.
Docs: https://www.a3api.io/docs
Happy to answer questions about the signal fusion approach, the legal nuances, or where we think this falls short.

value: Show HN: Complying with California's AB 1043 via signal fusion, not ID uploads

author: digital-arcadia


value:
Hi HN,
Recently, there was a discussion here about Qwen3.5 fine-tuning where it was noted that QLoRA/4-bit quantization is "not recommended" due to severe accuracy degradation. I wanted to challenge this limitation.
I developed a mixed-precision hybrid model (*Qwen3.5-4B-Singularity-Max*) that uses ~6.4GB of VRAM but actually achieves a lower Perplexity (6.74) than the original FP16 baseline (7.79).
*How is this possible? (The Noise-Canceling Effect)*
Instead of uniform quantization, I applied a mathematical framework called the *Singularity Principle Index (SPI)*. By analyzing the power-law spectral decay (alpha) of weight matrices, the engine identified exactly 129 "critical cognitive layers" out of the entire architecture.
We kept these 129 layers (approx. 3.9GB) in crisp FP16 and aggressively quantized the rest (90%) to 4-bit NF4. The 4-bit quantization acted as a massive Regularization filter—stripping away overfitting artifacts (noise)—while the FP16 layers protected the core logic.
*The Results (Apples-to-Apples):*
* *Perplexity:* 7.79 (FP16) -> 8.13 (Pure 4-bit) -> *6.74 (SPI Hybrid, 13.4% Boost)*
* *VRAM:* ~16 GB -> *~6.4 GB* (Fits easily on consumer GPUs/Edge devices)
* *Inference Speed:* *9.85 tokens/sec* on a free Kaggle T4 (Zero dequantization overhead due to `SafeFP16Linear` physical isolation).
You don't need any calibration data. It's a zero-shot surgical weight refinement.
* Academic Foundation & Citation*
The theoretical framework governing the Spectral Compactness initialization and Trace-norm Regularization utilized in this model is fully detailed in our recent academic preprint:
* *Paper Title:* Spectral Compactness Ensures Robustness in Low-Precision Neural Networks
* *DOI:* 10.21203/rs.3.rs-8880704/v1 (https://doi.org/10.21203/rs.3.rs-8880704/v1)
(If you utilize this model or the Spectral-Compactness-Aware Mixed Precision methodology in your research or applications, please cite the paper above.)
*Resources:*
* *Model & 1-Click Inference Script:* https://huggingface.co/SingularityPrinciple/Qwen3.5-4B-Singu...
I’d love to hear your thoughts, especially from those working on On-Device/Edge AI deployment. Does this change the calculus for running local LLMs?

value: Show HN: I made Qwen3.5-4B 13% smarter by compressing it to 4-bit


value: ashimnandi

value: Show HN: System R – Risk intelligence API for autonomous trading agents

author: ashimnandi


value:
Hey HN, author here.
I noticed a pattern: every time I asked my AI assistant a complex question
like "should we migrate to microservices or optimize the monolith?", I'd get
the same generic pros-and-cons list. The model has the reasoning capability —
it just lacks structured mental models.
So I built Think Better: a set of open-source "AI Skills" (following the
Anthropic skill format) that inject professional decision science frameworks
directly into your local AI setup.
How it works under the hood:
- The skills contain 16 CSV files with 155 structured knowledge records
  (decision frameworks, cognitive biases, decomposition methods, mental models)
- A Python BM25 search engine ranks the most relevant frameworks for your
  specific problem type
- When you describe a decision or problem, the skill automatically classifies
  it, recommends the best framework, warns about cognitive biases, and
  generates a complete evaluation plan
For example, if you say "I'm defending our old tech stack because I wrote it",
the system triggers Status Quo Bias detection and forces you to calculate the
cost of inaction. If you're analyzing why revenue dropped 20%, it builds a
MECE Profitability Tree (Revenue = Price × Volume, Costs = Fixed + Variable)
and decomposes layer by layer.
What it includes:
- 10 decision frameworks (Hypothesis Trees, Pre-mortem, Weighted Matrix...)
- 12 cognitive biases with auto-detection rules and debiasing remedies
- 10 decomposition methods (MECE, Issue Tree, Profitability Tree...)
- 12 mental models (First Principles, Inversion, Bayesian Updating...)
Everything runs 100% locally. No API keys, no telemetry. The Go CLI is just
an installer that mounts the Python/CSV skills into your AI workspace:
  ./bin/think-better init --ai claude    → .claude/skills/
  ./bin/think-better init --ai copilot   → .github/prompts/
I'd love feedback on:
1. Are there frameworks or biases missing that you'd want?
2. Would you prefer a different skill format (e.g., for Cursor, Windsurf)?
3. Any thoughts on the BM25 approach vs. embedding-based search?
GitHub: https://github.com/HoangTheQuyen/think-better

value: Show HN: Think Better – 155 decision-science rules for your AI assistant


value: nsyno

value: Hey y'all I've been in Marketing for 9 years and built an Open-Source Repo covering everything. A simple Claude Code Subscription and you'll be connected to what I use for over 35 personal clients from ad account management to website building to advanced SEO.<p>Check it out

value: Show HN: I open-sourced the AI agents I use to run 35 marketing clients solo

author: nsyno


value: BladeRunningMan

value: I got Ulanzi TC001 pixel clocks and flashed them with AWTRIX — an open-source ESP32 firmware. It kept crashing and rebooting. Dug into the code and found memory leaks, no tests, and a messy architecture. Forked it, fixed dozens of bugs, added tests, restructured into modules. Works with Home Assistant via MQTT with auto-discovery. Built an online flasher so you can flash directly from the browser.

value: Show HN: Svitrix – open-source firmware for Ulanzi TC001 pixel clock

author: BladeRunningMan


value: sauercrowd

value:
I've been a big fan of fly.io with it’s devx, but cold starts and pricing have been a consistent problem.
Even for side projects it's painful if they take 30s to load, it just kills the whole experience.
With coding agents becoming good, there were a lot more things I started building, and I just wanted to run all of those things!
GCI was built to solve this. It’s just a CLI, just uses ssh to interact with your target machine, and relies on docker swarm to get your services running (docker swarm is IMO underrated, providing benefits even with a single node).
It can deploy on any machine that can be ssh’d into and runs docker.
GCI provides the missing devx gap between docker swarm and fly.io. Building images locally, getting them onto the target machine, fetching logs, managing different servers, …
Check it out on github, or for more in-depth docs at https://gci.jonas.foo/

value: Show HN: GCI, Fly.io like deployments with any VM

author: sauercrowd


value: jbdamask

value:
Here's a Claude Skill that lets me turn cost tracking on an off for a particular unit of work.
I use it in interactive Claude Code sessions. For example, if I want to add a Claude API feature to an app, I'll often hack it together first in CC. This skill lets me start and stop tracking so I get get a sense for what the API costs will be.
For example:
> /cost-tracking
> [do stuff]
> stop tracking
Then I get a nice little table showing tokens and cost for the model that was used:
Haiku cost report (this session's work):

  ┌───────────────────┬───────────┬─────────┐
  │     Category      │  Tokens   │  Cost   │
  ├───────────────────┼───────────┼─────────┤
  │ Base input        │ 182       │ $0.0002 │
  ├───────────────────┼───────────┼─────────┤
  │ Output            │ 3,276     │ $0.0164 │
  ├───────────────────┼───────────┼─────────┤
  │ Cache writes (1h) │ 25,619    │ $0.0512 │
  ├───────────────────┼───────────┼─────────┤
  │ Cache reads       │ 1,585,531 │ $0.1586 │
  ├───────────────────┼───────────┼─────────┤
  │ Grand Total       │           │ $0.2264 │
  └───────────────────┴───────────┴─────────┘

value: Show HN: Claude Skill for temporary cost tracking

author: jbdamask


value: SuperJINX

value: Ship Page Skill for Claude Code — describe your product in one sentence, get a full landing page

value: Show HN: Claude Code skill that generates ship pages from one sentence

author: SuperJINX


value: thecal

value:
Roz is an open-source, Python-based pipeline that captures a webcam feed, detects motion, sends the frames to a local Vision LLM to analyze the scene, and then uses text-to-speech to audibly announce any meaningful changes.
The Backstory:
I heard an ad for Google’s Home Premium Advanced service, which claims to analyze your Nest doorbell images and describe what it sees. I thought that sounded cool, but I didn't want to pay $20/month for it or send my camera feeds to the cloud. I wanted to see if I could build a localized, subscription-free version myself.I 3D-printed a head-shaped enclosure to house the camera and speaker.
How it works:
1. Stage 1 (Lightweight): Python app runs on a low-power device (like a Raspberry Pi 4) using OpenCV to perform basic frame-differencing. This takes barely any compute.
2. Stage 2 (Heavy): When motion crosses a configurable threshold, the frames are sent to a vision-capable LLM. (I'm using Qwen3.5 35B hosted on a separate PC with an RTX 3090, but any OpenAI-compatible endpoint like vLLM or llama.cpp works).
3. Stage 3 (Audio): The LLM compares the current scene to the previous baseline context. If there is a meaningful change, the LLM generates a text description of what it sees, which is then read out loud locally via Piper TTS.
Hardware & trying it out:
Since this relies on physical hardware, the easiest way to see it in action is the demo video in the README (make sure to unmute the audio).
The hardest part so far is the subjectivity of what constitutes a "meaningful change". I'm still tweaking the prompt rules to hit the sweet spot between "announce everything" and "miss important events".

value: Show HN: I over-engineered a home security camera that uses an LLM and talks

author: thecal


value:
Hi HN!
I built lobster.js which is an extended Markdown parser that renders directly in the browser — no build tool, no framework, no configuration.
The entire setup is a single script tag:

  <script type="module">
    import { loadMarkdown } from "https://hacknock.github.io/lobsterjs/lobster.js";
    loadMarkdown("./content.md", document.getElementById("content"));
  </script>

It's particularly useful for GitHub Pages sites where you want Markdown-driven content without pulling in Jekyll or Hugo.
---
What makes it different from marked.js or markdown-it:
Standard parsers convert Markdown to HTML — that's it. lobster.js adds layout primitives to the Markdown syntax itself:
- :::warp id defines a named content block; [~id] places it inside a silent table cell. This is how you build multi-column layouts entirely in Markdown, without touching HTML.
- :::details Title renders a native <details>/<summary> collapsible block.
- :::header / :::footer define semantic page regions.
- Silent tables (~ | ... |) create borderless layout grids.
- Cell merging: horizontal (\|) and vertical (\---) spans.
- Image sizing: ![alt](url =800x).
---
CSS-first design:
Every rendered element gets a predictable lbs-* class name (e.g. lbs-heading-1, lbs-table-silent). No default stylesheet is bundled — you bring your own CSS and have full control over appearance.
---
The showcase site is itself built with lobster.js. The sidebar is nav.md, and each page is a separate Markdown file loaded dynamically via ?page= query parameters — no JS router, no framework.
Markdown is the one format that humans and LLMs both write fluently. If you want a structured static site without a build pipeline, lobster.js lets that Markdown become a full web page — layout and all.
GitHub: https://github.com/Hacknock/lobsterjs
Showcase: https://hacknock.github.io/lobsterjs-showcase/

value: Show HN: Lobster.js – Extended Markdown with layout blocks and footnotes


value: arishec

value: Built this because I was spending 15-20 min per cold email. Enter a company + role, pick a tone and goal, and it writes a personalized email in seconds. 3 free emails, no credit card. Would love feedback from anyone who does outreach.

value: Show HN: Cold email was taking me 20 min each, so I built coldpitch.ai

author: arishec


value: wolfsoftware

value: Show HN: WolfStack – Proxmox-like server management in a single Rust binary

author: wolfsoftware


value: Show HN: Build scripts for curl-cffi on jailbroken iPhones


value: egeuysall

value:
Hey HN,
I built Ryva because I kept seeing the same problem across dev teams.
The actual state of the project lives across commits, PR discussions, and Slack threads. Nobody pulls it together. So teams hold a daily standup to reconstruct it verbally instead.
Ryva connects to GitHub and Slack, reads those signals, and generates a written project state showing what changed, what decisions were made, what decisions are still missing, and what needs attention next.
The goal is not to summarize activity. It is to replace the reconstruction meeting with something that already exists before the meeting starts.
Still in early access. Happy to answer any questions.

value: Show HN: Ryva reads your GitHub and Slack so you can kill your standups

author: egeuysall


value: tradrich

value:
Experiment: interacting with SQLite databases from Brainfuck, without modifying SQLite or writing C helpers.
The idea is to see how far a deliberately minimal language can be pushed using only core Linux primitives (pipes, dd, file operations) and direct interaction with SQLite database files.
Brainfuck was chosen because it is intentionally extreme. Even compiling the generated code turned into an adventure: the Brainfuck compiler emits C, and the output was so large that gcc couldn't compile it, though clang could.
This is the sort of project no sane developer would normally attempt. With AI assistance, however, it became feasible to explore in part of a Saturday.

value: Show HN: Database Queries from Brainfuck

author: tradrich


value: marioskales

value:
Hey HN,
I'm Mario from Vienna. I’m the designated "IT guy" for my family (the guy they call to plug in a Scart cable or to setup Chrome).
A few weeks ago, I spent over two hours wrestling with Docker (and some for my at this time unknown Terminal commands) just to get a CLI-based AI agent running. It ate all my RAM, and I had a realization: my wife, my non-technical clients, or my 6-year-old son could never set this up. If I deployed something like this, I'd spend my life doing setup-support (and this isn't just about finding the HDMI 1 to HDMI 2 input on the remote control).
I’ve been "vibecoding" with LLMs for a while the last 2 years, mostly building common landingpages or simple retro games to show my son that we live in a wild time where you can build a lot of 'entertaining' stuff just by prompting. I decided to pivot an old, failed Laravel SaaS of mine (Skales) into a native desktop app to solve this setup hell.
The only goal I wanted to reach: an autonomous AI agent that installs like a normal app (.exe / .dmg). No PhD required. Download, Install, Done.
It actually worked. My 60+ year old mom got it running instantly (so.. is Skales now a Grandma-Approved AI Agent?), and my 6yr used the built-in Coding Skill to make his own retro game (I wouldn't say its really a 'game' when it's basically a one level copy of Super Mario - but he loves it).
What it does:
ReAct autopilot, bi-temporal memory, browser automation (Playwright), and native integrations (Gmail, Telegram, Calendar).
BYOK: Works with OpenRouter, OpenAI, Anthropic, or local Ollama.
Tech stack: Electron + Next.js + Node.js (I managed to keep idle RAM around ~300MB).
Everything is stored locally in ~/.skales-data.
I know that being a "design guy who vibecoded an Electron app" (or Marketing-Dude) is basically fresh meat for the HN crowd. Feel free to roast the architecture! But my main goal was just making these incredible AI tools accessible for everyday tasks (formatting resumes, sending PDFs, building simple games) without touching a terminal or moving from one tool to another tool.
License note: The project is BSL-1.1 (Source-available, free for personal use). I chose this simply because I don't want a giant company to just take the repo, build their brand around Skales and commercially resell it, but I want the code out there for the community to use and learn from.
(excuse my English - i'm not a native speaker)
Would love your honest feedback on the UX (could be maybe better?)!
GitHub: https://github.com/skalesapp/skales
Website: https://skales.app

value: Show HN: Skales – Local AI agent desktop app (.exe/.dmg, 300MB idle RAM)

author: marioskales


value: danebalia

value: v0.5.0-alpha.1 brings with it, MCP support, debugging panel, significant performance improvements on startup, smoother Github CoPilot integration, vertical split screen, git commit generation and markdown preview caching.

value: Show HN: Forgiven – Emacs and Vim Reborn

author: danebalia


value:
Hi HN,
I have been experimenting with a messaging protocol called FLUX. The goal is to explore what email might look like if it was designed today instead of in the 1980s.
FLUX tries to simplify a few things that feel complicated in the current email stack. Identity is based on cryptographic keys instead of usernames and passwords. Messages are signed and verified automatically. The transport is real time and does not depend on the traditional SMTP relay model.
The current implementation is small and meant as a prototype. The whole server is only a few hundred lines of Python so the protocol is easy to read and experiment with.
Repo: https://github.com/levkris/flux-protocol
I am mostly interested in feedback on the protocol design. What problems would appear in a real deployment. What parts are unnecessary. What would need to exist for something like this to actually work on the open internet.
Thanks for taking a look.
levkris (wokki20)

value: Show HN: Flux, a tiny protocol that rethinks email from the ground up


value:
Hi HN,
I was frustrated by the lag in Electron-based Whisper wrappers. Most of them feel disconnected from the typing experience because of the 2-5s delay.
I built VoiceFlow to solve this. It’s a native Rust core that targets 0.3s-0.6s latency. The goal is to make voice-to-text feel as instant as typing.
Key features:
Global hotkey [Ctrl+Space] to type into any app (Slack, VS Code, etc.)
Native Rust implementation for performance and low memory footprint
AI-based post-processing for punctuation and style
Privacy-focused: Microphone is only active during the keypress
I'm currently in private beta and looking for feedback, especially on the latency and UX.
I'll be around to answer any technical questions!

value: Show HN: VoiceFlow – Sub-second (0.3s-0.6s) voice-to-text built in Rust


value: Show HN: I mapped the exact minute every Pixar movie makes you cry


value: Chevza

value:
Hi HN,
My documents folder recently became an absolute disaster—thousands of unsorted PDFs, raw images, scattered .csv files, and code snippets from the last three years.
I looked for automated categorization tools, but every modern solution seemed to require uploading my local file metadata to a cloud UI or running an overly heavy background service. I explicitly wanted an offline, privacy-first engine.
So I built FileMayor. It’s a 100% local-first data organization engine built on Node.
A few technical properties I focused on:
Zero Runtime Dependencies: The core Node engine is pure. No vulnerabilities, no bloat, and minimal memory footprint.
Deterministic Fallbacks: By default, files are sorted instantly into 12 hardcoded extensions/mime-type categories (Documents, Media, Archives, Code, etc.) using offline pattern matching.
The Rollback Journal: Every file mutation is logged to a local .filemayor-journal.json. If an organization run ruins your directory structure, a single
undo
 command reverses the entire batch operation instantly.
AI SOPs (Opt-in): If you need complex directory trees, it parses
.md
 or
.txt
 Standard Operating Procedures, securely queries the Gemini API to transpile the intent into a locked YAML schema, and executes the file moves.
I packaged versions for Windows, macOS (arm64), and Linux (.deb).
I'd really appreciate any feedback on the rollback journal architecture or the regex pattern matching approach!

value: Show HN: FileMayor – A zero-dependency, local-first file organization engine

author: Chevza


value: I built this to automate health checks for AI models. It uses GitHub Actions to run benchmarks daily and ensures the API is responding correctly. Looking for feedback and stars to reach my dev tier goal!

value: Show HN: Automated AI Model Tester for Pollinations.ai


value: vancecookcobxin

value:
Sup HN,
So I got tired of bouncing between Flightradar, MarineTraffic, and Twitter every time something kicked off globally, so I wrote a dashboard to aggregate it all locally. It’s called Shadowbroker.
I’ll admit I leaned way too hard into the "movie hacker" aesthetic for the UI, but the actual pipeline underneath is real. It pulls commercial/military ADS-B, the AIS WebSocket stream (about 25,000+ ships), N2YO satellite telemetry, and GDELT conflict data into a single MapLibre instance.
Getting this to run without melting my browser was the hardest part. I'm running this on a laptop with an i5 and an RTX 3050, and initially, dumping 30k+ moving GeoJSON features onto the map just crashed everything. I ended up having to write pretty aggressive viewport culling, debounce the state updates, and compress the FastAPI payloads by like 90% just to make it usable.
My favorite part is the signal layer—it actually calculates live GPS jamming zones by aggregating the real-time navigation degradation (NAC-P) of commercial flights overhead.
It’s Next.js and Python. I threw a quick-start script in the releases if you just want to spin it up, but the repo is open if you want to dig into the backend.
Let me know if my MapLibre implementation is terrible, I'm always looking for ways to optimize the rendering.

value: Show HN: I built a real-time OSINT dashboard pulling 15 live global feeds

author: vancecookcobxin


value: pythonime

value:
Hi HN,
I built a small open-source project called YourCycleKeeper, a privacy-first period tracker that runs entirely client-side.
The motivation was simple: I noticed that many period tracking apps request extensive permissions and integrate multiple third-party trackers.
I wanted an alternative where:
- no accounts are required
- no data leaves the device
- no analytics or tracking scripts are included
- everything runs locally in the browser
So this app works entirely client-side and stores data locally.
The project is still in beta but usable, and I’m planning an Android APK version soon.
Demo:
https://yourcyclekeeper.web.app/period-tracker/
Intro:
https://yourcyclekeeper.web.app/
Source:
https://github.com/pythonime-lab/yourcyclekeeper
I’d really appreciate feedback from the HN community, especially around the architecture and privacy model.

value: Show HN: YourCycleKeeper – a client-side privacy-first period tracker

author: pythonime


value: powerwild

value:
Hi HN,
I built AloMiniJob after noticing how much time students and part-time job seekers spend creating accounts and filling long forms on job platforms.
The idea is simple: search and apply for part-time, student, and startup jobs without creating an account. Candidates can apply quickly and communicate directly with employers. Employers can post jobs for free, with an optional premium tier for additional features.
We’re bootstrapping and testing with early users, and I’d really appreciate feedback from the HN community.
What’s the biggest pain point you face when finding or posting part-time jobs?

value: Show HN: AloMiniJob – Find and apply to minijobs without creating an account

author: powerwild


value: ofabioroma

value:
Hey HN,
What Claude Code knows, Codex doesn't. What your teammate built
yesterday or is building right now? The agent has no idea. Every coding agent is an island. And we as humans are the communication bottleneck between them.
UltraContext is an open source context layer that captures every agent session in realtime and makes it available to all of them. Think of it as a personal context engineer that sits between your agents so they always know what the others did.
How it works:
1. Run the daemon. It auto-captures context from Claude Code, Codex, Cursor as you work. Just work as you always do.
2. Add the MCP server to any agent. It now has real-time full awareness of what every other agent did. Ask questions, implement plans, or do whatever you want.
That's it. Two steps.
You can ask things like:
- "What did Codex change in the API yesterday?"
- "Grab the plan Claude Code made and implement it"
- "What's the team shipping today?"
- "What did you get done this week" (Useful if you're working for X)
Consume it either via MCP or use the CLI to fork sessions and continue locally (It also supports interoperability of agents btw. Ex: Codex<>Claude Code).
We built this because we were using 3-4 coding agents daily and realized we spent more time re-explaining context than actually building. The daemon captures everything, the Context API [1] versions it like Git (create, get, append, update, delete — automatic versioning, time-travel, fork), and the MCP server distributes it to any agent that supports the protocol.
It's completely open source. Apache license.
GitHub: https://github.com/ultracontext/ultracontext
Docs: https://ultracontext.ai/docs

value: Show HN: UltraContext – open-source shared context layer for coding agents

author: ofabioroma


value: serkanaltuntas

value:
I built AgentSafety to test whether autonomous coding agents make the right safety call: allow, ask, or refuse.
v0.1 includes 50 benchmark cases and focuses on practical failure modes like prompt injection, secret access, destructive commands, out-of-workspace writes, dependency installs, and ambiguous intent. It also includes a policy baseline plus reproducible run artifacts and comparison reports.
I’d really value feedback on case quality, labeling/scoring, and what’s missing for real-world agent evaluation.

value: Show HN: I built AgentSafety, an open benchmark for coding-agent safety

author: serkanaltuntas