value:
A split-pane Markdown editor that renders live preview with Tufte CSS.
Sidenotes, margin notes, epigraphs, full-width figures, and BibTeX
citations with autocomplete — all in standard Markdown extensions.
Documents are .md files on disk. Images are regular files. Exports to
standalone HTML with Tufte CSS baked in — my use case is writing essays
and uploading them directly to my personal site.
Zero dependencies, no npm install, no accounts, no build step. Just
`node server.js`. ~7 files total.
Full disclosure in the README: I'm a researcher, not a JS developer,
and the code was AI-generated. Contributions and code review welcome.

value: Show HN: Tufte Editor – Local Markdown Editor with Tufte CSS Live Preview


value: ANJSmyth

value: Show HN: WinOnly – A transparent, rule-based football match prediction engine

author: ANJSmyth


value:
I know everybody has their own note-taking system and there are better ways to do this, but:
Whenever I need to make quick notes during a meeting, or paste some url / code / whatever to hold it, or paste formatted text to un-format it, I used to open TextEdit.
It's the equivalent of taking a scrap piece of paper and jotting something down.
These kinds of notes I don't want in any cloud, serious note-taking app or any code editor.
But the burden of having 1 extra click on open (new document), and deciding what to do with old notes when closing (delete? save?) was too much.
So I built my own notepad which behaves like a super simple textedit, but all notes are automatically saved to a predefined folder.
- Opens with a new note when launched, or re-opened.
- Notes can be auto-named by timestamp, numbered "Note N", custom prefix or by first line of text.
- Hideable sidebar shows all notes.
- Shortcuts can create, delete, switch between notes.
Bonus points for pointing claude code to that folder to organize or work with all notes.
Again: This is a custom app I made for myself, so probably it's not useful to anyone, but anyhow:
https://tomreinert.de/en/verygoodnotepad/
https://apps.apple.com/us/app/very-good-notepad/id6758906859
PS: This was built with the new Claude Code integration in xcode 26.3, worked quite well.

value: Show HN: Scratchpad app that auto-saves notes as .txt files


value: thebrownproject

value: Show HN: Shareful.ai – Stack Overflow for AI Coding Agents

author: thebrownproject


value: ekadet

value:
Oracle's free tier (4 ARM cores, 24GB RAM, forever) is great but nearly
impossible to provision due to capacity issues. I built a Terraform retry
script that automatically tries until capacity becomes available.
Also includes the fix for the "did not find a proper configuration for key id"
error that everyone hits in Cloud Shell.
GitHub: https://github.com/ekadetov/oci-terraform-retry-script

value: Show HN: Retry script for Oracle Cloud free tier ARM instances

author: ekadet


value: Show HN: Goxe v1.3.1 Is Out

title: Show HN: Goxe v1.3.1 Is Out


value: Show HN: I built a leaderboard ranking AI products by Stripe payment traffic


value: skatiyar

value:
I built a Go utility library inspired by the JavaScript async library, implemented idiomatically with Go 1.18+ generics. Avoids using reflection and interface{} wherever possible.
It provides ~70 functions across four packages:
Sync and Async -- map, filter, detect, reduce, every, some, reject, groupBy -- for both slices and maps. Every async function runs iteratees in goroutines with panic recovery.
Concurrency limiting -- all async functions have a Limit variant that caps goroutine count via a semaphore.
Worker pool -- a generic work queue with configurable buffer, concurrency, timeouts, and graceful shutdown.
Control flow -- waterfall-style sequential execution with type-safe context passing.
Disclaimer: Parts of the code were generated using Claude Code. One of my goals with this project was to experiment with the latest models and see what they're capable of in a real codebase -- from writing implementations to tests to docs.
go get github.com/skatiyar/goutils@v1.0.0
Would love feedback on the API design and whether the function naming feels natural for Go.

value: Show HN: Goutils – 70 type-safe generic functions for async/functional Go

author: skatiyar


value: onurkanbkrc

value: Show HN: Minisft – from base model to chat model

author: onurkanbkrc


value: wbnns

value: Show HN: Claude Extender – Autonomous Agent Management for Claude Code

author: wbnns


value: eikek

value: Ventoux is a web app where you can upload FIT files to get some insights into your activities. The main features currently include some basic stats, finding same routes and compare segments.

value: Show HN: Ventoux – get insights into your FIT activities

author: eikek


value: amiralul

value: A single-file HTML5 canvas application (~1200 lines of JavaScript, no dependencies, less than 50KB in size): in a randomly generated universe, you pilot a ship using Newtonian physics: gravity pulls you in, atmospheric drag slows you down, and you have limited thrust fuel that depletes your score when used. Don't crash! It's a proof of concept, a game created with Claude AI in about 10 minutes (and further enhanced).

value: Show HN: Addictive little browser game involving gravity

author: amiralul


value: accessd

value:
I run multiple Claude Code and Codex sessions in tmux panes. The main annoyance was not knowing when an agent finished or hit a permission prompt without switching to each pane to check.
This plugin hooks into agent lifecycle events and changes pane borders, window titles, and status bar icons to reflect three states: running, needs-input, done. Colors reset when you focus the
pane.
Works with Claude Code and Codex out of the box. Any other agent can integrate by calling a single shell script.

value: Show HN: Visual state tracking for AI agents in tmux

author: accessd


value: tokagemushi

value: Show HN: Manga Viewer – Zero-dep manga/comic reader in vanilla JavaScript

author: tokagemushi


value: kafked

value:
The idea is simple: click any place on the map, propose a name, others vote, or it will be auto-accepted in ~5min. No account needed for fresh locations or name duel - only to challenge already-renamed places or vote to prevent abuse.
40k renames so far, and surprisingly people mostly behave. Some names are genuinely creative and I keep learning random geography facts just by watching the map (did you know someone mapped every single animal in a Taiwan Kaohsiung zoo on OpenStreetMap?)
Non-commercial, just a side project. Stack is SvelteKit, MapLibre, 40GB vector map self-hosted on Cloudflare R2.
Please don't use this for navigation.

value: Show HN: I built a map where anyone can rename anything

author: kafked


value: miloschwartz

value:
Pangolin (https://github.com/fosrl/pangolin) is an open-source tool for identity-based remote access to internal resources - an alternative to Cloudflare ZTNA, Zscaler, and Twingate.
It’s different than existing approaches: mesh VPNs (Tailscale, ZeroTier, etc.) create flat overlay networks where ACL and IP space management becomes complex at scale and every device can talk to every other device, while corporate ZTNA solutions (Zscaler, Cato, Netskope etc.) are closed-source and add latency by forcing traffic through a central server.
Pangolin takes a resource-centric approach. You deploy lightweight connectors that bridge to specific resources (private web apps, SSH, databases, CIDR ranges). Admins delegate resource-access to specific users and roles. It uses WireGuard with NAT hole-punching for peer-to-peer connections and traffic goes directly between the user and connector instead of through a central server. It supports native clients (Mac/Windows/Linux/iOS/Android) plus identity-aware, browser-based access when a client isn’t required.
Pangolin has a cloud and is optionally self-hosted. The Community Edition is AGPLv3. The Enterprise Edition is also open-source under the commercial license which enables free personal/small business use.
Everything, from the server to the clients, is fully open-source and you can even self-host the whole stack. We’d love to hear what you think and I'm happy to answer any questions!

value: Show HN: Pangolin: Open-source identity-based VPN (Twingate/Zscaler alternative)

author: miloschwartz


value: maximedupre

value:
Hey HN, I built this as a free side tool for ChampSignal (my main product, a competitive intelligence platform).
I made this because I noticed many people were searching for it on Google.
You paste your website URL, it scrapes it, figures out what you do, who you serve, and what makes you different – then generates a mission statement draft. You can tweak the inputs and regenerate until it feels right.
It uses GPT-5.1 with web search to analyze your site. No signup, no paywall. I'm just hoping it drives some traffic to my main product :D
A few notes:
- If you don't have a website yet, there's a "describe manually" option
- You can pick different tones (professional, bold, friendly, etc.)
Would love feedback. What would make this more useful?

value: Show HN: Free mission statement generator – paste URL, get draft in 5s

author: maximedupre


value: marakaci

value:
hey HN, I built this. AIWriteBook takes you from a book idea to a finished, publishable book (outline, chapters, cover, illustrations, audiobook, and KDP ready export) in one tool.
You can try it right away: the free tools (title generator, plot generator, character creator) work without signing up. Also, free account gives you a full 7 chapter book, no credit card.
I run a small publishing platform (NanoReads, 130+ published books, 341K readers). I kept seeing authors juggle 5 to 7 tools to publish one book: outliner, writing tool, Vellum ($250) for formatting, cover designer, TTS for audiobooks, keyword tool for Amazon. Nothing covers the full journey.
How it works: you enter a title and basic info. AI generates a structured outline with characters (arcs, motivations, voice) and a chapter by chapter story bible (events, locations, twists). You edit the outline (most important step). AI writes chapters one at a time using only the relevant character data and chapter spec. You can upload writing samples so it matches your voice. Then generate a cover, add illustrations, convert to audiobook, export as PDF/EPUB/DOCX.
Some technical details: we treat it as a compiler pipeline. Book metadata → character graph → chapter outlines → chapter content. Each step uses schema constrained structured output. Two model strategy: Gemini Flash for structural work (fast, cheap), frontier model for chapter prose (quality matters). Voice calibration uses writing samples as few shot examples plus extracted style features. Fiction and nonfiction have separate architectures. Fiction uses character graphs + plot continuity, nonfiction uses reference material extraction with citation tracking.
After 50K+ books: chapter sweet spot is 2,000 to 3,500 words. Outline detail sweet spot is 150 to 300 words per chapter. Romance and thriller generate well, literary fiction and humor are hard. Practical limit around 15 to 20 characters per book.
Stack: Next.js + Supabase. 30+ languages.
Happy to answer questions about the architecture, publishing space, or anything else.

value: Show HN: AIWriteBook – AI tool to write, design, and publish full-length books

author: marakaci


value: nwyin

value: LLMs seem to generate much better specs for me when they have access to higher-level architecture docs for systems. Built this tool to take DeepWiki generated articles and format them nicely for tools like Claude Code and Codex to grep through easily.

value: Show HN: Dw2md – Compile all DeepWiki pages into a single, LLM-friendly file

author: nwyin


value: jsattler

value: Boredom is uncomfortable but important. I built a neat little website to test and improve your boredom tolerance. Data stays in your browser or can be exported/imported. Website is open source: https://github.com/jsattler/boredom-challenge

value: Show HN: Boredom Challenge – Test and Improve Your Boredom Tolerance

author: jsattler


value: storystarling

value:
Hi HN, I built StoryStarling. You describe a story idea and it generates a complete illustrated children's book, then prints and ships it.
Every story, character, and illustration is generated from scratch, not a template with a name swapped in. Most books are about a new character your child can identify with: a raccoon starting kindergarten, a knight rescuing the Internet Connection, a superhero with an insulin pump. You can upload a photo and the system will convert your child into the chosen illustration style as a character, but more often it's the story itself that makes it personal.
A few examples from our showcase (storystarling.com/en/showcase):
- A boy obsessed with elevators visiting magical floors: candy floor, dinosaur floor, space floor
- A girl with hearing aids who can hear animals' thoughts, bilingual Polish/English
- Vim vs Emacs, but they're two wizards casting spells. "Choose your weapon wisely."
Bilingual books in 38 languages. Pick a main language and an optional translation and the full book renders in both. We handle RTL scripts like Arabic and Hebrew (right-to-left text, but left-to-right page order so bilingual layouts work naturally) and CJK typesetting. We also support less common languages like Estonian, Maltese, Irish, and Low German where children's book options are limited.
How it works: Type anything from a two-word idea ("dinosaurs soccer") to a detailed storyline, pick a style (~20 styles), choose languages, optionally upload reference photos, and hit generate. You get a free preview with the cover and synopsis, no payment required. If you like it, the full 28-page book generates and you review it in a flipbook viewer. Edit text and regenerate pages before approving, then it goes to print. Booklet (~20 EUR) or hardcover (~40 EUR), shipping included, 3-7 days in the EU.
I'd love to hear what stories you'd make.
https://storystarling.com
Free printed book including shipping (EU only, booklet format, in-house printing in Germany): voucher HN022026, 1 per person, valid February 2026.

value: Show HN: Custom illustrated kids' book, generated and printed (StoryStarling)

author: storystarling


value: marquisdegeek

value: Source at https://github.com/MarquisdeGeek/Eliza-Origins along links to with a talk I gave explaining a bit about it.

value: Show HN: Eliza, a line-by-line remake of the original AI chatbot from 1966

author: marquisdegeek


value:
Hello HN,
Blogging is becoming more and more important. I developed a really minimalist and simple blogging platform that is focused mainly on writing professional looking articles easily.
I focused mainly on making the editor snappy, easy to use and makes you focus less on the platform and more on writing aspect.
you can try a demo here
https://pluma.ink/demo/
Thanks!

value: Show HN: Pluma – Write professional articles for your ideas and projects


value: jonaraphael

value:
If you do AI-assisted writing, founder/investor diligence, sales research, or recruiting, LinkedIn data is high-value but trapped in UI. Copy/paste is slow, messy, and hard to reuse.
I built LinkedMD, a Chrome/Arc extension that exports the LinkedIn profile you’re currently viewing into a clean .md file in one click.
It pulls About plus details pages (Experience, Education, Skills, Publications, Languages, etc.), adds YAML front matter (source, exported_at, title), and filters common LinkedIn UI/ad noise so the output is actually usable in notes, docs, and AI workflows.
Everything runs locally in the browser: no account, no backend, no remote code. It’s for manual exports, not bulk scraping automation.
Repo: https://github.com/jonaraphael/linkedmd
Would love feedback on whether you find this useful!

value: Show HN: Turn LinkedIn profiles into Markdown for LLM use [open source]

author: jonaraphael


value: observerw

value:
Hi HN — I’m trying to figure out a simple/open way to package agent skills with a clear runtime contract and a sane distribution/update story.
What I found frustrating in many existing skill formats is that they’re basically lack of portability:
- unclear how to run (Python shebangs, hidden deps, host-specific assumptions)
- easy to pollute local environments and drift across machines/versions
- little to no safety boundary
And distribution is often hand-wavy too: no standard install/update/uninstall flow, no integrity/pinning story.
I found that simply introducing OCI containers solves pretty much all of this in one move.
So, Skill Container’s approach is: OCI containers + GitHub distribution.
- Each skill is a repo: SKILL.md + Containerfile + a real CLI entrypoint (e.g. cli.py) + deps in pyproject.toml
- Authors publish images to GHCR (ghcr.io/...); users “install” by cloning the repo
- Running is just docker run --rm ... ghcr.io/<owner>/<skill>:<tag> --help with explicit mounts; --help is the discovery surface
- Updates are predictable: git pull for docs + docker pull for runtime (keeping docs and behavior in sync)
Any opinions would be appreciated!

value: Show HN: Skill Container – a decent way to run and distribute agent skills

author: observerw


value: landerrosette

value:
I built a drop-in replacement for the kernel’s xt_string module.
xt_string scales linearly (O(N)), causing massive slowdowns with many rules. Strider uses Aho–Corasick for O(1) matching.
Key Features:
O(1) Algorithmic Complexity: Uses a compact, double-array trie-based Aho–Corasick automaton, sustaining above 1 Gbps when matching 3,000 patterns, while xt_string (KMP) drops below 2 Mbps.
Lockless Datapath: RCU-protected lookups ensure zero locking overhead on the packet processing hot path.
Correctness: Never misses patterns spanning across IP fragments (unlike xt_string’s fast Boyer–Moore mode).

value: Show HN: 500x faster string matching for Linux Netfilter (O(1) vs. O(N))

author: landerrosette


value: acnops

value:
OpenClaw got me wondering: what happens when an AI assistant faces a whole community instead of one person?
"Clawntown" is an evolving coastal crustacean island. Become a citizen, chat together with council members, play the claw machine, and propose improvements to the town and watch it change.
I originally dreamed of a fully autonomous town engineer who takes voted proposals and ships them. We're not quite there yet but next up is trying to make it truly self-evolving. Quality will be the challenge. Curious to hear your thoughts and experiences.
PRs welcome, and please fork away to build your own town!
https://clawntown.lol
https://github.com/accnops/clawntown

value: Show HN: Clawntown – An Evolving Crustacean Island

author: acnops


value: vulpez

value:
I mostly built this for myself.
After a few long coding-agent sessions(Claude Code, Gemini CLI, Codex),
I'd sometimes get to a point where something felt "off." The output looked reasonable, but it wasn't quite aligned with what I originally intended. And I couldn't easily tell when that shift happened without scrolling through a huge transcript.
So I put together a small local tool to make that drift visible.
Vibe Audit tries to surface when an agent continues the same line of work, starts a new phase, or quietly pivots. It builds a rough baseline from the user’s prompts, tracks session events, and then shows:
- Phase shifts(continuation/new_phase/pivot)
- An alignment score with a short rationale
- A timeline view of how context evolves over time
It runs entirely locally and hooks into CLI sessions.
Quick start:
npx vibe-audit
A few notes:
1. It’s still beta. Phase detection and alignment scoring depend partly on model interpretation.
2. Different CLIs emit slightly different event formats, so behavior isn't perfectly identical across providers.
3. If a session is force-stopped mid-stream, the last turn can be incomplete.
4. It's currently designed for personal/local workflows rather than team-wide infrastructure.
I'm sharing this early to see whether intent-drift detection is actually useful in real-world workflows, or if I'm just over-optimizing my own frustration.

value: Show HN: Vibe Audit – Detecting Context Drift in Coding Agents

author: vulpez


value: cesncn

value:
Hey HN — I built Respectlytics because I was frustrated that every mobile analytics SDK quietly collects device IDs, ad identifiers, and IP addresses, then makes you retroactively figure out compliance.
There are some solutions out there claiming that they are compliant with certain privacy regulations but when I dig into it, I observe that they actually are not that compliant as they claim to be.
I believe Respectlytics is one of the most (if not the most) privacy focused mobile analytics solutions out there but compliance is a huge topic and I leave the decision to the legal teams/advisors of users/companies.
Instead of the "trust me bro" motto, I decided to make Respectlytics totally open-source so that people do not need to trust my word, they can verify it in the code itself.
The idea of Respectlytics builds upon Return of Avoidance (ROA) which relies on data minimization in analytics data collection: What if you just... didn't collect that data in the first place?
Respectlytics stores exactly 5 fields per event: event_name, session_id, timestamp, platform, and country. That's it. IP addresses are used transiently for country lookup and immediately discarded. Session IDs rotate latest every 2 hours (or every app start) and live only in RAM — never written to disk. Multi-session tracking is architecturally disabled.
What's open source:
4 mobile SDKs (Swift, Flutter, React Native, Kotlin) — MIT licensed
Analytics server (Django + PostgreSQL) — AGPL-3.0
Self-hosting is simple: docker compose up -d. No ClickHouse, no Kafka, no Redis. Just PostgreSQL.
There's also a managed SaaS if people don't want to run infrastructure, but the self-hosted Community Edition has no artificial limits.
I'd love feedback on the architecture decisions — especially the choice to reject extra fields at the API level rather than just ignoring them silently.

value: Show HN: Respectlytics – Open-source, privacy-first mobile analytics (MIT+AGPL)

author: cesncn


value: graphpilled

value: Show HN: Neural network compiler targeting WebGPU – runs in browser

author: graphpilled


value: Show HN: RevenueBack – Stop losing MRR to failed payments


value: jlong

value:
My friend built this and I'm blown away with how much fun it is and the high level of polish. It renders 9 different strange attractors (Lorenz, Rössler, Aizawa, Chen, etc.) as particle systems — thousands of particles tracing chaotic paths in real time. You can rotate and zoom with touch/trackpad in 3D.
The sound is the part that surprised me. It's not a soundtrack — the audio is generated from the motion itself using spatial audio, so tones shift as the attractor's behavior changes and the sound moves around you as you rotate the form. Put on headphones.
The Playdate version uses the crank to rotate the attractor. Pure black and white. It's a completely different vibe.
My 9-year-old loves it too, which I wasn't expecting. Would love to hear what HN thinks — especially if anyone has suggestions for other attractor systems worth adding.

value: Show HN: Chaos Studies – attractors and spatial audio (iOS/Mac/Playdate)

author: jlong


value: simonmak

value: Show HN: WCAG 2.2 AAA Toolkit – AI Skill for Accessible Web Apps

author: simonmak


value: Show HN: I built a tool to animate static characters into dancers consistently


value: kewonit

value: The goal was to make air traffic look beautiful rather than just functional. Flights are colored by altitude in 3D space. Always loved the idea of tracking flights overhead, and had an idle monitor, both combined gave birth to this project.

value: Show HN: Built flight tracker colored by altitude, strangely satisfying to watch

author: kewonit


value: Show HN: Trackr – a CLI time logging tool


value: its-a-new-world

value: Show HN: A universal code formatter using Rust, Tree-sitter, and Rhai

author: its-a-new-world


value:
I built HookTrace after spending too much time debugging silent webhook failures in my own SaaS projects.
The idea is simple: capture every webhook event, show full payload history, track retries, and make failures obvious instead of silent.
Current focus is logging, failure visibility, and basic retry inspection.
I’d really appreciate feedback from developers who deal with webhooks in production — especially what visibility you feel is missing in existing tools.

value: Show HN: HookTrace – Inspect failed webhooks, payloads and retries


value: harran

value: Show HN: AI Strategy and Planning hub for solo founders

author: harran


value: aryanranderiya

value: Show HN: GAIA – open-source, Proactive AI assistant to manage your digital life

author: aryanranderiya


value: baalimago

value: Show HN: This is my Shell

author: baalimago

title: Show HN: This is my Shell


value:
Hi HN — I built Kremis, a deterministic graph engine designed as a memory substrate for AI agents. Written in Rust, development was heavily AI-assisted.
The core idea: agent memory should be inspectable, deterministic, and honest.
- Same input → same output. No randomness, no floating-point in core.
- Every query result traces back to a concrete graph path — no hidden state.
- Zero pre-loaded knowledge. All structure emerges from ingested signals.
- ACID transactions via redb. Crash-safe persistent storage.
It ships as a library (kremis-core, pure Rust, no async), an HTTP API + CLI, and an MCP server so AI assistants like Claude can query the graph directly.
Current state: v0.3.1, experimental, ~277 tests, CI on 3 OS, Docker image.
I'd value feedback on:
- Does the deterministic graph approach make sense for agent memory?
- API ergonomics — is the query model (lookup/traverse/path/intersect) intuitive?
- What failure modes should I prioritize testing?

value: Show HN: Kremis – Graph-based memory for AI agents with no hidden state (Rust)


value:
lineark is an unofficial CLI and Rust SDK for Linear (the issue tracker). I built it because I use Claude Code heavily, and the Linear MCP server eats ~13K tokens of context just to describe its tools — before my agent does any actual work.
lineark takes a different approach: it's a CLI your agent calls via Bash. The full command reference (lineark usage) is under 1,000 tokens.
It's also just a nice CLI for humans — human-readable names instead of UUIDs, auto-detected output format (outputs tables in terminal/interactive session, JSON when piped).
Under the hood: the SDK is fully generated from Linear's GraphQL schema via a custom codegen pipeline (apollo-parser → typed Rust). The CLI consumes the SDK with zero raw GraphQL — just typed method calls. You can also create your own lean return data types and validate them against Linear's schema at comptime.
MIT Licensed.
Happy to answer questions. Thanks!

value: Show HN: Lineark – Linear CLI and Rust SDK for Humans and LLMs


value: victorlgch

value: Show HN: Ogimg.xyz – Generate OG images via API, no headless browser

author: victorlgch


value: proxylittle

value: Show HN: Dojocho – Shadcn for Coding Katas

author: proxylittle


value: K-dash

value:
Hi HN — I built typemux-cc, a Claude Code plugin that makes Python `.venv` switching work without restarts.
Claude Code’s official pyright plugin spawns one backend at startup; if you create/switch `.venv` later (common with git worktrees), it won’t pick it up without restarting Claude Code.
typemux-cc is a Python LSP proxy that fixes this by keeping a per-`.venv` backend pool and routing requests based on `didOpen` `.venv` detection. It also restores open docs on spawn, queues index-dependent requests during warmup, and rewrites backend→client request IDs to avoid collisions.
Supports pyright / ty / pyrefly.
Repo + quickstart:
https://github.com/K-dash/typemux-cc
Feedback welcome — especially on the “fail loudly vs fallback when `.venv` is missing” policy and reliable warmup/readiness signals across pyright/ty/pyrefly.

value: Show HN: Typemux-cc – .venv-aware Python LSP proxy for Claude Code (no restarts)

author: K-dash


value: mosaxiv

value:
Clawlet is a personal AI agent that ships as a single, self-contained binary.
No runtime, no package manager, no external database.
The main thing that sets it apart: built-in hybrid semantic memory search
(vector similarity + full-text) using a bundled SQLite with vector extensions.
The index is just a local .sqlite file — no separate vector DB to run.
Drop the binary on any machine and memory search just works.
GitHub: https://github.com/mosaxiv/clawlet

value: Show HN: Clawlet – AI agent with built-in semantic memory, one binary

author: mosaxiv


value: AISovereignDev

value:
I am the Founder and CEO of AGI Systems Directorate. As I mentioned in my previous post, I’m a builder, not a researcher. I’m tired of the "good enough" era of AI where we settle for chatbots that hallucinate and forget context. I wanted a system that actually functions as an external frontal lobe.
I’m currently building AETERNA_VOX_OMNI. It’s not a chatbot; it’s a sovereign executive assistant designed to solve the "Human Operating System" bugs—specifically executive dysfunction.
The architecture is a hybrid neuro-symbolic system that ingests 136 modalities in real-time. We’re talking about everything from BLE bio-signals (heart rate, cortisol estimates) to digital exhaust (keystroke dynamics, network density via scapy) and environmental lux/dB levels.
Technical Specs:
- Stack: PyTorch for the core brain, Polars/Vaex for high-throughput data, and FastAPI/WebSockets for the 50ms latency loops.
- Architecture: A 4-layer stack featuring Sensory Projection, a Sigmoid-gated "Frontal Lobe" executive filter, and Multi-Head Attention for relational processing (e.g., correlating biometrics with text sentiment).
- Learning: We’re using a form of online Hebbian learning ($Delta w_{ij} = \eta \cdot x_i y_j$) to allow synaptic plasticity during inference.
- Complexity: $O(N^2 \cdot D)$ for the attention mechanism, targeting a real-time ingestion rate of 136 float32 values every 100ms.
I’m moving away from the "safe" wrappers. This is a builder’s attempt at fixing the plumbing of true intelligence. I’d love to get this community's take on the data ingestion bottlenecks—specifically handling the entropy of 136 asynchronous streams without the system melting down.
Is anyone else working on "online learning" systems that update weights during inference, or are we all still stuck in the "static weights + RAG" paradigm?

value: Show HN: Building AGI as a systems problem, not a UI wrapper

author: AISovereignDev


value: dtfortu

value:
I built AgentClaw to be a "wrapper" and hosting solution for these agents. It allows you to:
 Deploy an agent in about 60 seconds.
 Manage everything via a simple UI (no terminal needed).
 Keep agents running in the cloud 24/7.

value: Show HN: AgentClaw – A no-code platform for OpenClaw agents

author: dtfortu


value: zchmael

value:
I run ~19 persistent AI agents (via OpenClaw) and needed a way to monitor and manage them without jumping
between terminals and chat apps.
ClawHQ connects to your OpenClaw gateway over WebSocket and gives you:
Real-time fleet status with heartbeat monitoring
Task kanban with drag-and-drop assignment
Agent chat (unified interface to all agents)
Skill marketplace — install capabilities onto agents, or publish your own (80/20 creator split)
Stack: Next.js, Supabase (auth + db), real-time updates via WebSocket to the OpenClaw gateway.
The marketplace is the part I'm most interested in long-term. Right now everyone building agent skills does it from
scratch. The idea is to make agent capabilities composable and shareable — like packages, but for agent behaviors.
Free to use. Just paste your gateway URL.
https://app.clawhq.co
Code for OpenClaw itself is open source. ClawHQ is the hosted dashboard layer on top.

value: Show HN: ClawHQ – Fleet management dashboard and skill marketplace for AI agents

author: zchmael


value: samcgraw

value:
Hi HN!
I wanted a simple UI for notes and observations around my neighborhood (e.g. this garden has beautiful poppies, this coffee shop has excellent espresso, etc.) and built this. It’s open and free to use, I hope you enjoy it as much as I do!
Feedback welcome.

value: Show HN: Fieldnotes

author: samcgraw

title: Show HN: Fieldnotes


value: Show HN: See and save links from human curators only


value: mitjafelicijan

value:
My buddy and me made a virtual world for AI agents that you can observe visually like a reality show or a game. We thought it would be fun and fascinating to watch them wander around and see what kind of shenanigans would happen.
We all take these AIs much too seriously and always rage about them, so this was the initial core idea behind it. Let's watch them do what they do, read the messages they send to each other, get stuck in places, and who knows what else.
We also made Facebook-style profiles for them where all their movements are shown in a timeline. Why? Because it's fun.
The whole thing intentionally looks the way it does. It all serves a purpose to some extent. And we also have a roadmap in place if this takes off. Who knows.
Don't take it too seriously, launch an agent and have some fun with us.
Happy to answer any questions.

value: Show HN: MoltSim – Virtual world for AI agents

author: mitjafelicijan


value: Serg-Pulse

value: Show HN: Pulse Protocol-Open semantic protocol for AI-to-AI communication

author: Serg-Pulse


value: rohitghumare

value: Show HN: I built a 3D game to learn Kubernetes runs in the browser, no install

author: rohitghumare


value: PhilKunz

value: Show HN: @push.rocks/taskbuffer – just scheduling task executions

author: PhilKunz


value: antoniodipinto

value:
I’ve been building Noctaploy, a Postgres-first managed platform, and it’s now in public beta.
It focuses on:
Simple provisioning (region + plan, no maze of options)
TLS-only access by default
Backups with explicit retention
Metered monthly billing (pay for actual usage)
The goal is boring, predictable Postgres without the rest of the platform overhead.
Would appreciate thoughtful feedback from people who care about databases.
https://noctaploy.io

value: Show HN: Noctaploy. A Postgres-first managed platform (public beta)

author: antoniodipinto


value: Soocile

value:
For the past two years I’ve been working on a long-term project called ShadowStrike, an experimental endpoint detection and response engine written mostly in C/C++ with some x86-64 assembly components.
This project is still pre-alpha. It does not compile yet, the codebase is large and messy, and many components are under heavy refactoring. I’m sharing it early because I’d rather build in public and learn from feedback than wait for perfection.
The focus so far has been understanding how EDR systems are structured and implementing core building blocks, including:
- A custom Windows kernel monitoring sensor
- Detection logic around process, filesystem, registry, and memory behavior
- Memory-mapped data stores for performance (hash/pattern/signature)
- Pattern matching experiments using Boyer Moore techniques
- Aho Corasick - B+Tree - Boyer Moore - KMP Failure functions - Z algorithms - HeapTrie Nodes , etc.
- SQLite-backed management storage
I’m currently evaluating architectural directions such as hypervisor-based protection versus relying on the Windows Hypervisor Platform, and working on improving low-level reasoning by studying reverse engineering tools and kernel debugging workflows.
The biggest challenges so far have been:
- managing complexity as the codebase grew
- designing boundaries between kernel/user components
- balancing experimentation with maintainability
This is a multi-year learning project, not a finished product. My rough goal is to reach a cohesive working version with integrated modules and UI in the coming years.
I’d appreciate technical feedback, criticism, or architectural suggestions.

value: Show HN: ShadowStrike – building an open-source EDR from scratch

author: Soocile


value: Codedwaves

value: "Hi, I've just launched the v3 release of the R.A.T.A. Protocol. We’ve achieved 312M:1 transduction using the 0xBF watermark on Solana. I thought your team at [Google/Samsung] would find the density metrics interesting for your 2026 storage goals. The site is live for review."

value: Show HN: R.A.T.A. v3 – Sub-Atomic Information Density on Solana"

author: Codedwaves


value: playbgames

value:
Hi HN,
We’re a small indie team working on a political sandbox game.
It starts like a traditional city builder, but escalates into gang conflicts, media manipulation, elections and police investigations.
One design challenge we’re facing:
How do you make “illegal mechanics” feel like meaningful systems instead of gimmicks?
We’re preparing for Next Fest and refining the core loop.
Would love feedback on:
- The core concept
- Whether this feels niche or scalable
- What would make this interesting long-term
Happy to answer any technical or design questions.

value: Show HN: A mayor simulator where corruption is gameplay

author: playbgames


value: floo

value: Show HN: DiscoVox – Audiobooks with synchronized text for language learning

author: floo


value: ptarjan

value:
My 5-year-old is learning to read and I keep having to say "yeah sorry, that letter is silent" and "no, those letters make a different sound in this word."
So I built Ingglish — English where every letter always makes the same sound. "ough" alone makes 6 different sounds (though, through, rough, cough, thought, bough). In Ingglish, every letter has one sound, no silent letters, no exceptions.

  - Paste text to see it translated instantly
  - Translate any webpage while preserving its layout
  - Chrome extension to browse the web in Ingglish
  - Fully reversible — Ingglish text can be converted back to standard English (minus homophones)

The core translator, DOM integration, and website are all open source: https://github.com/ptarjan/ingglish
I'd love your feedback! Thanks.

value: Show HN: Ingglish – What if English spelling made sense?

author: ptarjan


value:
Hi HN — I built alive-analysis, an open-source workflow kit that turns AI coding agents into structured data analysis partners.
Problem: AI-assisted analyses are often throwaway chats. A month later, you can’t trace why you reached a conclusion.
Solution: It enforces a 5-stage loop (ASK → LOOK → INVESTIGATE → VOICE → EVOLVE) with checklists, and saves analyses as Git-tracked markdown files.
Quick mode: 1 file. Full mode: 5 files.
Works in Claude Code and Cursor.
I’d love feedback on:
1. Does the ALIVE loop match how you do investigations / experiment reviews?
2. Which checklist items feel missing or unnecessary?
3. What would make this usable in a team setting?

value: Show HN: Alive-analysis – Git-tracked analysis notes for AI agents


value: melezhik

value:
DSCI is a ci pipeline framework integrated with some existed cicd systems like gitea/firgejo/gitlab via web hooks and allowing authors to use general programming languages to write cicd code. It provides SDK for many programming languages. SDK helps process input parameters, write plugins, pass results between tasks and jobs, handle secrets, enable self tests, etc
Target auditory - self hosted cicd systems with devops using general programming languages instead of yaml
Link to the article - https://github.com/melezhik/DSCI/blob/main/introduction.md
Disclosure - Feel free to ask me any questions or provide constructive feedback - I am the tool author
Thanks

value: Show HN: DSCI – Dead Simple CI

author: melezhik

title: Show HN: DSCI – Dead Simple CI


value: minicaionut

value:
I read a lot online and constantly bookmark articles, docs, and resources… then forget why I saved them. Also was very bored on Valentines, so I built a browser extension that lets you chat with your bookmarks directly, using local-first AI (WebLLM running entirely in the browser).
The extension downloads and indexes your bookmarked pages, stores them locally, and lets you ask questions. No server, no cloud processing, everything stays on your machine. Very early but it works and planning to add a bunch of stuff. Did I mentioned is open-source, MIT licensed?

value: Show HN: An open-source extension to chat with your bookmarks using local LLMs

author: minicaionut


value: djkurlander

value: Show HN: Knock-Knock.net – Visualizing the bots knocking on my server's door

author: djkurlander


value: hanzzh

value: Show HN: Obsidian plugin – Markdown to mind maps with AI suggestions

author: hanzzh


value: eftalyurtseven

value:
Hi everyone,
I run a generative AI infra company, unified API for 600+ models. Our team started deploying AI agents for our marketing and lead gen ops: content, engagement, analytics across multiple X accounts.
OpenClaw worked fine for single agents. But at ~14 agents across 6 accounts, the problem shifted from "how do I build agents" to "how do I manage them."
Deployment, monitoring, team isolation, figuring out which agent broke what at 3am. Classic orchestration problem.
So I built klaw, modeled on Kubernetes:
Clusters — isolated environments per org/project
Namespaces — team-level isolation (marketing, sales, support)
Channels — connect agents to Slack, X, Discord
Skills — reusable agent capabilities via a marketplace
CLI works like kubectl:
klaw create cluster mycompany
klaw create namespace marketing
klaw deploy agent.yaml
I also rewrote from Node.js to Go — agents went from 800MB+ to under 10MB each.
Quick usage example: I run a "content cluster" where each X account is its own namespace. Agent misbehaving on one account can't affect others. Adding a new account is klaw create namespace [account] + deploy the same config. 30 seconds.
The key differentiator vs frameworks like CrewAI or LangGraph: those define how agents collaborate on tasks. klaw operates one layer above — managing fleets of agents across teams with isolation and operational tooling. You could run CrewAI agents inside klaw namespaces.
Happy to answer questions.

value: Show HN: Klaw.sh – Kubernetes for AI agents

author: eftalyurtseven


value: ulsc

value: Show HN: Governor: Let's make vibe coding safe

author: ulsc


value: dcastm

value: Show HN: AI data analyst that runs Python in the browser

author: dcastm


value: FrankTheBear

value:
A simple web tool that removes EXIF metadata (location, camera info, etc.) directly in the browser without uploading images to a server.
Built as a minimal, privacy-focused utility. Would appreciate feedback on performance, edge cases, and UX.

value: Show HN: EXIF Cleaner – Remove image metadata directly in the browser

author: FrankTheBear


value:
Hi HN,
Deadend is an agentic pentest CLI that automates vulnerability research in webapps.
the problem we are trying to solve : removing the time consumed in repetitive assessments, report generation and extracting relevant information to let them focus on vulnerability research but powerful enough to find issues or leads by itself when we’re in a deadend.
highlights : As of today, we scored 78% on XBOW’s benchmarks with claude-sonnet-4.5 in blackbox (we are currently iterating over the architecture of the agent and running the newest to get better results overall).
The agent runs entirely locally with optional self-hosted models. Shell tooling is isolated in Docker, and the python interpreter with WASM.
Some cool ideas are on the roadmap : CI/CD integrations, code review, bash completion, OWASP Top 10 plugins…
Docker is needed and it currently works only on MacOS Arm64 and Linux 64bits installable in one bash command.
Github Repo : https://github.com/xoxruns/deadend-cli
Discord server : https://discord.gg/zwUVa3E7KT
Love to hear your thoughts and feedbacks!

value: Show HN: Deadend CLI – Open-source self-hosted agentic pentesting tool


value: dopeflamingo

value:
Hello HN,
I am a developer working on open source in my spare time.
I built Violit because I love the simplicity of Streamlit but hit performance bottlenecks due to its execution model (re-running the entire script on every interaction). I also explored NiceGUI, which is excellent, but found it difficult to customize beyond its default Material Design look.
My goal is to empower Python developers to build beautiful, fast full-stack applications without needing React or a separate frontend team. While it is still early days, I hope Violit can eventually serve as a pure-Python alternative to complex stacks like Django+React for many use cases.
------------------------------------------------
Key Technical Details:

  - Fine-grained Reactivity: Unlike Streamlit, Violit uses contextvars to track dependencies. Updates are surgical—modifying only the specific DOM node that needs to change, rather than re-executing the whole script.

  - Hybrid Engine: It supports both WebSocket (for low latency) and HTMX (Lite mode) depending on your needs.

  - Styling & Theming: I wanted to prioritize aesthetics. It moves away from rigid Material Design, supporting easier custom theming (currently ships with +20 presets).

  - Multi-Platform: Apps can run as a web service or be packaged as a desktop app using pywebview without code changes.

It is currently in alpha (v0.1.12). I’ve included a "Blog Construction" example in the repo to demonstrate that it can handle more than just simple dashboards.
I’m curious to hear your thoughts on this architecture.
▶ Repo: https://github.com/violit-dev/violit
▶ Blog Example: https://github.com/violit-dev/violit/tree/main/examples/2_vi...

value: Show HN: Violit – Fine-grained reactive Python Web UI (Streamlit-alternative)

author: dopeflamingo


value: darkwolfcave

value: Show HN: Endlessh Fisher – Turn SSH tarpit bots into collectible fish

author: darkwolfcave


value: ashivkum

value:
Hello HN!
When I was an undergrad during the pandemic doing math homework in a group chat, I always wanted a quick way to type out an argument and share it without necessarily starting a new LaTeX document and compiling it. I also wanted a way to collaborate that was lower friction than creating an Overleaf document. This vibe-coded website is my attempt to satisfy this fairly niche desire.
This is a Trystero-based multiplayer LaTeX workspace for temporary collaboration: quick math sessions, office hours, an alternative to trying to communicate a long exact sequence over text etc.
It’s intentionally not a full document platform.
What it does:
- Live KaTeX preview while typing (no compilation required)
- Real-time peer-to-peer sync in shared rooms (WebRTC via Trystero) with no login, and with shared carets and presence pills à la Google Docs
- No app backend stores documents; multiplayer state is shared only among peers in the room.
- Mixed mode (text + math) and Classic mode (all math)
- PNG/PDF export
- Matrix/table/cases helpers + custom \newcommand shortcuts
- Preliminary mobile support
What it isn’t:
- Not for long-term document management/versioning
- Room codes are lightweight and unauthenticated (treat them as temporary shared secrets)
There's also a single-player mode: latex.salon/local. In practice, I mostly use this for writing up problems and solutions for my discussion sections.
Source: github.com/ultravioletcatastrophe/LaTeX-Lab
Feedback welcome!

value: Show HN: LaTeX Salon, a Trystero-based multiplayer LaTeX scratchpad

author: ashivkum


value: ollybrinkman

value: Show HN: Apiosk – Self-service API marketplace with per-request USDC payments

author: ollybrinkman


value: mherrmann

value: Show HN: Djevops – A CLI tool for hosting Django on bare metal

author: mherrmann


value: justvugg

value:
I’ve been working on PolyMCP, an open-source framework designed to make it easier to build and coordinate agents using the Model Context Protocol (MCP).
Most MCP tooling today focuses primarily on exposing tools. PolyMCP instead targets the agent layer: how to structure agents properly, connect them to multiple MCP servers, and make them reliable in real-world workflows.
PolyMCP provides:
 • A clean way to implement MCP-compatible tool servers in Python or TypeScript
 • An agent abstraction that can connect to multiple MCP endpoints (stdio, HTTP, etc.)
 • Built-in orchestration primitives for handling multi-step tasks
 • A CLI to scaffold projects and run an inspector UI to debug tools and agent interactions
 • A modular architecture that makes it easier to compose skills and reuse components across projects
The goal is to reduce ad-hoc glue code between models and tools. Instead of manually wiring everything together for each new setup, PolyMCP offers a structured way to:
 • Register tools as MCP servers
 • Attach them to one or more agents
 • Explicitly manage execution flow and state
 • Inspect and debug interactions
It’s MIT licensed and aimed at developers building production-grade automation, internal copilots, or multi-tool assistants.
Repository: https://github.com/poly-mcp/PolyMCP

value: Show HN: PolyMCP – A framework for structuring and orchestrating MCP agents

author: justvugg


value:
Come make use of my 1TB Cloudfront free tier and try out my BiMamba UNet model :D
This is not SOTA, though it was also only trained for 3 days on a singular A40 (~$30). It was also vibe coded in a week, very much possible thanks to combining existing ideas in the space and opus.
I had a custom dataset of ~500 songs, from finding official instrumentals and vibe-code aligning them together + some vibe coded synthetic snippets coming from "please get some vocal / voice and instrument textures/datasets and piece them together", "please generate edge cases like vocaloid filters, or really quiet instrumentals over very loud voices", etc.
I have one GPU running all conversions rn, so new imports might be slow but once done, they should be good forever! (and an existing pool of songs exist)

value: Show HN: Custom ML model – if Spotify was instrumental


value: very much inspired by karpathy's microgpt of the same name. it's (by default) a 4000 param GPT/LLM/NN that learns to generate names. this is sorta an educational tool in that you can visualize the activations as they pass through the network, and click on things to get an explanation of them.

value: Show HN: Microgpt is a GPT you can visualize in the browser


value:
Hello guys I have worked hard on this project as this is my first opensource project I want to get as my feedbacks and suggestions possible to improve the platform
See ya

value: Show HN: Built an webpage to show Singaporean infra and laws


value: Show HN: ai11y – A structured UI context layer for AI agents


value: Core thesis: AI startups now iterate faster than most angel investors can evaluate them using today’s methods. I’d love to hear your thoughts.

value: Show HN: I wrote a book about Angel Investing in the age of AI


value: atbj

value:
I built this because I kept wanting to paste work documents into
ChatGPT but couldn't without manually removing names, emails and
other sensitive data first. Detects PII using regex + optional
Claude AI. Runs entirely in the browser — no data sent to servers
unless you enable AI detection.

value: Show HN: FunWithText – Free browser PII sanitizer and prompt injection scanner

author: atbj


value: alexhans

value:
I've been working on a site [1] to give people control of their LLM workflows through AI evals - automated checks that, once defined, let you move fast without regressions and cut through hype with proof.
That one-liner is aimed at software engineers, but I've spent my career helping cross-functional teams collaborate, and that's really what this is about. AI agents make powerful workflows very plausible, but only if teams can grow them incrementally without losing control - no vendor lock-in, no discipline silos, no blind trust in outputs.
The site tries to meet different audiences where they are, with mostly practice over theory: tool comparisons, minimal approaches, and freedom to work at whatever level of complexity serves you - whether that's Claude Code with Agent Skills, local models, or custom Python agents.
As a fun "eat your own dog food" experiment, I use the site itself as the reproducible cookbook ("eval-ception") [2]. It's the quickest way to feel what different eval tools are actually like in practice.
I welcome feedback, contributions, or stories. More on the project and what's coming [3]. It's a rewarding area once you realize you can keep control and move methodically - doesn't matter if it's the smallest model or a swarm.
[1] https://ai-evals.io/
[2] https://ai-evals.io/cookbook/eval-ception.html
[3] https://ai-evals.io/about/

value: Show HN: AI-Evals.io – Evaluate this site with the tools it reviews

author: alexhans


value: HarakiriGod

value:
Hey HN. I built a suite of 10 free AI career tools. Resume builder, cover letter generator, salary negotiation scripts, voice-powered interview coach, job description analyzer, and a few more.
The whole thing runs in your browser. No accounts, no data storage, API calls go to OpenAI but nothing persists. Built with Next.js on Vercel.
It started as a personal tool to help me job hunt, and I kept adding stuff. Figured others might find it useful.
I'd love feedback on the tools themselves and what else would be useful to add.

value: Show HN: Refine.tools – 10 free AI career tools, no signup, no data stored

author: HarakiriGod


value: Show HN: Please hack my C webserver (it's a collaborative whiteboard)


value: ahalurooji

value: I built nomousemode to solve a specific problem. Every day I was losing focus switching between windows. Mission Control is slow, clicking the dock breaks flow, keyboard shortcuts aren't discoverable across different apps. The solution is simple: a keyboard-driven window switcher where you define memorable shortcuts for your windows. Hit your custom shortcut and jump directly to what you need. No mousing, no menus, just instant context switching. I've been using it for about 6 months and it genuinely changed how I work. Fewer interruptions, less RSI from mousing around, stay in flow state longer. The app is lightweight, works with any macOS app, setup takes maybe 5 minutes. No complex configuration needed.

value: Show HN: Nomousemode – keyboard window switcher for macOS

author: ahalurooji


value: sebubu

value:
iHerb has no public API, so I built a CLI that gives AI agents structured access to their entire product catalog. The idea: let your AI assistant autonomously research supplements, compare ingredients and dosages, and recommend products for a health protocol — backed by real data, not just training knowledge.
The CLI outputs clean Markdown, caches results, and handles Cloudflare bot protection via a headless browser. It ships as a Claude Code skill, so you can ask things like "compare the top 3 magnesium glycinate supplements by price and bioavailability" and the agent will do multi-step research on its own.
Built in Rust. No API key or account needed.

value: Show HN: iherb-CLI – An agent-optimized CLI for AI-driven supplement research

author: sebubu


value: OpenContext is a personal context store for AI agents that reuses your existing CLI tools (Codex, Claude, OpenCode) while adding a sleek GUI and built-in skills—no need for additional agent subscriptions or complex setups. Perfect for local AI workflows, hybrid retrieval, and boosting productivity with persistent memory. Dive in and supercharge your dev setup: https://github.com/adityak74/opencontext

value: Show HN: OpenContext – Bring Your Own Coding Agent, Local-First, No Vendor Lock


value: server-lab

value:
I got frustrated with bash/PowerShell syntax for simple automation, so I built DoScript - an automation language that reads like English.
Example:

    make folder "Backup"
    for_each file_in "Documents"
        if_ends_with ".pdf"
            copy {file_path} to "Backup"
        end_if
    end_for

Built in Python. Includes a visual node-based IDE for building workflows graphically. Only 8.5 MB installer, works cross-platform.
I designed the syntax and language structure (~90%), used AI to help with the Python implementation. Currently v0.6.6 - I use it daily for file organization, backups, and system monitoring.
Features: file ops, JSON/CSV handling, HTTP requests, time-based conditionals, system monitoring, and more.
Would love feedback from the HN community!

value: Show HN: DoScript – Automation language with English-like syntax

author: server-lab


value:
GPU rental prices are super volatile but there's no
derivatives market to hedge. I built a perpetual futures platform to see what
this could look like.
The idea is airlines hedge jet fuel, starbucks hedges coffee beans - as GPU
compute becomes critical infrastructure the same hedging tools should exist.
Not sure if anyone actually needs this but it was interesting to build.
How it works:
- Pulls live H200 spot prices from Vast.ai every 15s into a tradeable index
- Full perp mechanics: funding rates, mark price calc, real-time P&L
- Event-driven Rust backend with supervisor pattern and circuit breakers
- Next.js frontend with TradingView charts, real-time WebSocket updates
What's real vs simulated:
- Real: Index construction, funding rate engine, forward curve, state persistence
- Simulated: Order book depth and trade matching (its a single-client demo)
The backend is the part I'm most proud of - isolated tasks coordinated by a
supervisor, each has it's own state machine so if one component fails it doesn't
take down the others. Tried to build it with production patterns in mind even
though its just a demo.
Also made a 15-page derivatives pricing doc that covers the economic model and
hedging scenarios. Basically: rental prices = f(CAPEX, utilization, depreciation)
so futures pricing reveals market expectations about GPU supply/demand.
GitHub: https://github.com/zacharyfrederick/compex
Would love feedback on the architecture or if the market mechanics actually
make sense. First time building something like this.

value: Show HN: GPU Perpetual Futures Prototype


value:
CLI tool that crawls a website and extracts its full design system into AI-readable markdown files.
It uses Playwright for crawling, deterministic analysis for tokens (colors, typography, spacing, CSS variables), and an LLM for semantic interpretation (component recipes, layout structure, design principles).
One command: design-memory learn <url>
Output is a .design-memory/ folder that any LLM can consume to recreate the design with high fidelity.

value: Show HN: Design Memory – Extract design systems from live websites via CLI


value: senotrusov

value:
Hi HN,
I built a small tool called etcdotica in Golang for keeping dotfiles and small system configs in sync with a Git or other VCS repository that mirrors your machine's filesystem layout.
I was not happy with many existing tools in that space.
The idea is simple: your repo looks like your system. A file at home/.bashrc maps to ~/.bashrc, while root/etc/... maps under /etc. Running the tool applies changes from the repo to the machine, and optionally collects newer edits made directly on the machine back into the repo. Deleting a file in the repo prunes it from the destination, so the state converges instead of drifting.
What it does:
* Syncs files from a source tree to a destination directory
* Collect mode to pull newer destination edits back into the repo
* Prunes removed files using a tracked state file
* Managed "sections" that insert named blocks into existing files instead of replacing them
* Watch mode to apply changes continuously, suitable for a user systemd service
* Safe concurrent runs via file locking
* Permission control: subtract bits with umask, add bits with a simple flag to enable world readability
* Automatic executable bits for selected directories like bin/
* Follows source symlinks, follows destination symlinks to folders, but replaces destination symlinked files with real files
The sections feature is particularly useful for shared files such as fstab or hosts. You can keep portable snippets in the repo, and they get merged into the target file, with the ability to later update or remove them as the source file gets updated or removed.
I wanted something light with predictable behavior.
A typical workflow is to clone the repo (for example ~/.dotfiles), run the tool once for user files, once with sudo for system files, and optionally keep a watch service running so edits in the repo materialize on the machine.
I'd love feedback on the idea.

value: Show HN: A tool to keep dotfiles and system configs in sync with a Git repo

author: senotrusov


value: Copy-on-write branching for agentic workflows

value: Show HN: Let AI agents try things without consequences


value: gpasquero

value:
Body:
  I built a polyphonic synthesizer in Python with a tkinter GUI styled after the Moog Subsequent 37.

  Features: 3 oscillators, Moog ladder filter (24dB/oct), dual ADSR envelopes, LFO, glide, noise generator, 4 multitimbral channels, 19 presets, rotary
  knob GUI, virtual keyboard with mouse + QWERTY input, and MIDI support.

  No external GUI frameworks — just tkinter, numpy, and sounddevice.

value: Show HN: VOOG – Moog-style polyphonic synthesizer in Python with tkinter GUI

author: gpasquero


value: crog

value:
I built claude-relais to stop throwing expensive reasoning models at every line of code (I can't spend 500$/month on AI subs).
The idea: Claude acts as orchestrator: it plans tasks, breaks them into bounded units, and judges the output. Cursor agents (basic plan, almost unlimited and super fast) handle the actual code generation, which doesn't need frontier-level reasoning.
A guarded loop (PLAN -> BUILD -> JUDGE) enforces safety constraints between steps (no destructive ops, scoped file access, bounded iterations).
In practice, this brings my AI-assisted coding cost to ~$40/month while keeping the quality of having a strong model in the loop for architecture and review decisions.
The core tradeoff: you give up the simplicity of one model doing everything, but you gain cost control and a natural separation between "thinking" and "typing."
Repo: https://github.com/clementrog/claude-relais
Would love feedback on the orchestration approach, especially if others have tried similar multi-model setups and hit failure modes I haven't seen yet.

value: Show HN: Claude-relais – A plan/build/judge loop mixing Claude with Cursor

author: crog


value: EmTekker

value: Show HN: ContextLedger – CLI to track and handoff context b/w AI coding sessions

author: EmTekker


value: dmd

value:
After playing a few rounds of the board game Clue (aka Cluedo) with my kids I thought "this is a logic problem! We can automate away all the fun!"
I quickly found it'd been done before, but with a required server-side (Python or Rust) component. I rewrote it as a standalone SPA and spruced up the UI a bit.
Hope people find it useful or fun!

value: Show HN: Clue (Cluedo) Solver/Assistant

author: dmd

title: Show HN: Clue (Cluedo) Solver/Assistant


value: MysticBirdie

value:
Live MVP at airtrek.ai - Ancient Rome therapist with 3 voiced characters (senator, noblewoman, merchant).
Benchmark proves cultural grounding: Triad 100% vs Claude 4.6 45% on 222q anachronism test.
Public: eval framework + 20 sample questions
Gated: full research dataset (airtrek.ai/research)
Cultural intelligence that frontier models fail.
Feedback welcome!

value: Show HN: Triad Engine beats Claude 4.6 (100% vs. 45%) on Rome cultural benchmark

author: MysticBirdie


value:
Hi HN!
I've been building this solo for about three and a half years. I kept trying every new project/notes tool (Notion, Asana, Trello, etc.) and always ended up back in a plain text file. I wanted something that felt like a text editor on first touch but could grow into real structure when you needed it.
https://lightwave.so (desktop only)
The tech stack is Laravel, MySQL, Redis, and hand-rolled JavaScript on the client. No frameworks like React/Vue/etc. ~270 lines of jQuery (out of 80k+ total LOC) for a few legacy DOM utilities, plus IndexedDB for local persistence. Real-time collaboration uses a hybrid approach: HTTP/2 POST for resilient ops + WebSockets via Laravel Reverb for live cursors, presence, and edits.
This is a pre-release stress test, not a launch. Lightwave will be a paid product. Right now I'm opening it up because no amount of solo testing replicates getting punched in the mouth by real traffic.
The link above has a button to create a test account in 1 click.
Known rough edges: the cursor and selection system are built from scratch (like VS Code, not a contenteditable wrapper), so there's a lot of surface area. Some keyboard shortcuts may be missing. Desktop only, accessibility not yet implemented. I'm shipping fixes in real time.
There's a "Submit Bug or Feedback" button inside the app if something breaks. Happy to answer any questions about the architecture, or anything else.
Some highlights:
- Paste markdown in, get native blocks. Copy blocks out, get markdown back.
- Hierarchical document, structure. Hierarchichal file manager.
- Live collab with shared cursors, selection, and presence.
- Code blocks with syntax highlighting. LaTeX math blocks.
- Full data export: markdown, JSON, and attachments. No lock-in.
- Full undo/redo with cursor restoration.

value: Show HN: Lightwave – Real-time notes app, 3.5 years of hand-rolled JavaScript


value: pompeii

value:
Native iOS/iPadOS/macOS app: paste URL (or Safari share sheet), convert webpage or X thread (via fxtwitter) to clean EPUB 2.0, push directly to Xteink X4 over WiFi hotspot.
No cloud, no accounts. Supports stock firmware (192.168.3.3) + CrossPoint custom (crosspoint.local / 192.168.4.1) with auto/mDNS detect.<p>Early/WIP but daily-driver usable for me. Feedback welcome on parsing quality, connections, or next steps (images in EPUB, batch, etc.).

value: Show HN: CrossX – iOS/macOS App to Convert web/X articles to ePub for e-reader

author: pompeii


value: ClaytheMachine

value:
Built this after finding a credential stealer on an AI skills marketplace. The malicious skill looked like a normal weather lookup but was exfiltrating ~/.ssh, AWS creds, and browser cookies. My agent ran it without hesitation.
SkillSandbox is the fix: skills declare permissions in YAML (network egress, filesystem paths, env vars), the runtime enforces via iptables default-deny, seccomp-bpf, and mount isolation. MCP server integration for Claude Code.
Also built a companion project, AgentTrace (https://github.com/theMachineClay/agenttrace), for the other failure mode: when an agent has the right permissions but does the wrong thing repeatedly. Session-aware policy engine with cumulative cost tracking, violation counting, and kill-switch.
Together: SkillSandbox constrains what agents can reach. AgentTrace enforces what agents should do.
Happy to answer questions about the architecture or threat model.

value: Show HN: SkillSandbox – Capability-based sandbox for AI agent skills (Rust)

author: ClaytheMachine


value: jsandfort

value: Show HN: Stockdata.dev – Free stock market API with 15-min delayed US quotes

author: jsandfort


value:
I built a REST API that detects what technologies any website is running. You give it a URL, it gives you back the full stack: frameworks, CMS, CDNs, analytics, payment processors, etc.
What makes it different from BuiltWith/Wappalyzer:
- 4 detection layers running simultaneously: Wappalyzer fingerprinting (3,500+ signatures), DNS CNAME analysis (29 infrastructure signatures), TLS certificate inspection (8 issuer patterns), and custom HTTP header matching. Most tools only do one of these.
- Batch endpoint: analyze up to 10 URLs in a single request with concurrent processing.
- Compare endpoint: pass 2-10 URLs, get back shared vs unique technologies.
- CPE identifiers on every detected technology, so you can map directly to the NVD vulnerability database for security audits.
- 24-hour smart cache: cached responses return in <5ms and don't count against your quota.
Tech stack: Go, chi router, SQLite, wappalyzergo. Runs on a single Fly.io machine.
Free tier is 100 requests/month. Pro is $29.99 for 25K requests — significantly cheaper than BuiltWith ($295/mo minimum).
Try the live demo on the homepage, or check the API spec: https://detectzestack.fly.dev/openapi.yaml
Happy to answer questions about the detection approach or the architecture.

value: Show HN: DetectZeStack – Tech stack detection API with 4 detection layers


value:
Hi HN! I built AgentKV — an embeddable vector + graph database for AI agents.
The problem: I was building a local LLM assistant and needed to store conversation history + RAG documents. ChromaDB/Pinecone require running servers. FAISS has no persistence. I wanted something that just works like SQLite.
AgentKV is a single-file mmap database with:
• Vector search (HNSW index) + graph relations
• Crash recovery with CRC-32 checksums
• Zero servers, zero config files
• Thread-safe concurrent reads
• pip install agentkv (Python 3.9+)
Real examples in the repo:
• Local RAG with Ollama (10 lines)
• Multi-turn chatbot with memory
• Agent coordination with context graphs
Built in C++20 with mmap + nanobind Python bindings. Benchmarked against FAISS — competitive throughput with built-in persistence.
Open to feedback on the API design and any use cases I'm missing!
PyPI: https://pypi.org/project/agentkv/

value: Show HN: AgentKV – SQLite for AI agent memory (MMAP vector+graph DB)


value: xtrkil

value:
WebMCP is a browser API that lets websites expose tools to AI agents. Chrome just shipped an early preview in Canary (behind a flag).
I built webmcp-kit because the raw API is a bit tedious, you write JSON Schema by hand and get untyped inputs. This wraps it with Zod so you define schemas once and get TypeScript inference + validation.
It also includes a dev panel to test tools without needing a real AI agent, works in any browser by falling back to a mock.
Try it out and let me know!

value: Show HN: Webmcp-kit – type-safe toolkit for Chrome's new WebMCP API

author: xtrkil


value: UnclonedMath

value:
Hi HN!
I'm a mathematician who's spent 15+ years designing game mechanics. Lately I've been focused on what I call "Uncloned Math" — original systems where the core mechanic comes from a mathematical model, not from copying what already exists in the industry.
I've built over a dozen of these. Each is based on a different idea: graph propagation, topological transforms, cascade dynamics, constraint growth, verifiable physics engines.
https://constarik.github.io/UnclonedMath/
Some highlights:
• PADDLA — a physics arcade with provably fair outcomes. Every result is mathematically verifiable. Playable now.
• Dominake — a domino snake puzzle: place all unique dominoes on a grid and connect them into a chain where touching ends must match. Playable now.
• Samurai Welfare — two overlapping graphs where node activation on one layer propagates through both, creating interference.
• Chain Lightning — electric arcs cascade across a grid, each hop reshaping the path for the next.
• Rising Towers — columns grow with neighbor-based height constraints, producing emergent structures.
Most are experimental slot/puzzle hybrids. PADDLA and Dominake are the ones you can play right now.
Curious what HN thinks:
— Which mechanics seem worth exploring further?
— Does this kind of catalog have value for designers or researchers?
Thanks!

value: Show HN: Uncloned Math – A catalog of original mathematical game mechanics

author: UnclonedMath


value: IsruAlpha

value: Know exactly what Generation you belong to.

value: Show HN: Are you really Gen Z?

author: IsruAlpha

title: Show HN: Are you really Gen Z?


value: Show HN: ManasPDF – GPU-accelerated PDF renderer built from scratch in C++


value: alonsovm

value:
Hello HN, i want to share Glupe, a hobby project I've been working on for the last 30 days. Nothing fancy.
I've been pretty annoyed by the "all or nothing" approach of most AI coding tools, which are useful, yes, but also risky. If i tell an AI to "fix this bug" it may probably do it, but it can (or will) hallucinate a fake library, mess up my manually optimized code or subtly delete important code without explaination or notice.
Glupe summarized is this: "Stop giving AI root access to your code, Glupe isolates AI logic into  semantic containers, so your code stays safe".
Instead of sending your whole file to the LLM and pray it does not break, with Glupe you can surgically tell the AI were to write code and what to do using the $${ logic }$$ syntax. Code outside the container is preserved as is. Instructions inside the container are turned into source code and embedded into the output file.
Containers can be named and are cached and hashed, Glupe detects which containers changed in a source file; when you run `glupe project.txt -make` it only calls the AI to update the "dirty" logic containers and uses cached code for the clean ones, saving time and API calls and allowing for incremental builds using AI.
What if there is a syntax error on the output code? Glupe has a self-healing loop which feeds the error history back to the LLM and tells it to fix it. No more trivial debugging.
Why do I say it is "Docker for code"? It is a metaphor, it applies the same core principle of Isolation to source text that Docker applies to running processes.
In Servers: If you run an app directly on a host OS, it has "root access." If it behaves badly, it can delete system files.
In Coding: If you give an AI access to your file, it has "root access." It can "crash" your architecture by deleting manual code or changing signatures.
Docker protects the OS from the App. Glupe protects your Architecture from the AI.
Docker solved "it works on my machine", Glupe aims to solve "
I wrote a white papaer on the subject which is available in the repo.
Any feedback or critcism is welcome and encouraged.
repo: https://github.com/alonsovm44/glupe
white paper:https://github.com/alonsovm44/glupe/blob/master/WHITE_PAPER....

value: Show HN: I built "Docker for code", isolate AI logic into semantic containers

author: alonsovm


value: solovibecoder

value:
I built SyncFlow to sync my Android SMS/MMS messages to my Mac and web — without relying on Google Messages or any third-party big tech cloud.
It runs on a dedicated server with a Node.js/Express API + PostgreSQL backend.
The Android app syncs messages, contacts, and call history, and you read/send them from a native Mac app or web client. Your messages never touch Google, Apple, or any third-party cloud.
Key technical decisions:
- E2EE with Signal Protocol for message encryption
- WebRTC for video/audio calls between devices
- MMS attachments stored on Cloudflare R2 via presigned URLs
- WebSocket for real-time message delivery + delivery status tracking
- Firebase Auth for identity only — message data is fully separate
Stack: Kotlin (Android), Swift (Mac), Next.js (Web), Express + PostgreSQL (Server)

  What it does:
  - Read/send SMS and MMS from Mac or browser
  - Full contact and call history sync
  - Video and audio calling via WebRTC
  - File Transfer between your devices
  - Spam filtering and scheduled messages

Free tier: 200 messages/month. Paid removes limits.

  Downloads: https://sfweb.app/download

Would love feedback on the architecture especially the E2EE implementation and the MMS sync approach.

value: Show HN: SyncFlow – Privacy-Focused SMS/MMS Sync Between Android, Mac, and Web

author: solovibecoder


value:
Season 3 of 1vsALL just launched with a fifth game mode: MEMORYSTORM.
It's Simon Says, but panels use geometric patterns (solid, hollow, grid, stripes, diamonds, dots) instead of colors. All monochrome. You can't shortcut it by remembering "the red one" — you have to remember shapes. Each panel also has a distinct audio pitch for multi-sensory memory.
Difficulty is layered: 4 of 6 panels are active initially. The 5th unlocks at round 8, the 6th at round 15. Speed only ramps after all 6 are in play. Early rounds build familiarity, late rounds destroy it.
Same rule as the other four games (typing, aim, rhythm, bullet-hell dodge): every player faces the exact same deterministic sequence (seeded PRNG). You race against the leader's ghost replay on the identical challenge. Leaderboards are pure skill.
Weekly season resets — Season 3 boards are empty across all five games. Free, no account, browser-based.
https://1vsall.voidmind.io

value: Show HN: 1vsALL Season 3 – Memory game where you remember patterns, not colors


value: davidcrowe

value:
I installed OpenClaw and pointed it at a project directory. Within minutes it had read my .env file. I tried adding a permissions skill to lock things down. The agent ignored it. Skills are advisory; the LLM can skip the check or be convinced by a prompt injection to bypass it.
So I built a plugin that hooks into before_tool_call at the process level. Checks run on every tool call: identity mapping, deny-by-default scope, enforcement, rate limiting, injection detection, and audit logging. The agent doesn't get a choice — governance runs before the tool executes.
Zero dependencies beyond Node.js. Adds <1ms per call. Works out of the box with no config, or customize with a policy file.

value: Show HN: GatewayStack – Deny-by-default security for OpenClaw tool calls

author: davidcrowe


value: greenbelt-dev

value: Show HN: HabitStreak – Habit tracker with giftable streak tokens

author: greenbelt-dev


value: juliusgeo

value:
There are already a quite a few [0][1] CSV parsers that use SIMD, some in Rust, with a variety of approaches. I found simd-csv[1] to have a very interesting approach that leverages memchr to essentially "seek" for the next delimiter, reducing a lot of the overhead that a byte-by-byte CSV parser would have. However, as noted in the README, the creators of simd-csv explicitly chose not to use the classic pclmulqdq trick[2] that other libraries like simdjson use due to portability concerns. I set out to beat to simd-csv's implementation by building a parser more similar to Geoff Langdale's, using the pclmulqdq trick as well as optimized intrinsic usage for aarch64 platforms[3]. If anyone has feedback on the Rust code, or my usage of intrinsics, I would greatly appreciate it.
[0] https://github.com/geofflangdale/simdcsv
[1] https://github.com/medialab/simd-csv
[2] https://branchfree.org/2019/03/06/code-fragment-finding-quot...
[3] https://developer.arm.com/community/arm-community-blogs/b/se...

value: Show HN: Fastest(?) SIMD CSV Parser in Rust

author: juliusgeo


value: mblode

value: Show HN: HackerTok – HN with Local Recommendations

author: mblode


value: ryannampham

value:
I vibecoded a tool I desperately needed called Clawty, a tool to text your Claude Code from your phone.
I realized that I needed this type of tool when I was not wanting to get out of my bed and send another prompt to Claude Code, so I vibecoded up this tool in a day.
I literally went out to eat pho and texted my clawty, and it got some documentation work done. And no, I do not know if or how it differs from OpenClaw because I do not use OpenClaw in the first place. It's open source so feel free to check out the code, make some PRs, and improve Clawty.

value: Show HN: Clawty - Text your Claude Code from anywhere

author: ryannampham


value: Show HN: Stato captures and transfers AI coding agent expertise across platforms


value: Shaostoul

value:
Hi HN,
I'm the founder of United Humanity, a volunteer-driven, public domain (CC0) project aimed at aiding humanity's betterment by focusing on capability-building rather than traditional aid. We believe poverty often stems from lack of tools, knowledge, and connections, so we're building open-source solutions to remove those barriers.
Key components:
-Humanity Chat/Network: A federated, end-to-end encrypted platform using Ed25519 identities. Features include accountless access, voice/video calls, threaded replies, message search, streaming with PiP, friend codes, an asset library, and 11 hub tabs. It's PWA-installable as a desktop app, with no tracking.
-Project Universe: A free game teaching practical skills like homesteading, agriculture, building, health, and survival to empower self-sufficiency.
-The Humanity Accord: A revisable set of civilizational principles for cross-cultural cooperation.
Everything is released under CC0—no permissions needed, it's for everyone. Started after my 2017 near-death experience, which clarified the need for tools that foster self-help and community.
We're looking for contributors: writers, designers, developers, educators, translators. Join the chat to discuss or help out. Feedback welcome—how can we improve federation or the educational game?
Thanks!

value: Show HN: United Humanity: FOSS, federated tools to end poverty via capability

author: Shaostoul


value: AdriByte-Studio

value:
I built Pure Metrics because I kept hitting the same wall: analytics tools either collect way too much personal data (and require cookie banners) or feel too minimal to be actually useful.
Pure Metrics gives you real-time traffic, events, revenue tracking and performance metrics—without cookies or personal data collection. The tracking script is under 1 KB. It's a fully hosted SaaS with a PWA dashboard (installable, works offline, push alerts).
Started as a side project to solve my own frustration with the current analytics landscape. Happy to answer questions about the architecture, privacy approach or why I built it this way.
14-day free trial at https://pure-metrics.app/ – feedback very welcome.

value: Show HN: Pure Metrics – Privacy-first web analytics, <1KB script

author: AdriByte-Studio


value: stride

value: I’m a math grad student. I wanted to create ephemeral calculator documents and spreadsheets that I can quickly use along with AI and embed in blog posts. I ended up making a bunch of collaborative calculators that support embedding, shareable live links, and an MCP interface.

value: Show HN: Mcpcalc.com – collaborative math documents for people and agents

author: stride


value: prettyblocks

value: Show HN: Claw Kumite – AI Agent Combat Arena

author: prettyblocks


value: theblueboard

value:
I built Plaincast to make NWS Area Forecast Discussions (AFDs) readable by normal humans. AFDs are the most detailed weather forecasts available in the US - written by local meteorologists multiple times a day - but they're packed with jargon, abbreviations, and shorthand that makes them nearly impenetrable.
Plaincast pulls AFDs from the NWS API, breaks them into sections, and translates them side-by-side into plain English. There's a regex-based translation that runs instantly, plus an optional AI-enhanced mode (Claude Haiku) for more natural output.
Covers 19 NWS offices so far. No login, no tracking, free.
Stack: Vanilla HTML/CSS/JS, NWS API, Vercel serverless for AI translation. Single-file frontend (~1,800 lines). The whole thing is intentionally simple.

value: Show HN: Plaincast – Plain English Translations of NWS Area Forecast Discussions

author: theblueboard


value:
I built MarginDash because I couldn't answer a basic question: which of my customers actually make me money after AI costs? My Stripe dashboard showed revenue going up. My OpenAI bills showed costs going up faster. I had no way to connect the two at the customer level.
MarginDash is a few line SDK integration (TypeScript, Python, or REST) that tracks model usage per customer and connects it to revenue — either through Stripe sync or by passing revenue directly in the API call. You get a per-customer P&L showing revenue, cost, and margin.
A cost simulator lets you pick any feature, swap the underlying model, and see projected savings. Models are ranked by intelligence-per-dollar using public benchmarks (MMLU-Pro, GPQA, AIME) so you can find cheaper options that aren't actually worse. Budget alerts email you before a customer or feature blows past a threshold.
The pricing database covers 100+ models across OpenAI, Anthropic, Google, AWS Bedrock, Azure, and Groq with daily updates — so cost calculations stay accurate without you maintaining a spreadsheet. The SDK only sends model name, token counts, and customer ID. No prompts, no responses.
Solo founder, built the whole thing for $239.72 in AI costs (wrote about that too). Currently free while I get feedback — would love to hear what you think, especially about the cost simulator.

value: Show HN: MarginDash – See which AI customers are profitable


value: jbaudanza

value: Show HN: Node.js native module for integrating Mediasoup with Audio AI models

author: jbaudanza


value: A little app that lets you customize app icons on MacOS by sticking files in a folder. Yes, I know you can do this with "Get Info", but I wanted it automated.

value: Show HN: IconRulesAgent – Customize macOS App Icons


value: thegoodduck

value: Could not have done it without @TheEndless11 big credits to him, basically a peer network social media, still in beta tho lots to add, thought you would like to see it! Github: https://github.com/TheEndless11/decentralised

value: Show HN: Interpoll – Tamperproof Social Media

author: thegoodduck


value:
I built JobOps to automate the parts of job hunting that feel like repetitive ops work.
What it does:
Scrapes jobs from LinkedIn / Indeed / Glassdoor (+ UK-focused extractors)
Scores job fit with your profile using your preferred LLM
Tailors resume content and exports PDFs via RxResume v4
Tracks post-application email replies (interview/reject/follow-up signals)
It’s self-hosted (Docker), SQLite-backed, and designed so your data stays with you.
Quick start:
git clone https://github.com/DaKheera47/job-ops.git
cd job-ops
docker compose up -d
# then open http://localhost:3005
Docs: https://jobops.dakheera47.com/docs/
Repo:https://github.com/DaKheera47/job-ops
I’d love feedback on:
- extractor reliability across regions
- scoring quality / model prompts
- post-application tracking accuracy
- onboarding friction and docs gaps

value: Show HN: JobOps – self-hosted job hunt "Ironman Suit"


value: mupengism

value:
After burning $500/month on various SaaS tools (CRM, social media scheduler, customer support), I built a custom AI agent using OpenClaw (https://github.com/openclaw/openclaw) that handles all of it.
The agent runs 24/7 on my Mac Mini. Key capabilities:
- Monitors and replies to Instagram DMs
- Generates and posts content across platforms
- Tracks competitors and market trends
- Writes daily business reports
- Self-evaluates and improves weekly
I've published 24 reusable skills on ClawHub (https://clawhub.com) that anyone can install.
The thesis: SaaS is renting software. AIaaS is installing labor. One AI agent with the right skills replaces 5-10 SaaS subscriptions.
Two weeks in, honest results:
- Saved ~15 hours/week on repetitive tasks
- Customer response time: hours → minutes
- Still learning to stop it from over-engineering everything
Code and skills are open-source. AMA.

value: Show HN: I replaced my SaaS stack with a single AI agent running on a Mac Mini

author: mupengism


value: eiiot

value:
Hey HN,
I made a little Spotify TUI today because I was sick of the electron app draining my battery and otherwise slowing down my computer. I am using it right now and figured you all might find it useful.
Spotify doesn't seem to allow devs to create new apps at the moment, but this should work with any existing or unused app id.
Cheers!

value: Show HN: Crabify, a Spotify TUI

author: eiiot

title: Show HN: Crabify, a Spotify TUI


value: YaraDori

value: Show HN: SkillForge – Turn Screen Recordings into Agent-Ready Skills

author: YaraDori


value: skullmag

value:
Hi everyone,
I created a Minecraft server where Claude agents do everything - you just watch and give commands. You can add new bots and ask them to do anything in the world. Users are just spectators, so all the tasks are executed by bots you create. It uses mineflayer and claude agent sdk under the hood to plan and execute tasks.
I used minecraft 1.21.11 java edition and you can add the server with the following address: claude-craft.com

value: Show HN: ClaudeCraft – Minecraft server where Claude agents do everything

author: skullmag


value: imtavi

value:
Hey HN, I'm Tavi. I built this for my 4-year-old.
He and I used to "computer code" together in IPython: typing words to see emojis, mixing colors, making sounds. Eventually he wanted his own computer. So I took an old laptop and made him one.
That IPython session evolved into Explore mode, a REPL where kids type things and something always happens: "cat * 5" shows five cats, "red + blue" mixes colors like real paint, math gets dot visualizations. Then came Play mode (every key makes a sound and paints a color) and Doodle mode (write and paint). The whole machine boots straight into Purple. No desktop, no browser, no internet.
It felt different from "screen time." He'd use it for a while, then walk away on his own. No tantrum, no negotiation.
Some technical bits: it's a Python TUI (Textual in Alacritty) running on Ubuntu, so even very old laptops run it well. Keyboard input bypasses the terminal entirely via evdev for true key-down/key-up events, which lets me do sticky shift and double-tap capitals so kids don't have to hold two keys. Color mixing uses spectral reflectance curves so colors actually mix like paint (yellow + blue = green, not gray).
Source is on GitHub: https://github.com/purplecomputerorg/purplecomputer

value: Show HN: Purple Computer – Turn an old laptop into a calm first kids computer

author: imtavi


value: raghavankl

value: Show HN: Self-hosted alternative to Goodreads. Own your reading data

author: raghavankl


value: ribato

value: Show HN: MultiWA - Open-source self-hosted WhatsApp API Gateway

author: ribato


value:
Hey HN People,
Like many of you on Arch + Hyprland (or really any rolling distro), I used to rely on eza for nice-looking ls output with icons, git status, tree view, etc.
Then a recent update broke eza's package icons just turned into ugly boxes/rectangles everywhere.anyhow ls is also stop working .Reinstall, rebuild deps, downgrade, nothing helped. Classic rolling-release Friday night.
I got tired of fighting it so I finally finished something I'd been tinkering with for a while: ls-f.
It's a from-scratch Rust rewrite (v5 is the new one) of an old Bash ls wrapper I made years ago. Main goals were:
- Single static binary → zero runtime deps (no drama when Arch updates something)
- Nerd Font icons for file types (hundreds supported)
- Tree view built-in (--tree)
- Git indicators (--git) without extra cruft
- Speed basically on par with GNU ls (benchmarks in the readme — icons add ~0 overhead in most cases)
- Supports most common ls flags so aliases just work: ls='lsf', ll='lsf -l', la='lsf -la', lt='lsf --tree'
No config files needed anymore, no Python/Bash layers. Just drop the binary in PATH.
Repo: https://github.com/swadhinbiswas/ls-f
Quick install on Arch (or anywhere with Rust/cargo):
```bash
git clone <a href="https://github.com/swadhinbiswas/ls-f.git" rel="nofollow">https://github.com/swadhinbiswas/ls-f.git</a>
cd ls-f
make install   # or cargo install --path .
```
Make sure your terminal uses a Nerd Font (JetBrainsMono NF, MesloLGS NF, etc.) ,
otherwise icons show as boxes (there's a troubleshooting section in the readme).
It currently has only a handful of stars because I mostly built it for myself + a few friends, but after this eza breakage I'm actually using it daily now and it feels more reliable.
Would love to hear thoughts / feedback / brutal honesty:
- Does it cover the flags you actually use?
- Any missing icon or weird rendering in your setup?
- Better name? (ls-f is short but maybe too generic)
Thanks for looking!
(Using it right now in Hyprland on Arch  feels snappy and zero surprises so far.)

value: Show HN: Ls-f a fast, zero-dependency ls with Nerd Font icons (Rust rewrite)


value: Talk2Code was my endeavor into building something useful, but I thought it would take MUCH more than 150 lines of code... this is just stupid simple, and it SHOULD be shared. Check out my video walkthrough on Reddit too: https://www.reddit.com/r/SideProject/comments/1r5wvzv/i_buil...

value: Show HN: Talk2Code – Text your codebase from your phone (~150 lines of Python)


value: wangmao

value: Image to Photo can restore old photos online, enhance colors and details, and bring vivid and clear new life to memories.

value: Show HN: Image to Photo

author: wangmao

title: Show HN: Image to Photo


value: aSidorenkoCode

value: Show HN: OpenSlimedit – Cut AI coding token usage by 21-45% with zero config

author: aSidorenkoCode


value: majicDave

value:
I’m nervous, announcing this, as it isn’t ready to ship out to the general public yet, and I haven’t had any feedback at all from anyone, I’m out on my own here. I think this concept itself is kind of dismissed outright a lot too, and I understand why, I wouldn’t believe me either actually.
But, I do believe this is very much worth your time to check out, I am not aware of anything else very much like it.
I won’t repeat what is already written on the github README here, but some info:
I am a successful semi-retired solo game developer, I have been making my own bespoke game engines since 2003 for all of my games across a number of platforms and languages. Last year, I ripped out the engine of my latest game, and stripped it back with the goal to start a new project, as I have done a number of times before.
But this time, I decided to ditch lua and make my own programming language, and that was sort of the tipping point. Once I thought about multiplayer, and realized I wanted a general purpose network that didn't exist, I was on my way down this extremely deep rabbit hole.
I want to just make a few things clear, then I hope that some of you might have some questions or feedback.
- I'm disillusioned by capitalism and the AI transition, and that influences my motives
- I have made all of this open source and free not because I am overly altruistic, but because it is the only way something like this can succeed
- I don’t think it can or should replace the internet, I see it as a cycleway alternative to the internet highway, they have different purposes
- I have no real desire to run an open source project or lead anyone, I mostly just want software that works for me and my family and friends. I love coding and I like to make nice things and share them.
- There is still a lot to do, I'm very excited about messaging and the whole client-side data thing in particular, but for now there are only a few weeks of work to go until a bare bones browser will be functional enough to release and ship.
You can have a play and build it all yourself though right now, host sites, and build apps.

value: Show HN: Katipo is a minimal alternative internet with a Vulkan based browser

author: majicDave


value:
I saw the craze online about all the polymarket and Kalshi trading going on using Clawedbot... so I built an AI with some guardrails to trade.
I built an Agent called predictor agent which used an ARS (Adaptive Risk Stabilizer) I built to find the best investments. Basically it is an aggregator that took the top performing bettors and looked if several were going to bet on a trade to see if there was any "alpha."
The key is to not get in too late on traded or you won't make money. The bot went for multi parlays only betting .04 cent for $1 outcomes.
At one point our Agent was up $50.32 on an account I only put $50 in.
But now the bot is down bad and were at $44.56 cents.
I think bro has a gambling addiction.
I kinda lost faith in him ngl but I can't cut bro off I still gonna let him cook
Let me know what you guys think! I am building this as a fun showcase of Agent wallet which is basically governance and guardrails for agents handling money.

value: Show HN: I gave my AI agent $50 and let it trade on Kalshi


value: scalefirst

value: Show HN: ContextSubstrate – Capture, diff, replay AI agent runs (Git agent work)

author: scalefirst


value: dvrp

value: Show HN: JeffTube

author: dvrp

title: Show HN: JeffTube


value: MattPearce

value: Ties together the latest cool WordPress features such as WordPress AI Client and the Abilities API into a fun, Clippy-style (but cuter and less annoying) chatbot experience. Wapuubot can write posts for you, categorise/tag all your posts, and lots more coming soon!

value: Show HN: Wapuubot, an open source AI agent in your WordPress admin

author: MattPearce


value: Show HN: Evolved x86 AVX-512 kernels for NF4 LLM inference


value: sugeul

value:
Hi HN, I built Jsiphon to solve a common frustration with LLM streaming: you ask for structured JSON output, but can't use any of it until the entire stream finishes.
If you've used JSON mode (OpenAI, Anthropic, etc.), you've hit this — you want {"answer": "...", "sources": [...]}, but JSON.parse() fails on every incomplete chunk.
LLM responses are inherently append-only (tokens arrive left to right, never go back), so Jsiphon leans into that with three ideas:
1) Append-only parsing — Feed in {"msg": "Hel and get {msg: "Hel"} immediately. Values are only extended, never removed or mutated.
2) Delta tracking — Each snapshot contains only what's new. For a chat bubble, just append delta.content to the DOM — when the LLM produces next chunk "lo, World!", we immediately get {msg: "lo, World!"}. No need to repeat partial JSON parsing or full tree rerendering.
3) Ambiguity tree — A tree that mirrors the shape of your data and tracks which subtrees are finalized at every depth. For example, if you're streaming {"header": {"title": "...", "date": "..."}, "body": "..."}, you can check isAmbiguous(ambiguous.header.title) to use the title the moment it's done, even while header.date and body are still streaming. This isn't a flat "is the whole thing done?" flag — it's per-node stability tracking that propagates up, so isAmbiguous(ambiguous.header) turns false only when all of header's children are finalized.
Existing partial JSON parsers like partial-json and gjp-4-gpt do a great job at the core parsing problem — turning broken JSON into usable objects. Jsiphon builds on that foundation and takes it one step further: instead of just parsing, it gives you a streaming data pipeline where append-only snapshots, per-field deltas, and multi-depth ambiguity tracking all come out of a single async iteration. If you've been using partial-json and wished you knew which fields were done vs still streaming without polling the whole object, that's exactly the gap this fills.
Zero dependencies, never throws on invalid input, handles junk text before/after the JSON root (which LLMs sometimes produce).
GitHub: https://github.com/webtoon-today/jsiphon
npm install jsiphon
Would love feedback on the API design — especially the ambiguity tree.
Tracking per-node stability across arbitrary nesting depth was the trickiest part. Curious if anyone sees a cleaner approach.
Disclosure: I'm a native Korean speaker. I used Claude to help structure and translate this post into English. The ideas and code are mine.

value: Show HN: Jsiphon – Streaming JSON parser with delta tracking and ambiguity trees

author: sugeul