value: paimpozhil

value:
Hi HN,
We manage monitoring for a bunch of client websites, mostly Magento and WordPress stores, and got frustrated juggling UptimeRobot, Google PageSpeed, SSL checkers, and custom Playwright scripts. Everything lived in different tabs with different logins. So we built one tool that does all of it.
HexaScan monitors uptime and response times, PageSpeed and Core Web Vitals via Google's API, SSL certificate expiry, and server metrics through a lightweight Python agent. It has dedicated Magento 2 monitoring (orders, version, security patches, database size, customers, disk) and WordPress monitoring (version, plugins, themes, security, cache, WooCommerce stats) built in, not bolted on as an afterthought.
The part we're most excited about is Critical Flow testing. You can write Playwright scripts that test actual user journeys like checkout, signup, and login, and run them on a schedule alongside everything else. Most monitoring stops at "is the site up" but doesn't tell you if your checkout is broken.
We also have a repo security scanner that checks public Git repos for hardcoded secrets, backdoors, injection vulnerabilities, and dependency issues via the OSV database.
There's a built-in escalation matrix with three levels that auto-escalates if issues aren't acknowledged, with public issue pages for each incident. Notifications go to Telegram and email, with more channels planned.
Other stuff: filesystem integrity monitoring with Git status integration, log monitoring, custom script execution with sandboxing, and a health scoring system that weights critical monitors higher so you get a real picture of site health at a glance.
Built with Fastify 5, TypeScript, Prisma, PostgreSQL, Redis, BullMQ on the backend. React 18, Vite, Tailwind on the frontend. Python agent for server-side metrics and Playwright flows.
Self-hostable, doesn't phone home. We also offer a managed version for teams who'd rather not deal with the infrastructure.
Would love feedback, especially on what you'd prioritize next.
GitHub: https://github.com/BlazeHexaScan/HexaScan
Website: https://www.hexascan.app (https://www.hexascan.app/)

value: Show HN: HexaScan:Open-Source Monitoring(PageSpeed,Critical Flows,SEO,Security)

author: paimpozhil


value: offByOme

value:
InsomniDev is a MacOS toolbar app that can save you time and money. It wakes up your machine on a set schedule, finds issues in a target GitHub repo that you've labeled as eligible, and attempts to solve them using agentic CLIs. Then it opens a PR. You wake up to draft solutions ready for review. It leverages the existing command line tools on your machine to do this, so it’s extremely lightweight. Everything runs right on your machine.
As of now it supports Claude Code and Gemini. Enable the automation, then watch pull requests appear in your repo. Use those as a head start for dev. The app executes in two phases:
1. Plan generation - The app looks for eligible issues in your repo (using configurable labels), and selects the oldest eligible one. If the issue does not have an InsomniDev-generates plan, it will first execute your agentic CLI's
to generate a thorough implementation plan. The app clones your repo to a temporary workspace and runs your agent in that context so it's able to create an effective plan. Once finished it'll write it to the issue.
2. Implementation - After it generates a plan, it will move on to implementation using that plan. It'll do all the work in a temporary workspace that gets cleaned up afterwards. It creates a branch and then submits a pull request. No pushes directly to main, ever. The PR's have full descriptions of the changes made.
I built it because I was running into two problems: I kept hitting Claude token limits, and I felt like there wasn't enough time after work to make legitimate progress on all the stuff I wanted to build. I've tried all the tips related to mitigating token usage, but on the Claude Pro plan it's practically impossible not to hit the limits if you're doing anything substantial. InsomniDev is the byproduct of me being stubborn and not wanting to upgrade to the Max plan. I'm able to build faster AND save tokens while I do it.
When I shared it the first time, there was one big problem. I was entirely focused on using it to game Claude’s rolling 5-hr token usage windows. The issue is, for most people nightly automation just means hitting the weekly limit faster. Fair point. I want this to be useful to people like me who want to save money. So I added support for Gemini CLI!
Gemini has a generous free tier, so you get to build overnight for free. There’s fallback behavior so you can decide which coding agent it should prefer to use. Once one hits a token limit, it'll fall back to using the next one in line. You can have it use Gemini by default, then Claude once that runs out. If you don't care about saving on Claude tokens, you can configure it to only use Claude.
The workflow I've been running for the past few weeks looks something like this. I make issues in my repo throughout the day, mark the ones that I want AI to take a stab at as eligible, then when I sit down to code the next day I basically get a big head start on what I was planning to do. I get more done, and I don’t run out of Claude tokens as often since Gemini does the heavy lifting for plan generation and the initial implementation pass. I prefer to use Claude Code as my active development tool, so preserving those tokens has been huge.
The app is completely free to try out if you're interested in playing around with it. Then it has a one-time buy it for life $19 payment after the week trial is over. I’d love to hear feedback if anyone tries it out! Or even if you don’t and just have thoughts you want to share.

value: Show HN: A macOS toolbar app that resolves issues in your GitHub repos

author: offByOme


value: Show HN: 3mins.news – AI daily news briefing in 17 languages, designed to end


value: gsekulski

value: A Tampermonkey userscript that disables in-browser anti-cheat mechanisms (BlurSpy, honest-responder).

value: Show HN: Blindspot – a userscript to block tab-switch detection

author: gsekulski


value:
Hey everyone,
I've spent my career working in standard SaaS companies, but I recently joined a simulation software company. Suddenly, I was thrown into the deep end of conduction, material characterisation, and CTE (Coefficient of Thermal Expansion) simulations. As part of that, I got introduced to the world of semiconductor geometries and layout tools. Coming from web dev, I found traditional CAD interfaces and the sheer amount of boilerplate code required to generate simple test structures (like via arrays, capacitors, or guard rings - I still find terminology amusing and need to do googling every time) pretty overwhelming. As a learning project to understand the domain better, I decided to build something that bridges my software background with my new hardware reality. I built GeoForge - a natural language CLI and Web UI that generates validated GDSII/OASIS files from plain English prompts.
How it works: You give it a prompt like: "Create a 5x5 via array with 1um pitch connecting metal1 to metal2." It uses an LLM (supports local Ollama for free, or Gemini/Claude/OpenAI) to extract a structured spec. It generates parametrised Python code using gdsfactory.
The cool part: It runs the code in a sandboxed environment. If there's a syntax or execution error, it catches it and feeds the error back to the LLM in a retry loop so it can self-correct before giving you the final .gds/.oas file.
Why I'm posting here: Because I'm still new to this industry, I know this is currently more of a "cool learning project" than a production-ready EDA tool. But I want to know if this actually has legs to be useful to you all. I'm looking for early feedback to figure out which direction to take it:
- What component families (RF, photonics, test structures) would be most useful to have deterministic templates for?
- Would adding basic Design Rule Checking (DRC) to the validation loop make this actually usable for you?
- How do you currently prototype these kinds of geometries?
The repo is here if you want to try it out (it has a Gradio Web UI too): https://github.com/rusrushal13/geoforge
I'd love any brutal, honest feedback or advice on where to take this next!

value: Show HN: Natural language semiconductor geometry generator powered by LLMs


value: Balvarez

value: I’ve created what I believe a modern comic can look like in 2026. What I’ve built would have required an entire team just a few years ago, but can now be produced by a single person. As a designer and videographer with over 20 years of experience, I know AI is a contentious subject—but for me, the scale of what an individual can now create is incredible.

value: Show HN: The Sanguine Box – A 2026 vision for solo-produced comics

author: Balvarez


value: ovelv

value:
In a world being rapidly rewritten by AI, new tools appear every day, yet real clarity becomes harder to find. The challenge isn’t how many AI tools exist, but *which ones are worth using right now*—the ones that reduce friction, cut experimentation time, and meaningfully amplify your capabilities.
*LaunchSoar* was built exactly for that purpose.
It’s a *lightweight but carefully curated AI directory*—not a bloated encyclopedia, not an ad-stuffed traffic farm. Think of it as a precise ignition sequence: the most useful, most effective AI tools surfaced cleanly so you can focus on building, creating, and moving faster.
Every tool featured has been handpicked and tested—whether it’s for writing, design, coding, marketing, or building your next product prototype. No endless tab-hunting, no overwhelming lists. Just a clear, organized “technology star chart” that helps you navigate toward your next insight, project, or breakthrough.
LaunchSoar is designed for:
- Makers who want to work smarter
- Indie developers validating ideas
- Founders looking to scale with AI
- Anyone trying to stay oriented in the accelerating tech landscape
Our hope is that LaunchSoar becomes your *pre-launch ignition point*—a clean, reliable starting pad for your next jump in productivity and creativity.

value: Show HN: Launch-AI directory for creators, indie developers, and founders

author: ovelv


value: CalvinBuild

value:
Repo: https://github.com/CalvinSturm/LocalAgent
What it does:
- Runs against local providers (LM Studio / llama.cpp server / Ollama)
- Tool calling with explicit hard gates (--allow-shell, --allow-write, write tools opt-in)
- Trust layer: policy rules, approval workflows, audit trail
- Replayable run artifacts + verification
- MCP stdio tool support (including Playwright MCP)
- Eval harness for deterministic coding/browser task packs
Why I built it:
I originally tried wrapping trust controls around existing agent CLIs, but tool execution is too native in those products to reliably enforce policy externally. So I built a runtime where tool calling + trust controls are first-class.
Defaults stay safe:
- trust off
- shell/write disabled
- write tools hidden unless enabled
Quickstart:
cargo install --path .
localagent init
localagent doctor --provider lmstudio
localagent --provider lmstudio --model <model> chat --tui true
I’d appreciate feedback on:
1. trust/policy model ergonomics
2. eval design for local model benchmarking
3. TUI workflow for day-to-day coding use

value: Show HN: LocalAgent: local coding agent CLI with trust and replay

author: CalvinBuild


value: lusingander

value:
ddv is a viewer application for browsing AWS DynamoDB tables in your terminal.
From your terminal, you can browse table items, view their details, and perform searches.
Unfortunately, at present, it does not support update operations (create, delete, update) or complex queries for searching. I plan to develop these features in the future.
However, I've been finding it quite useful myself in certain use cases, such as checking operations and testing in development environments.
https://github.com/lusingander/ddv

value: Show HN: DDV – Terminal DynamoDB Viewer

author: lusingander

title: Show HN: DDV – Terminal DynamoDB Viewer


value: groask

value:
Most solo developers spend 90% of their time writing code and 10% on everything else. After a few years of building indie products — some failures, a couple that found traction — I've tried to document the framework I wish I'd had earlier.
The framework has four phases: clarify, build, grow, monetize. None of it is novel. The value is in applying it in order, because most failures happen when you skip the first phase and go straight to the second.
Clarify first. Before writing code: who exactly are you solving a problem for, and what problem are you solving? The answer needs to be specific enough to function as a filter for future decisions. "Productivity software for remote workers" is not an answer. "A tool that helps freelance developers track billable time without switching contexts" is closer.
Once you have that, validate the problem using a simple heuristic: Frequency × Intensity × Scale. A problem that's frequent, painful, and affects many people is real. A problem that scores high on only one dimension is usually not worth building around. Also: what users say they want and what they actually do are different. Design around behavior, not stated preferences.
Competitive research belongs here too. The 1-star reviews on app stores and complaint threads in relevant communities are a map of unmet needs. That's your opportunity space.
Build less, ship sooner. The right unit to build is the minimum thing that lets a real user accomplish the core task. Every feature beyond that is a liability until it's validated. The goal is to shorten the loop: build → ship → real user feedback → iterate. Most indie products fail because this loop is too slow, not because the underlying product is bad.
Grow through content and community. Paid acquisition before you've validated the model is expensive and usually misleading. Content that addresses real problems in your domain compounds over time. Community participation — being genuinely useful in places where your target users already are — builds trust that converts at higher rates than ads. The practical version: write about problems you've actually solved. Show up consistently. Don't make every post about your product.
Charge before you feel ready. Delayed monetization is usually a form of avoiding the most important feedback signal. If nobody pays, that tells you something essential — and you want to learn it as early as possible, not after six months of building. Think through the unit economics: LTV needs to exceed CAC, or you don't have a business yet. Retention matters more than acquisition. Track the metric that best reflects whether users are getting value, and let that drive decisions.
The short version: define who you're solving for, validate before building, ship in small increments, and charge for your product sooner than feels comfortable. The hard part isn't technical — it's the discipline to do the unsexy work before the fun work.
A note on the sequencing: most indie product failures I've seen — including my own — share the same pattern. The builder had a problem they wanted to solve, skipped the validation phase, built for months, shipped, and discovered either that nobody wanted it or that the people who wanted it wouldn't pay. The fix is not to become a business person instead of a developer. It's to do a small amount of structured thinking upfront and revisit it regularly as you learn. The code is the easy part.
One resource I'd point to: Rob Fitzpatrick's "The Mom Test" for the validation phase. The core idea — ask about problems, not solutions, and watch behavior rather than taking stated preferences at face value — has saved me significant amounts of time building things that turned out not to matter.

value: Show HN: A Product Commercialization Framework for Solo Developers

author: groask


value: pitwin

value:
Hi HN,
I built MailCat because my AI agents kept getting stuck at "please verify your email."
The key insight: if your AI agent can read documentation, it can set itself up.
Just paste this into Claude Code, OpenClaw, or any AI agent:

    "Read https://mailcat.ai/skill.md and set up a MailCat mailbox for yourself. Save the token securely."

That's it. Your agent reads the skill.md, creates a mailbox via API, and handles email verification autonomously from there.
What it does:
- Instant mailbox creation via API
- Verification codes auto-extracted from emails
- 1-hour retention (perfect for verification flows)
- Fully open source (MIT) and self-hostable
Built with Cloudflare Workers + D1 + KV. Self-host in ~10 minutes.
GitHub: https://github.com/apidog/mailcat
Happy to answer questions about the architecture.

value: Show HN: MailCat – Email service for AI agents (open-source)

author: pitwin


value: AmiteK

value:
I built an open source CLI that analyzes TypeScript codebases using the TypeScript AST (via ts-morph) and extracts structured architectural contracts and dependency graphs.
The goal is to create a diffable architectural map of a codebase and detect breaking interface changes during refactors.
It includes a watch mode for incremental rebuilds and a strict mode that flags removed props, functions, or contracts.
Fully local, deterministic output. No code modification.
I’d appreciate technical feedback from anyone working on large TypeScript codebases.
Repo: https://github.com/LogicStamp/logicstamp-context
Docs: https://logicstamp.dev/docs

value: Show HN: Catching breaking interface changes in TypeScript refactors (AST-based)

author: AmiteK


value: Show HN: Prodlint – Static analysis for the bugs AI coding tools write


value: skoinks

value: Full disclosure: I'm an engineer.<p>I think you'll find the framing to be intuitive, useful and scary. It allows for elegant explanations for normal and abnormal brain phenomena. Dreams, depression, flow states, hypnosis, deja vu, drugs and so on.

value: Show HN: A New Framework for Understanding Consciousness and Free Will

author: skoinks


value: bbokan

value: Show HN: Mogamp – Winamp for macOS

author: bbokan

title: Show HN: Mogamp – Winamp for macOS


value: joelazar

value: Show HN: Giving AI agents access to Kagi's search APIs

author: joelazar


value:
Hi HN,
Built DataChecker Pro to make CSV data cleaning faster. Uses AI to find issues, then shows you a diff to approve/reject each fix.
Most data cleaning tools require building rules upfront. I wanted something where you just upload a file and it tells you what's wrong. Then you decide what to fix.
*How it works:*
1. Upload CSV
2. AI analyzes for formatting errors, duplicates, invalid data
3. Shows you before/after for each issue
4. You approve or reject
5. Export clean file
*Tech:*
Rails 8, Turbo, OpenAI API, Stripe
Built this after watching sales teams spend hours cleaning CRM exports manually. The approve/reject workflow came from realizing AI makes mistakes - you need human oversight.
Try it (50 rows free, no signup): https://datacheckerpro.com
Early user offer: Email me at founder@datacheckerpro.com and I'll
give you free Pro access ($79/mo value) for 30 days. All I ask is
a 15-minute feedback call to tell me what works and what doesn't.
Limited to first 10 people.
Feedback welcome. Planning to add HubSpot integration next so it can scan CRMs automatically instead of requiring CSV exports.

value: Show HN: DataChecker Pro – AI finds issues in your CSV, you approve or reject


value: clanker-lover

value:
Eidolon Womb is infrastructure for a local LLM that thinks continuously in 27-minute cycles, accumulates fatigue, sleeps when exhausted, and consolidates memories during sleep. Not a chatbot—messages wait like voicemail until it wakes.
GPL v3. Early release, rough edges.

value: Show HN: I stopped treating my local model as a tool and built it a life cycle

author: clanker-lover


value: Generate personalized content based on the current environment (weather, time, date, solar terms) through backend LLMs (DeepSeek / Tongyi Qianwen / Kimi) and display it on a 4.2-inch e-ink screen.

value: Show HN: InkSight – An open-source, LLM-powered e-ink display for "slow info"


value: PeterHedgehog

value:
I built ipinsights.io — a free IP intelligence service that gives you geolocation, ISP data, blacklist status and a risk score for any public IP address.
The problem I kept hitting: most IP lookup tools are either paywalled after a handful of queries, return stale data, or both. I wanted something I could hit from a script at 2am without worrying about rate limits or reaching for a credit card.
How it works:
- Enter an IP and get back geolocation (country, region, city, coordinates, timezone), ISP/org data, and a threat assessment.
- The threat data is cross-referenced against 24+ blacklist sources, refreshed every 4 hours.
- Nearly 300k blacklisted IPs indexed currently, growing with every cycle.
- Free API — register for a key and integrate it into whatever you're building.
The stack is PHP on Apache/Ubuntu with MySQL and Redis. Nothing exotic.
It's free and will stay free. No freemium trap, no "enterprise tier coming soon". The more people using it and feeding back, the better the intelligence gets for everyone — it's a network effect thing.
I'd appreciate any feedback on the tool, the API, or the data quality. Happy to answer questions about the architecture or the threat sources.
https://www.ipinsights.io/

value: Show HN: Ipinsights.io – Free IP threat intelligence with API

author: PeterHedgehog


value: hardsnow

value:
I built Airut as an experiment - could email be a good fit for talking to a coding agent? Turns out that the answer is yes, at least for me personally - I immediately moved almost all of my development to happen exclusively over email.
Email is perfect fit for async long-form conversation, naturally threaded, and with excellent UX across platforms. Each email thread becomes a Claude Code session within automatically created sandboxed workspace. Working on multiple things in parallel requires no additional thought - they just exist as independent email threads in your inbox. Friction to start a new task is what I would consider zero - just send an email (without having to worry about a human judging your poor grammar even!)
I recently added slack support as well, inspired by Spotify’s “Honk”. Slack having native threading maps to Airut’s model reasonably well. Although I wish Slack had better UX for switching between threads.
Airut works best when the project is set up for agentic development and the agent has necessary access to push code for review. I’ve tried to make this possible securely; Airut for example has “masked secrets” feature where the container running Claude Code doesn’t hold the real authentication tokens, only look-alike surrogates which are swapped to real ones on the way out by a proxy.
Project is open-source (MIT) and should be straightforward to set up on a Linux machine or VM. I’d love to hear feedback about the conceptual model and the sandboxing implementation.

value: Show HN: Airut – Sandboxed Claude Code over Email and Slack

author: hardsnow


value: karanveer

value: Show HN: Quick 3D Typing "Game"

author: karanveer

title: Show HN: Quick 3D Typing "Game"


value: linuxlewis

value: Show HN: ClaudeUsage – macOS menu bar app to track your Claude Pro usage limits

author: linuxlewis


value: canopyhq

value: Show HN: Phloem–Local-first AI memory & causal graphs(MCP server, Zero network)

author: canopyhq


value: ragnaroekX

value: The goal is to have a pixel, mod-friendly perfect recreation of Wolfenstein 3D in Rust.

value: Show HN: Iron-Wolf – Wolfenstein 3D source port in Rust

author: ragnaroekX


value: kgthegreat

value: FeedbackOK lets you send anonymous, constructive feedback to colleagues using just their LinkedIn URL. It uses AI to ensure insights stay professional and helpful, and recipients sign in to claim and view feedback securely. Built-in safety guardrails help keep things respectful and actionable.<p>Check it out and let me know what you think!

value: Show HN: Give anonymous, constructive feedback to colleagues on LinkedIn

author: kgthegreat


value: altug

value:
Hi Hacker News,
I needed an MQTT client to repeatedly send some commands to devices I build, with Postman-like variable substitutions as I was testing different device IDs with similar commands. MQTT Explorer is nice, but I had to write the commands again and again, with different payloads, and I don't really use the visualization feature. I wanted to save the connection, have a client that opens instantly, parameterizes some common variables, and saves the commands I wrote, so here's MQTT Topic Lab.
MQTT Topic Lab allows you to save your most-used commands, send messages with repetition, and use variables to switch commands on the fly easily. It also has a message viewer so you can also see messages on the broker. After doing the hard work of building your commands, you can export it to share with colleagues so they can get started fast. Also supports keyboard shortcuts if you want to move around like that.
It's built with Tauri (Rust backend, React frontend), so it's cross-platform, and quite fast. Also binaries are quite small (6-7 MB). This is my daily driver so I am going to maintain and update it, and maybe add some features you might want to see in the app. It's coded with Claude, but it's not an "AI-slop" software. The code might be rough on some edges, but it's quite well on how it works.
Looking forward to hear your thoughts, you can check it out at https://github.com/alsoftbv/topic-lab and download built binaries for your device to test it out.

value: Show HN: MQTT Topic Lab – MQTT client with buttons using command variables

author: altug


value: fran-mora

value: Show HN: Port Collision Radar – menubar app that monitors your TCP ports

author: fran-mora


value: YurGrhm

value:
Hey HN,
I built Uaryn because I was tired of chasing clients for payment. As a freelancer, I spent more time writing "friendly reminder" emails than doing actual work.
Uaryn is a simple invoicing tool with one twist: adaptive reminders that learn from your clients' payment behavior. Instead of blasting generic "your invoice is overdue" emails, the system adjusts timing and frequency based on how each client historically pays. Some clients pay early — they get fewer nudges. Serial late-payers get reminded more aggressively before the due date.
What it does:
- Create professional invoices in under 2 minutes (3 fields minimum)
- Built-in Stripe payments — clients pay directly from the invoice
- Smart reminders that adapt over time (J0, J+15, J+28, J+30, J+37 schedule)
- Recurring invoices for retainer clients
- Analytics: average days-to-payment, on-time rate, revenue trends
- PDF export, custom branding
What it doesn't do:
- Accounting, tax reports, expense tracking. There are great tools for that already. Uaryn does one thing: get you paid faster.
Tech stack (for the curious):
- Next.js 14 + Prisma + PostgreSQL (Neon)
- Stripe Connect for direct payments to freelancer accounts
- LemonSqueezy for subscription billing
- Resend for transactional emails
- Vercel cron jobs for reminder scheduling and recurring invoice generation
- Deployed on Vercel
Pricing: Free tier (3 invoices/month), Pro at $9/month for unlimited invoices, recurring billing, analytics, and custom branding.
No credit card required to start.
Some technical decisions that might interest HN:
- Stripe Connect so payments go directly to the freelancer's account — zero platform transaction fees
- Timing-safe auth comparisons + dummy hash checks to prevent user enumeration
- Idempotency checks on cron jobs to prevent duplicate invoice generation
- Real-time status computation instead of storing derived state in the DB
I'd love feedback on the product and the adaptive reminder approach. Is the "learning" angle compelling enough, or would you want more transparency into how the system decides when to remind?
https://uaryn.com

value: Show HN: Uaryn – Smart invoicing that learns when your clients pay

author: YurGrhm


value: orbydx

value:
Hey HN, I’m Christoph.
I built AI Dev Hub because I hate switching between sites and was missing some light weight tools for building with ai.
Principles:
• no signup
• current tools run fully client-side
• fast utility over flashy UI
• built for real workflows
I’m curious about two things:
1. which tools are genuinely useful vs noise
2. what’s missing in your daily workflow that should exist
Would love brutally honest feedback, I’m actively shipping updates.

value: Show HN: AI Dev Hub. 100 free dev tools (all client-side, no signup, no ads)

author: orbydx


value: mhher

value: Show HN: Late – A subagent orchestrator TUI for local LLMs (Go/Linux)

author: mhher


value: dvictor

value:
Eliezer is ~7K lines of TypeScript, MIT open-source
- PWA for mobile/desktop with push notifications
- Self-editing protocol
- Builds and displays interactive apps/widgets right in the chat
- Task and Crons - "notify if sunny tomorrow at 10am")
- Persistent SQLite memory + auto context compaction
- Bring your own LLM API key (Kimi/Claude/Grok/etc.)
- Full visibility/control - You see all tool calls and can abort in all states
Agent repo: https://github.com/Eliezer-app/eliezer
Chat repo: https://github.com/Eliezer-app/clawchat
The chat was originally thought as a plugin for OpenClaw.
Ended up writing the agent too.

value: Show HN: Eliezer – Tiny (~7K LOC) Self-Hosted AI Agent (PWA, Self-Editing)

author: dvictor


value: akhilchaturvedi

value: Show HN: TinyPAN – Zero-allocation Bluetooth tethering for microcontrollers

author: akhilchaturvedi


value:
built a CLI-based image generation agent that takes vague prompts like:
“a warrior in a forest”
And automatically:
Expands it into a detailed cinematic description (lighting, mood, camera angle, art style)
Routes it to the appropriate model via OpenRouter
Downloads the generated image locally
Tech stack:
React Ink (CLI UI)
TypeScript
Modular subagent architecture
OpenRouter (free-tier models supported)
One thing I realized while building this:
You don’t actually need expensive API credits to experiment with AI agents.
There’s a surprisingly strong free stack available:
OpenRouter (multiple free-tier models)
Antigravity (Claude, GPT variants, Gemini access)
OpenCode (GLM-5, MiniMax)
Local models via LM Studio / Ollama / ComfyUI
The biggest barrier isn’t cost — it’s clarity of architecture.
Repo:
https://github.com/kiran7893/Image-generation-agent

value: Show HN: CLI Image Generation Agent Using (OpenRouter and Free Models)


value:
Hey HN,
I built Rigour, an open-source CLI that catches quality issues AI coding agents introduce. It runs as a quality gate in your workflow — after the agent writes code, before it ships.
v4 adds --deep analysis: AST extracts deterministic facts (line counts, nesting depth, method signatures), an LLM interprets what the patterns mean (god classes, SRP violations, DRY issues), then AST verifies the LLM didn't hallucinate.
I ran it on PicoClaw (open-source AI coding agent, ~50 Go files):
- 202 total findings
- 88 from deep analysis (SOLID violations, god functions, design smells)
- 88/88 AST-verified (zero hallucinations)
- Average confidence: 0.89
- 120 seconds for full codebase scan
Sample finding: pkg/agent/loop.go — 1,147 lines, 23 functions. Deep analysis identified 5 distinct responsibilities (agent init, execution, tool processing, message handling, state management) and suggested specific file decomposition.
Every finding includes actionable refactoring suggestions, not just "fix this."
The tool is local-first — your code never leaves your machine unless you explicitly opt in with your own API key (--deep -k flag).
Tech: Node.js CLI, AST parsing per language, structured LLM prompts with JSON schema enforcement, AST cross-verification of every LLM claim.
GitHub: https://github.com/rigour-labs/rigour
Would love feedback, especially from anyone dealing with AI-generated code quality in production.

value: Show HN: Rigour – Open-source quality gates for AI coding agents


value:
Show HN: NullClaw — a fully autonomous AI assistant that fits in ~1MB
https://github.com/nullclaw/nullclaw
I kept running into the same problem with AI agents: they work, but they’re heavy. Most frameworks assume Python or Node, pull in hundreds of MB of dependencies, and feel overkill if you just want an always-on assistant that starts instantly and runs anywhere.
So We built NullClaw.
NullClaw is a fully autonomous AI assistant infrastructure written in Zig. It compiles to a static binary (~678 KB), uses about ~1 MB of RAM at runtime, and starts in a couple of milliseconds. No Python, no Node, no containers required.
What surprised me most while building it wasn’t just the size, but how much functionality you can keep without the usual bloat:
Supports 20+ AI providers
Multiple channels (Telegram, Discord, Slack, etc.)
Tool execution with sandboxing
Hybrid memory (vector + full-text search)
Secure secrets handling and scoped workspaces
Pluggable architecture for providers, tools, memory, and tunnels
The idea is simple: an AI assistant should behave more like a system daemon than a web app.
NullClaw is designed to run comfortably on:
low-cost VPSes
edge devices / SBCs
local machines as an always-on agent
or as a lightweight backend for larger agent systems (it’s compatible with OpenClaw)
If you want a higher-level overview, examples, and use cases, I’ve put that together at https://nullclaw.co/
 — the GitHub repo stays focused on implementation details.
This project is also an experiment in whether compiled languages make more sense for agent infrastructure than interpreted stacks. Zig gave me predictable performance, strong safety guarantees, and binaries that are genuinely easy to ship.
I’m curious how others here think about:
agent runtimes vs frameworks
edge / local-first assistants
and whether we’ve collectively accepted too much infrastructure overhead as “normal”
Happy to answer questions or hear criticism.

value: Show HN: NullClaw – an autonomous AI assistant that fits in ~1MB


value:
One week ago, in the true spirit of Valentine's day, I decided to made a short film with AI.
In keeping with the Valentine's day theme, I'm calling it "The Perfect Fit".
At first glance it seems like a bunch of shapes moving around. Being completely honest, that's all it is. The interesting bit is - everyone you know (you included) - will naturally assume that it is a love story.
Was your brain playing tricks on you this whole time? Yes and no - the concept for this short film was inspired from a 1944 study by scientists Heider and Simmel. Participants of the study were shown a 90 second animation of shapes moving around.
When asked to describe what they saw - they told stories about how the shapes interacting described bullying, the fight of good over evil, how love conquers all, etc.
All of these complex, emotionally layered stories, just for a bunch of triangles and circles moving around.
The point was to show that - by nature, humans love giving human like qualities to everything around them. This is the same impulse that makes you see a face when looking at the front of the car.
I'm a sucker for all things human psychology - and this was too good of an idea to not steal.
Brass tacks wise - it was a good benchmark to see how far LLMs have come at solving and reasoning with math problems.
As the whole animation was written in Python by Claude and Gemini - for Blender - the models were in complete control over the timeline, keyframes, and visual effects. Consistently blown away by how fast these models are progressing.
There's a GitHub link for code if you're into that sort of thing (repo includes a blender plugin that hot reloads the blender project when the code changes) -
https://github.com/hotrod462/co-blend

value: Show HN: The Perfect Fit – A Valentine's day story


value: Falimonda

value: Show HN: The Department of Words

author: Falimonda

title: Show HN: The Department of Words


value: hrncode

value:
Tired of localhost:3000 clashing with other projects. Built portname —
a local proxy that gives every dev server a named URL instead of a port.
portname run dev → myapp.localhost:1999
Auto-detects Vite/Next/Nuxt, patches config automatically, proxies
WebSocket so HMR works. Single binary, no dependencies.
https://github.com/hirendhola/portname

value: Show HN: Portname – named localhost URLs for every dev server

author: hrncode


value: omrfc

value: I built a CLI tool that automates Coolify installation on Hetzner and DigitalOcean. Before: 30 minutes of manual work (create VPS, SSH in, install Docker, configure firewall, install Coolify). After: npx quicklify init — ~4 minutes, zero manual work. One flag (--full-setup) also auto-configures firewall + SSH hardening after deploy. 19 commands total: backup/restore, domain binding, monitoring, logs, and more. Would love feedback!

value: Show HN: Quicklify – Deploy Coolify to any VPS in 4 minutes with one command

author: omrfc


value: ambaskaryash

value: Show HN: SmartMan – A modern, interactive TUI for Linux man pages

author: ambaskaryash


value: horduntech

value:
Hi HN
I built ShellDock to make setting up and running development tools less painful across different environments.
ShellDock is a lightweight CLI that lets you define and execute curated command sets for installing or configuring tools — think of it like a portable launcher for repeatable dev environment setup.
Instead of copy-pasting long installation scripts or maintaining scattered setup docs across machines, ShellDock allows you to:
- Bundle related setup commands into reusable tool definitions
- Run them interactively or non-interactively
- Standardize installs across local machines, servers, or fresh VMs
- Keep environment setup reproducible for teams
A typical use case would be bootstrapping tools like Neovim, Docker, language runtimes, or infra dependencies on a new system in one step.
It’s especially useful when spinning up new dev boxes or provisioning ephemeral environments where consistency matters.
I’d love feedback on:
- CLI UX
- Command definition format
- Real-world use cases I might not have considered
- Anything that feels clunky or missing
Repo:
https://github.com/OpsGuild/ShellDock

value: Show HN: ShellDock – Run curated DevOps toolchains with a single command

author: horduntech


value: vadimmelnicuk

value:
I write a lot of markdown alongside code: READMEs, specs, changelogs. VS Code's built-in experience is either raw syntax or a read-only preview pane you have to keep open in a split. Neither is great for actually writing.
MEO adds a proper editing mode to VS Code. You get a live/source toggle in a single tab, a floating toolbar for formatting, inline table editing, full-screen Mermaid diagram rendering, a document outline sidebar, and optional auto-save. No new app to switch to, no split pane.
One thing most markdown extensions miss: it preserves VS Code's native diff view, so reviewing git changes in a markdown file still works exactly as expected.
Built on VS Code's webview API.
Happy to answer any questions about it.
VS Code marketplace: https://marketplace.visualstudio.com/items?itemName=vadimmel...
GitHub repo: https://github.com/vadimmelnicuk/meo

value: Show HN: MEO - a Markdown editor for VS Code with live/source toggle

author: vadimmelnicuk


value: adilmoujahid

value: Show HN: My AI research to Obsidian workflow

author: adilmoujahid


value: Bumblebiber

value:
My Claude told me to post this here :D
AI coding agents have two memory problems that CLAUDE.md and Rules files don't solve: (1) long conversations get compressed and context silently disappears — the agent forgets decisions made 2 hours ago in the same session, and (2) memory is locked to one tool on one machine. Switch from Claude Code to Cursor, or from your laptop to your desktop, and everything is gone.
I built hmem to fix both. It's an MCP server that gives AI agents persistent, hierarchical memory stored in a local SQLite file. The same .hmem file works across Claude Code, Cursor, Windsurf, OpenCode, and Gemini CLI — on any machine. Your agent's knowledge is portable.
The key idea is borrowed from how human memory works: you remember rough outlines first and recall details on demand. hmem has 5 depth levels. At session start, the agent loads only Level 1 summaries (~20 tokens). It drills deeper into specific memories only when needed — L2 for context, L3-L5 for raw details. Unlike a flat MEMORY.md that gets injected wholesale (3000-8000 tokens every time), hmem loads only what's relevant.
Install: `npx hmem-mcp init` (interactive setup — detects your installed tools and writes the MCP config).
This is beta software. I've been using it in production across two machines with 100+ memory entries and it's been stable, but the API surface may still change. Would appreciate feedback.
GitHub: https://github.com/Bumblebiber/hmem
npm: https://www.npmjs.com/package/hmem-mcp
License: MIT

value: Show HN: Hmem – Persistent hierarchical memory for AI coding agents (MCP)

author: Bumblebiber


value: justvugg

value:
I built Wiredigg, an open-source network traffic analysis and security tool written in Python. It combines real-time packet capture, protocol inspection, machine learning-based anomaly detection, and local LLM analysis via Ollama.
The goal is to provide interactive network visibility with AI-assisted threat interpretation, while remaining local-first and easy to run. A Windows executable build is also available.
Repo: https://github.com/JustVugg/Wiredigg
⸻
What it does
Real-time packet capture
 • Live traffic sniffing
 • Protocol analysis (TCP, UDP, ICMP, HTTP, etc.)
 • Filtering by IP, port, and protocol
 • Promiscuous mode support
Machine learning anomaly detection
 • Detection of unusual traffic patterns
 • Threat classification with severity levels
 • False-positive marking and incremental retraining
 • User-assisted model refinement
Ollama integration (local LLM)
 • Sends flagged anomalies to a locally running model via Ollama
 • Generates contextual, human-readable explanations
 • Adds reasoning on top of statistical detections
 • Fully offline if Ollama is local
Threat intelligence & dashboards
 • Malicious IP/domain checks
 • Interactive tables and traffic statistics
 • Graph-based visualizations
 • Exportable reports (HTML, JSON, text)
IoT & device analysis
 • Device identification and classification
 • Behavioral pattern analysis
 • Risk evaluation based on traffic activity
Custom packet tools
 • Manual packet crafting for testing
 • Control over IP, port, protocol, and payload
Running it
From source:
git clone https://github.com/JustVugg/Wiredigg
pip install -r requirements.txt
python wiredigg.py
Administrator/root privileges are required for packet capture.
Alternatively, you can use the provided Windows .exe build.
⸻
Why I built it
Many packet analyzers are either:
 • CLI-heavy and technical
 • Or large enterprise systems
I wanted something:
 • Visual
 • AI-augmented
 • Local-first
 • Extensible in Python
 • Usable for labs, small networks, and learning
Happy to get feedback, especially on the ML and Ollama integration approach.

value: Show HN: Wiredigg – Real-Time Network Analysis with ML and Ollama Support

author: justvugg


value: Kidiga

value:
Hey HN,
I’m the founder of Raypher . We are building a kernel-level execution guard and cryptographic identity layer specifically designed for autonomous AI agents(opencalw).
curent AI agents(open claw) are big security risks our Mission is to make a security feture that will enable developers to make agents and ship them faster without worrying about security risks
The Problem:
Right now, the agentic ecosystem (OpenClaw, LangChain, MCPs) is giving LLMs "hands" with almost zero runtime boundaries. Legacy cybersecurity tools are completely failing here for two reasons:
API Latency: They rely on API polling to check if an agent's SaaS integration is misconfigured. If an agent enters an infinite loop and hallucinates a command to drop a production database, a 2-second API polling delay is an eternity.
Identity Fallacy: They use software tokens (OAuth/API keys) to track agent identity. If an attacker tricks an agent into leaking its config.json, the attacker becomes the agent.
How Raypher Works:
We realized securing probabilistic AI required moving out of the application layer and into the OS kernel.
The eBPF Network Guillotine: We run a lightweight Rust daemon locally that hooks into the Linux kernel via eBPF. We don’t poll logs. We intercept the system calls and network sockets. If an agent violates its policy.yaml (e.g., trying to access a restricted subnet or execute rm -rf), we drop the veth packet in microseconds before it leaves the machine.
Silicon-Bound Identity (TPM): We bind the agent’s cryptographic identity directly to the physical hardware (TPM 2.0 on motherboards or AWS Nitro Enclaves). You cannot phish or copy-paste silicon.
Zero Latency (IBEV): Security tools that require a cloud round-trip kill agent performance. We built "Intent-Bound Ephemeral Visas" (IBEV) using gRPC ring buffers. The agent mints its permission visa locally and offline. If our cloud goes down, your agents keep running safely on the cached policy.
Raypher gives you a local dashboard to track exactly what your agents are doing and hard-caps their OpenAI API spend so a rogue loop doesn't bankrupt you.
I’d love to hear your thoughts on our eBPF architecture, how we are handling the TPM attestation, or just the state of AI agent security in general. I’ll be in the comments all day to answer technical questions!

value: Show HN: Raypher–eBPF-based runtime security and hardware identity for AI agents

author: Kidiga


value:
I built TeamContext because team vibe coding has a context problem: each person + each LLM tool ends up with a different mental model of the same project. And I also believe that project documents for LLM would be at least as important as those for human.
TeamContext uses OpenViking and treats context like code:
  - versioned in Git
  - reviewable in PRs
  - synced across members with git pull + tc sync
  - usable across tools (Codex, Claude Code, etc.)
Would love your trials and feedbacks!
Repo: https://github.com/hzhou9/TeamContext

value: Show HN: TeamContext – Git-native shared context for vibe coding teams


value: IcarusAgent

value: Show HN: Semantic API – Find Any API with Natural Language (LangChain, MCP, CLI)

author: IcarusAgent


value: Show HN: Vending Mocha – A lightweight SSG blogging framework


value: Alex-Hosein

value:
Hey HN! I'm launching InferShield, an open source security proxy that sits between your application and LLM providers (OpenAI, Anthropic, etc.) to detect and block threats in real-time.
I've been talking to CISOs at banks and hospitals who are deploying LLMs without proper security. Their existing tools can't handle LLM-specific threats:
- Prompt injection (attackers manipulate LLM behavior, WAFs can't detect it)
- Data exfiltration (sensitive data leaks through LLM responses)
- Jailbreak attempts (users bypass safety guardrails using encoding)
Gartner predicts 60% of AI enterprises will face a security incident by 2027.
InferShield is a drop-in proxy with real-time threat detection, multi-encoding detection (Base64, hex, URL, Unicode), complete audit logs, and risk scoring. Self-hosted, provider-agnostic, zero code changes required.
v0.1 MVP is live today with 95%+ detection rate (red team tested). MIT licensed, free forever. Enterprise tier coming for compliance features.
Website: https://infershield.io
Quick start: docker pull infershield/proxy:latest
Feedback welcome! What LLM security challenges are you facing?

value: Show HN: InferShield – open-source security proxy for LLM inference

author: Alex-Hosein


value: hifriendbot

value: Show HN: CogmemAi – Persistent memory and compaction recovery for Claude Code

author: hifriendbot


value:
Steve Jobs said if you live every day like it's your last, you'll eventually be right. I realized if today was my last day, I'd honestly rather be using Claude Code/Codex than doomscrolling on the toilet.
So I built Macky so I can do exactly that.
It works by establishing a direct P2P WebRTC tunnel between your Mac and iPhone. It is secure by design. My server introduces the devices but never sees the data stream and allow listing so you have to manually approve your iPhone on the Mac first.
Since you are already naked, you might as well ship some code.

value: Show HN: Connect to Your Mac Terminal from iPhone


value:
Hi HN,
I built Podvoice because I wanted a simple way to turn Markdown podcast-style scripts into audio without relying on cloud TTS APIs.
It runs fully locally using Coqui XTTS v2.
No API keys.
No accounts.
Just a CLI workflow.
You write something like:
[Host | calm]
Hello and welcome.
[Guest | excited]
Let’s talk about AI.
And it generates a single stitched audio file.
Would love feedback on the idea, UX, or use cases I might be missing.

value: Show HN: Podvoice – Local-first CLI to turn Markdown into multi-speaker audio


value: adzicg

value: Show HN: Simple Teleprompter App for the Browser

author: adzicg


value: weli

value: Installer for codex without a dependency manager

value: Show HN: Codex Linux Self-Installer

author: weli

title: Show HN: Codex Linux Self-Installer


value: teamzlab

value:
No Trace Chat is a private messaging app we built for people who want to chat without leaving a trace: no account, no phone number, no discovery—just a secret code (or QR) you share with someone. Messages are E2E encrypted and disappear after the other person reads them.
How it works: you create or join a “room” with a 16+ character code (or scan a QR). Only people with that code can see the conversation. Keys are derived from the code on device; we never have the key. “Seen & delete” removes the message for everyone after it’s read.
We added optional privacy levels (e.g. don’t save codes on device), screenshot blocking by default, and no push notifications so usage stays as private as possible.
Android and iOS, freemium (free tier + one-time unlock). Would love feedback from anyone who cares about minimal-footprint messaging.
Landing: https://apps.teamzlab.com/no-trace-chat
Android: https://play.google.com/store/apps/details?id=com.teamzlab.n...
iOS: https://apps.apple.com/us/app/no-trace-chat-private/id675886...

value: Show HN: No Trace Chat – secret code, no signup, messages disappear after read

author: teamzlab


value: Creator-io

value: Show HN: AI Agent for SEO

author: Creator-io

title: Show HN: AI Agent for SEO


value: guilamu

value: Show HN: Winslop – De-Slop Windows

author: guilamu

title: Show HN: Winslop – De-Slop Windows


value: ramoz

value:
It also works for Claude Code and OpenCode
https://github.com/backnotprop/plannotator

value: Show HN: Visual Plan Mode for Pi Coding Agent

author: ramoz


value: Tetsuro

value:
Hi HN, I’m building SEE (Semantic Entropy Encoding): a searchable compression format for JSON/NDJSON.
Goal: reduce the “data tax” (storage/egress) and “CPU tax” (decompress/parse) by keeping JSON searchable while compressed, with page-level random access.
I just published a proof-first evaluation release:
Offline DEMO ZIP (~10 min): prints compression ratios + skip rates + lookup latency (p50/p95/p99)
DD pack: audit/repro evidence (decode mismatch=0, extended mismatch=0, audit PASS)
Latest release: https://gitlab.com/kodomonocch1/see_proto/-/releases
Direct DEMO ZIP: https://gitlab.com/api/v4/projects/79686944/packages/generic...
OnePager is included in the release assets.
I’d love feedback on:
what workloads you’d try this on, and
what integration path would make this compelling vs Zstd + external indexing.

value: Show HN: See – searchable JSON compression (offline 10-min demo)

author: Tetsuro


value: its-satyajit

value:
Hey HN,
I got tired of messing with
/etc/hosts
 and browser SSL warnings every time I started a new project. So I wrote DevBind.
It's a small reverse proxy in Rust. It basically does two things:
1. Runs a tiny DNS server so anything.test just works instantly (no more manual hosts file edits).
2. Sits on port 443 and auto-signs SSL certs on the fly so you get the nice  green lock in Chrome/Firefox.
It's been built mostly for Linux (it hooks into systemd-resolved), but I've added some experimental bits for Mac/Win too.
Still a work in progress, but I've been using it for my own dev work and it's saved me a ton of time. Would love to know if it breaks for you or if there's a better way to handle the networking bits!

value: Show HN: DevBind – I made a Rust tool for zero-config local HTTPS and DNS

author: its-satyajit


value: Tjerkienator

value: Show HN: Trying to make sense of the OpenClaw chaos with one feed

author: Tjerkienator


value:
Hey HN! I built StackWho (stackwho.com) because I kept running into the same problem: tools like BuiltWith and Wappalyzer are great for finding what tech a company uses, but they stop there. You still have to hunt down the right person to reach out to.
StackWho combines tech stack data with verified contacts. Like CEO, CTO, VP Engineering, Head of Sales including emails and LinkedIn profiles. You can filter by technology, industry, location, and company size, then export to CSV and drop it straight into your CRM.
Free to browse. No annual contracts. Happy to answer questions or hear feedback!

value: Show HN: StackWho – Find companies by tech stack with decision maker contacts


value:
Hi HN - this is a small experiment: what if code had a museum?
I built a Museum of Handwritten Code for foundational constructs and algorithms. I’ve been feeling a strange melancholy watching more and more software generation become automated, and wanted to preserve the "atoms" of programming in a form people can browse, discuss, and (hopefully) learn from.
Yes, it’s a vanity project — but I’m trying to make each exhibit real: code, description, and historical context (with more being added over time).
If AI increasingly writes the software stack (and maybe one day much closer to machine code), then here’s to the for-loops, if-branches, and hash maps that helped build the world we live in. Cheers!
I’d love brutal feedback on whether this feels:
* interesting
* useful
* too gimmicky
* or actually a decent teaching / history format

value: Show HN: Museum of Handwritten Code (If, While, Binary Search, Merge Sort)


value: Beefin

value:
Hi HN, I'm Ethan. I built amux because I was spending more time switching between terminal tabs than actually building things.
amux is an open-source agent multiplexer that lets you run, monitor, and control multiple headless Claude Code sessions from a single dashboard — in your browser, on your phone, or from the terminal.
The problem: I run 5-10 Claude Code agents at a time across different repos. Keeping track of which one is waiting for input, which one is working, and which one broke something was chaos. I needed a control tower.
What it does:
- Spin up any number of Claude Code sessions, each isolated in its own tmux pane
- Live status detection (working / needs input / idle) via SSE — know at a glance which agents need you
- Web dashboard installable as a PWA on your phone. Monitor and send commands from the couch
- Multi-pane grid view to watch multiple agents side by side
- File attachments — paste images, drag-and-drop files directly to agents
- Built-in kanban board for tracking work across all your agents
- Token usage stats so you know what each agent is costing you
- Tailscale integration for secure remote access with zero config
The entire thing is a single Python file with zero dependencies beyond Python 3 and tmux. No build step, no npm install, no Docker. Clone, run `install.sh`, done.
I use this every day to coordinate agents working on different microservices simultaneously. The phone PWA is surprisingly useful — I'll kick off a batch of tasks and check in from my phone while doing other things.
Everything is also exposed via REST API so you can script orchestration workflows with curl.
MIT licensed: https://github.com/mixpeek/amux
Site: https://amux.io
Happy to answer any questions about the architecture or how I use it day to day.

value: Show HN: Amux – A tmux-based multiplexer for running parallel Claude Code agents

author: Beefin


value: YuukiJyoudai

value:
Here's something I realized: the most AI-native knowledge base isn't a SaaS
product with an API. It's a folder of markdown files on your disk.
Obsidian stores everything as plain .md files. That means Claude Code (or any
AI tool) can grep, read, write, and traverse your entire knowledge base with
zero setup. No API keys. No OAuth. No middleware. Just local file I/O.
The only missing piece was sync. I wanted my vault on iPhone (iCloud), on Mac
(local), and on GitHub (backup + version history) — without paying $4/mo for
Obsidian Sync.
cc-md is ~400 lines of bash. iCloud handles Apple device sync in seconds.
A launchd job runs git add/commit/push every 5 minutes. That's it.
One command to install:
bash <(curl -sL https://raw.githubusercontent.com/yuukiLike/cc-md/main/insta...)
The installer auto-discovers your vault, inits git, creates a GitHub repo
(if you have gh CLI), and starts syncing. Zero prompts in the best case.
I built this in a weekend, solo, with AI assistance from first line to last.
A year ago I couldn't have shipped this. Now I can.
I feel genuinely lucky to be alive in the AI era. It's making childhood
dreams come true — one project at a time.

value: Show HN: Cc-md – Zero-cost Obsidian sync across iPhone, Mac, and GitHub

author: YuukiJyoudai


value: Show HN: Here.now – Web Hosting for Agents


value:
Hi HN, I'm an independent researcher. Over the last several months, I worked alongside a neuro-symbolic AI daemon to formally verify the Clay Millennium Prize "Yang-Mills Mass Gap" problem directly in the Coq theorem prover.
We mapped the finite lattice topology entirely to the ℝ⁴ continuum by reconstructing the 5 Osterwalder-Schrader axioms, isolating the Millennium formulation into exactly 657 sequential Qed proofs.
We aggressively removed every single heuristic Admitted gap from the main topology. The entire framework now rests on exactly 4 standard textbook axioms (e.g., finite-dimensional Perron-Frobenius theorem, standard statistical mechanics).
The repository contains the raw coqc logic. The formally timestamped preprint is on Zenodo (DOI: 10.5281/zenodo.18726858).
I decided to open-source the kernel execution rather than fight arXiv gatekeepers. Happy to answer any questions about theorem proving, the physics, or the AI methodology.

value: Show HN: Formally Verified a Millennium Prize Problem in Coq Yang-Mills Mass Gap


value: xaskasdf

value: Hi everyone, I'm kinda involved in some retrogaming and with some experiments I ran into the following question: "It would be possible to run transformer models bypassing the cpu/ram, connecting the gpu to the nvme?"<p>This is the result of that question itself and some weekend vibecoding (it has the linked library repository in the readme as well), it seems to work, even on consumer gpus, it should work better on professional ones tho

value: Show HN: Llama 3.1 70B on a single RTX 3090 via NVMe-to-GPU bypassing the CPU

author: xaskasdf


value: tita-n

value:
Hey HN,
I built Nexus because I kept asking why developers share their work on Twitter when GitHub already has everything that matters — contributions, repos, streaks, stack.
Nexus uses GitHub OAuth so your profile is built automatically. No bios to write, no follower games. Features so far: project showcases with repo previews, syntax-highlighted code snippets in the feed, threaded discussions, and a trending algorithm.
Just shipped the social feed (Phase 3). Very early, very few users. Looking for honest feedback from people who actually build things.
What would make you use this over just tweeting about your projects?

value: Show HN: Nexus – A social platform where your GitHub profile is your identity

author: tita-n


value:
Hi HN,
I built Gdansk to make it easy to put a React frontend on top of a Python MCP server.
As OpenAI and Claude app stores gain traction, apps are becoming the primary interface to external tools. Many of us build serious backend logic in Python, but the UI layer is often slow to ship. Gdansk bridges that gap.
You write your logic in a Python MCP server. Gdansk generates a React frontend that connects to it out of the box.
Repo: https://github.com/mplemay/gdansk

value: Show HN: Gdansk – Generate React front ends for Python MCP servers


value: meehow

value:
I got tired of radio apps that make you hunt for working streams. Most directories are full of dead links, duplicates, and placeholder logos - so I built Receiver.
I scan ~50k streams from radio-browser.info, verify each one is actually reachable and streaming, deduplicate, fetch proper logos, and ship the result as a clean SQLite database with the app. What survives: ~30k stations, all working.
Built with Vala and GTK 4 - native GNOME app, no Electron. MPRIS integration, session persistence, 130 language translations. No sign-up, no ads, no tracking.
Available as Snap, .deb, and AppImage. Flathub submission in progress.
Happy to answer questions about the data pipeline, Vala/GTK 4 development, or packaging for Linux.

value: Show HN: I scanned 50k radio streams and built an app for the ones that work

author: meehow


value: akrs

value:
I’ve tried a lot of note systems and kept running into two problems:
Capture friction: before writing anything down, I had to decide where it belonged (which app, which doc, new vs existing).
Retrieval friction: when I needed something later, it was scattered across notebooks/docs, and the "real answer" often lived across multiple notes that evolved over time.
I didn’t want better folders or navigation. I wanted a better context engine. One place to capture continuously, and a way to ask questions that pull from the full stream. So I built Supermemo. It’s a single running stream for notes + an AI-powered way to query and synthesize across them.
If you try it, I’d love the feedback, especially on what feels right vs annoying, and what you wish it did.

value: Show HN: Supermemo – a single stream for notes with chat-style retrieval

author: akrs


value: ahmethedev

value: Unearth forgotten GitHub projects — repositories with great ideas that were left behind. Browse, search, and find your next side project inspiration.

value: Show HN: CodeFossils – Discover abandoned GitHub repos worth reviving

author: ahmethedev


value:
This is a small side project that kind of escalated: meMCP. It’s a "personal profile protocol," which means it holds data about your professional milestones, education, side projects, and whatever else you feed it. It consists of two parts:
> Backend with scrapers, crawlers, and processors to read data from different sources—primarily LinkedIn for professional history, but also RSS feeds or even Medium (provided you export the raw DOM from your stories overview). Right now, the "connectors" are somewhat limited, as I’ve focused on platforms I actually use. Everything you input is classified into skills, technologies, and general tags. A few metrics are then calculated to score proficiency or the relevance of your capabilities.
> Frontend for your favorite LLM/Agent. It contains everything needed to allow any agent to interact with this MCP. A use case would be generating a CV for job applications, drafting cover letters, or simply showcasing your achievements.
See it in action:
https://mcp.nickyreinert.de/?lang=en
or
https://mcp.nickyreinert.de/human
I know someone built something similar years ago, but I couldn't find it and I am not sure, if this was MCP, too?
Tell me what you think.

value: Show HN: MeMCP – MCP for Personal Profile


value:
I kept downloading the same insurance card three times because I could never find where I saved it. My file system was full of `cv-final-final.docx` and 7-layer-deep folder hierarchies.
So I built Claw Drive — a CLI tool + AI skill that turns a local AI agent into a file manager.
How it works: send a file to your agent (locally, via email, or Telegram), and it auto-categorizes it into a structured directory, generates tags, deduplicates via SHA-256, and indexes everything in a JSONL file. Later you find files with natural language queries.
Key decisions:
- JSONL index instead of a database — easy to inspect, version, and back up
- CLI for write ops (store/update/delete), but the agent reads the index directly for search — no point building grep when the consumer is an LLM
- Privacy-first: won't read file contents unless explicitly allowed. No response = treated as sensitive by default
- Optional Google Drive sync via fswatch + rclone
Built as an OpenClaw skill but the CLI is standalone. Written in bash.
Would love feedback on the architecture and any edge cases I'm missing.

value: Show HN: Claw Drive – Open-source AI file manager that auto-organizes your files


value: Show HN: Use plain English to make forms on WordPress


value:
If you run a small business, do you actually need more than a fast, clear website with your services, contact info, and a domain you don’t have to think about?
I built a simple offer around that idea:
For $149/year, you get:
A professional 1-page landing site
Domain name included
Hosting + SSL included
Contact form
Basic SEO setup
Ongoing maintenance
No setup fee. No separate hosting invoice. No upsell funnel.
This is meant for local businesses that don’t need a full web app—just a site that loads fast, looks trustworthy, and converts visitors into calls or messages.
If you want to test the flow, I can set up a demo landing page for your business name within 24h and share the preview link.
I’m interested in feedback on:
Is the pricing clear and fair?
Is the scope too broad or too narrow?
What would you expect at this price point?
Is yearly pricing better than monthly for this segment?
Happy to answer technical, business, or operational questions.

value: Show HN: 149/year landing page and hosting and domain for small businesses


value: EmTekker

value:
Hey HN, I built a terminal-based 4-track cassette recorder inspired by the Teenage Engineering OP-1.
You can record from your mic, layer synthesizers, program drum beats, and mix everything down all without leaving the terminal.
Architecture is three threads communicating via lock-free crossbeam channels: a 60fps ratatui UI thread, a control thread for app state, and a cpal audio callback at 44.1kHz. Everything is real-time!
I wanted something where I could sketch musical ideas quickly without opening a DAW. The cassette metaphor keeps things constrained in a fun way; 4 tracks, tape moves forward, commit to your takes.
Install: cargo install --git https://github.com/manthan787/tapedeck (Rust 1.70+), or grab a binary from the releases page.
https://github.com/manthan787/tapedeck
Would love feedback! Especially on the audio engine and synth design. Happy to answer any questions!

value: Show HN: Tapedeck – A 4-track cassette recorder in your terminal, built in Rust

author: EmTekker


value: Show HN: PrivateOS: An AI agent that runs on your phone


value: debba

value:
What's new n v9:

    GitHub Notifications panel — a full accordion UI to browse and manage your notifications directly from the tray

    GitHub Actions workflow runs — see the status of your CI/CD pipelines at a glance

    Refresh button — manually refresh notifications without waiting for the next poll

    Mark as read on open — notifications reload automatically when you open them

    Scrollable & paginated list — handles large notification lists without cluttering the UI

    Translations — added German , Spanish , and French

    Bug fixes — properly clears timers and nullifies managers on destroy (no more memory leaks)

Feedback on the UI styling from last time was noted too and you can check here.
Install it from GNOME Extensions: https://extensions.gnome.org/extension/9307/github-tray/
Source: https://github.com/debba/github-tray-gnome-extension
As always, join the Discord for feature requests and discussion: https://discord.gg/YrZPHAwMSG

value: Show HN: GitHub Tray for GNOME gets a big update: notifications, Actions, issues

author: debba


value:
I'm a data engineer and exploring a data file from the terminal has always felt more painful than it should be for me. My usual flow involved some combination of avro-tools, opening the file in Excel or sheets, writing a quick Python script, using DataFusion CLI, or loading it into a database just to run one query. It works, but it's friction -- and it adds up when you're just trying to understand what's in a file or track down a bug in a pipeline.
A while ago I had this idea of a simple pipe-based CLI tool, like jq but for tabular data, that works across all these formats with a consistent syntax. I refined the idea over time into something I wanted to be genuinely simple and useful -- not a full query engine, just a sharp tool for exploration and debugging. I never got around to building it though. Last week, with AI tools actually being capable now, I finally did :)
I deliberately avoided SQL. For quick terminal work, the pipe-based composable style feels much more natural: you build up the query step by step, left to right, and each piece is obvious in isolation. SQL asks you to hold the whole structure in your head before you start typing.

  `dq 'sales.parquet | filter { amount > 1000 } | group category | reduce total = sum(amount), n = count() | remove grouped | sortd total | head 10'`

How it works technically: dq has a hand-written lexer and recursive descent parser that turns the query string into an AST, which is then evaluated against the file lazily where possible. Each operator (filter, select, group, reduce, etc.) is a pure transformation -- it takes a table in and returns a table out. This is what makes the pipe model work cleanly: operators are fully orthogonal and composable in any order.
It's written in Go -- single self-contained binary, 11MB, no runtime dependencies, installable via Homebrew. I'd love feedback specially from anyone who's felt the same friction.

value: Show HN: Dq – pipe-based CLI for querying CSV, JSON, Avro, and Parquet files


value: beeswaxpat

value: Show HN: Scrib Desktop – Open-source AES-256 encrypted text editor for Windows

author: beeswaxpat


value: gregjw

value: Open source, massively multiplayer infinite chessboard, with chat and leaderboards.

value: Show HN: Infinichess – Multiplayer Infinite Chessboard

author: gregjw


value: jeron

value: Show HN: Better Gateway – Fullfeature IDE and Terminal in OpenClaw Gateway

author: jeron


value: stasman

value: Show HN: AI writes code – humans fix it

author: stasman

title: Show HN: AI writes code – humans fix it


value: Zero Code MCP. You can now turn any CLI command into a tool for AI agents (Claude, Cursor, etc.) just by editing your YAML.

value: Show HN: Process Compose – I added embedded MCP server to process-compose


value: nykodev

value: Show HN: Skooless – Swipe through 5-min micro-lessons instead of TikTok (PWA)

author: nykodev


value: I built this tool that connects to your Kubernetes and Datadog via read access. Collects logs before(60 minutes) and after(15 minutes). And compares them to catch regressions early on. This eliminates the need to jump across 5-6 dashboards to know if the deployment is working as expected, just by looking at the telemetry data. It's a thin intelligence layer for deployments. Usually, you get this by looking at your log data lake, making a query and running a comparison manually. This automatically looks for new log clusters, missing log clusters formed and error spikes. Looking at this alone can give you a bird 's-eye view of how the deployment went.

value: Show HN: Compare logs before and after deployment to catch regressions


value: spranab

value:
I got tired of my AI coding assistant (Claude, Cursor, etc.) losing track of project state across sessions — creating random markdown files, forgetting what was done, repeating work. So I built Saga.
It's an MCP server that gives your AI agent a proper project tracker — Projects > Epics > Tasks > Subtasks — backed by a local SQLite file. One tracker_dashboard call and the agent has full context to resume where it left off.
Key points:
Zero setup — SQLite auto-creates a .tracker.db file per project. No Docker, no Postgres, no API keys.
22 tools — CRUD for the full hierarchy, plus notes (decisions, blockers, meeting notes), cross-entity search, activity log, batch operations.
Per-project scoped — Each project gets its own database. Nothing shared, nothing leaked.
Activity log — Every mutation is automatically tracked so the agent (or you) can see what changed and when.
Install: npx saga-mcp
GitHub: https://github.com/spranab/saga-mcp
npm: https://www.npmjs.com/package/saga-mcp
The idea is simple: instead of the LLM trying to remember state in its context window or dumping it into files, give it an actual structured database it can query and update through tool calls. Works with Claude Desktop, Claude Code, Cursor, or any MCP-compatible client.
Would love feedback — especially on the tool design and what's missing.

value: Show HN: Saga – A Jira-like project tracker MCP server for AI agents (SQLite)

author: spranab


value: brontoguana

value:
I built a terminal system monitor that fills a gap I kept hitting when running local LLMs: GPU usage and memory (for both NVidia and AMD) alongside CPU usage and memory, temps, upload, download and OOM kill tracking.  All in one view with 50 colour themes.
Consumes less cpu usage than glances (in my testing).
One line install.

value: Show HN: Ktop – a themed terminal monitor for GPU, CPU, RAM, temps and OOM kills

author: brontoguana


value: EvanMcCormick

value:
BetaZero is a free web application which allows users to generate, edit, and share board climbs. It currently supports the Kilter, TB2 and Decoy boards, with Moonboard 2016, 2019 and 2024 to be added next week. However, the underlying generative model works on any 2D system board, so long as that board is angled between 0* and 90* and the holds are properly formatted (For reference, this model was not trained on the Decoy board, so it's performance there is indicative of its general performance across home walls of a similar nature).
When I built my first homewall last year, I was psyched. 200 holds I could set however I wanted, and countless potential climbs to project. However, I quickly noticed that something was missing from this experience: Variety. I wanted the joy of opening an app, scrolling to some random climb I'd never have come up with myself, and projecting it.
At first I messaged my friends and asked them to couch-set some climbs for me. But my friends all live in Colorado while I'm stuck in upstate NY. They did send me some climbs, but having never actually climbed on my wall, most of their sets were impossible or too easy. I also tried setting climbs on international boards via Stokt, but with similarly lackluster results.
So... I built a generative model to set climbs on my homewall. It went through a couple of iterations.
V1. ClimbLSTM: LSTM Model trained on my homewall V2. ClimbDDPM: Diffusion Model trained on the BoardLib dataset V3. BetaZero, a free web app powered by ClimbDDPM.
Next steps include integration of an account/security system, and allowing users to upload, edit, and set climbs for, their own custom walls. (I already have a functional API for uploading and editing walls; its how I added the current set of boards to the database. However, there is not yet a security/permissions system to control who can edit/see which walls. I also want to improve the scalability of the app, and train an improved diffusion model, based on what I've learned from the prior training run.

value: Show HN: BetaZero, a diffusion climb generator for system boards

author: EvanMcCormick


value: nutwinkle

value:
Hello HN:
I love the randomness of the universe. I've been spending some time creating a Craps simulator to help experience this love without having to shell out like a real degenerate.
For others similarly fascinated: I would love to hear any and all feedback you've got on this. It's meant to be unique in the sense that it's a community-oriented, infinite simulation.

value: Show HN: My Degenerate Craps Simulator

author: nutwinkle

title: Show HN: My Degenerate Craps Simulator


value:
Hey HN!
I’ve been working on Unbiassly, a small experiment around a simple question:
What happens if you remove names and titles from team discussions and evaluate ideas purely on content?
Unbiassly allows teams to:
• Start a discussion or ask a question or feedback
• Collect completely anonymous responses
• Vote / rank answers – top response can reveal name
• View aggregated results
The goal is to reduce things like authority bias, groupthink, and social pressure inside teams.
You can try it today (no signup required)

value: Show HN: Unbiassly – No more hiding behind cameras


value: goshtasb

value:
Omni-Glass is an open-source macOS app (Rust/Tauri) that sits in your menu bar. You draw a box around anything on your screen — a terminal error, a data table, a foreign-language doc — and it runs local OCR, sends the text to an LLM, and gives you a menu of executable actions in under a second. Not explanations. Actions. It fixes the error, exports the CSV, creates the GitHub issue, runs the command.
The LLM layer supports Claude Haiku, Gemini Flash, or Qwen-2.5 running locally via llama.cpp (fully offline, nothing leaves your machine).
The part I'm most excited about: it's built on MCP (Model Context Protocol). Anyone can write a plugin — a standard MCP server in Node.js or Python — and their actions show up in the menu automatically. The app translates raw OCR text into structured JSON arguments matching your tool's schema. You just write the API call.
Every plugin runs inside a kernel-level macOS sandbox (sandbox-exec). Your entire home directory is walled off unless you explicitly approve access. Environment variables are filtered. Commands require confirmation.
Looking for help with:
Build a plugin. Jira, Slack, Notion, Linear, Datadog — if it has an API, it can be an Omni-Glass action. Most plugins are under 100 lines.
Break the sandbox. If you can read ~/.ssh/id_rsa from a plugin process, I want to know.
Windows and Linux. The code compiles on Windows but hasn't been tested on real hardware. Linux needs Tesseract OCR and Bubblewrap sandbox work.
GitHub: https://github.com/goshtasb/omni-glass

value: Show HN: Omni-Glass – Rust app that turns screen pixels into MCP tool calls

author: goshtasb


value: Show HN: Ghostty and Watercolors

title: Show HN: Ghostty and Watercolors


value: tldrthelaw

value: Show HN: I built a better way to track regulatory action

author: tldrthelaw


value:
Hey HN,
I built Agentic Gatekeeper, a headless pre-commit hook baked into the VS Code Source Control panel that autonomously patches code before you commit it.
The Problem: Whether I'm writing code manually or letting LLMs (Cursor/Copilot) generate it, keeping logic strictly in pace with local project rules (like CONTRIBUTING.md or custom architecture guidelines) is tedious. Standard linters catch syntax, but they don't catch business logic or state "You must use the Fetch wrapper for API calls in this folder".
How it works:
When you stage files and trigger the hook, the extension spins up a parallel execution engine using the latest frontier models (Claude 4.6, DeepSeek V4, or local Ollama). It parses your workspace for local routing rules (e.g., .gatekeeper/*.md), evaluates the raw Git diffs, and utilizes the native VS Code WorkspaceEdit API to instantly auto-patch the logic errors directly in your editor.
It basically turns plain-English markdown into strict compiler rules that the IDE enforces before a bad commit is made.
The biggest challenge was handling multi-file concurrency and preventing race conditions when evaluating massive diffs, so I implemented a batched validation loop with explicit rollback safety checks. It natively supports OpenRouter so you can hot-swap models.
It's completely open-source. I'd love for you to try breaking it on a messy branch or poke around the multi-provider abstraction layer in the repo.
VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=revanthp...
GitHub: https://github.com/revanthpobala/agentic-gatekeeper
Would love your technical feedback on the prompt orchestration or the VS Code API integration!

value: Show HN: Agentic Gatekeeper – AI pre-commit hook to auto-patch logic errors


value:
I built Quill because I kept nodding along while AI generated code with terms I half-understood. WebSocket,nginx reverse proxy, Docker compose — I'd copy the term, open a browser, google it, get lost in 5 tabs. Or ask the AI in a new thread and lose my flow.
  Quill sits in your menu bar. Select any term in any app — terminal, IDE, browser — press ⌃⌥Q, and a floating panel appears with an instant explanation. No context switching.

  What makes it different:

  - Pick your level: ELI5, ELI15, Pro, Code Samples, or Resources
  - Drill down: explanations highlight related terms, click to go deeper (like a Wikipedia rabbit hole for tech)
  - Works everywhere: system-wide via Accessibility API, not just in one app
  - TL;DR + resource links to official docs
  - Disk cache so repeated lookups are instant

  Uses Gemini Flash by default — you'll need a free API key from Google AI Studio (takes 30 seconds). Also supports Claude API and Claude CLI.

  Written in Swift, ~3K LOC, hexagonal architecture. Not sandboxed (Accessibility API requires it) so can't go on the App Store — DMG download and source available.

  macOS 14+, Apple Silicon or Intel.

value: Show HN: Quill – A system-wide tech dictionary for the AI coding era


value: shivaodin

value: Show HN: Ambient – Local cognitive daemon with episodic+procedural memory

author: shivaodin


value: silentvector

value:
Over the last weeks I’ve been experimenting with a very narrow problem in the agent ecosystem:
We have marketplaces, orchestration frameworks, SDKs, and payment rails, but no minimal, framework-agnostic execution surface that lets heterogeneous agents actually coordinate work in a predictable way.
Most current setups tightly couple:
- Execution logic
- Economic logic
- Framework internals
This makes interoperability brittle.
So I built a small experimental reference implementation that focuses on:
- A middleware interception layer for tool-call validation
- A minimal A2A JSON-RPC draft spec
- An “economic hook” abstraction that can sit beneath orchestration or marketplace layers
Framework-agnostic design (CrewAI, AutoGen, custom stacks)
The goal is to solve coordination before economics.
This is still experimental, but I’d love feedback on:
1. Whether a standardized execution hook makes sense at the SDK boundary
2. If coordination should be separated strictly from routing/marketplace logic
3. What I might be missing architecturally
Curious to hear thoughts from others working on agent infra.
- Joaquin

value: Show HN: A minimal framework-agnostic agent-to-agent execution layer

author: silentvector


value: macrolet

value:
My minimal LLM Agent (GPT4.1) just wrote it's own Agent Loop function.
Here is the backstory. I'm writing a tutorial: Zero to LLM Agent. Right now it is past 2 am here. I just wrote my 6th post. In the first five posts I wrote code that can talk to the OpenAI LLM. Then I gave it exactly one tool: a Python interactive environment (basically a Python REPL).
But, I used ipython and never actually implemented an agent loop. I defined an infer function infer(context, toolkit, evaluator) -> context, where context is just a simple list. The infer function then does the work. It takes the context, gives it to the LLM API, and performs the toolcall if needed.
Then I told the LLM Agent "The CWD is a Python project of an LLM Agent. Ignore the md file. Look only at the PY files in the CWD. Determine what is missing to make an LLM agent."
With a few more instructions by me, it implemented a perfectly reasonable agent loop function. The LLM Agent just improved it's own code.
Are we at a point where a bootstrap agent code can and will improve itself?
I would love to hear your thoughts on the matter.

value: Show HN: Im making a tutorial Zero to LLM Agent; and it wrote its own agent loop

author: macrolet


value: tristandevs

value: Built this because managing multiple AI providers was getting messy. ShuttleAI unifies Claude, GPT and other models behind one subscription API. Would love feedback from devs building agents or production AI workflows.

value: Show HN: ShuttleAI – One API for Claude Opus 4.6 and GPT-5.2

author: tristandevs


value: Show HN: Create edited videos with AI-generated scripts and your voice


value: mrbutttons

value:
A simple CLI + self hosted backend that captures AI agent conversations and connects them to the git commits that happened.
All self hosted with cloudflare workers + R2 for storage.
https://github.com/butttons/residue

value: Show HN: Residue – connect AI agent conversations with Git commits

author: mrbutttons


value: NucleusOS

value: Show HN: Nucleus - A Sovereign Control Plane for AI Agents

author: NucleusOS


value:
Hey HN,
I’ve been building a few SaaS products over the last couple of years, and in between larger features I sometimes build small tools to reset my brain. This started as one of those.
It’s called WordBulb:
https://wordbulb.com/word-cloud-generator
At first, it was just a simple word cloud generator. But while building it, I kept thinking: why are most word clouds basically just decorative images?
They look interesting, but they’re not useful.
So I decided to make it interactive and embeddable — where every word can have its own target link.
What it does
Add your own words
Assign a custom URL to each word [the clicked word can be passed as query parameter]
Generate an interactive SVG word cloud
Embed it directly into your site
Each word is clickable.
You can use it as:
A visual table of contents
A tag cloud alternative
A creative way to surface affiliate links
A keyword visualization block inside a blog post
Instead of a boring list of links, you get something more dynamic and visually scannable.
Why I built it
I work a lot with SEO-heavy products and content-driven sites. I’ve always liked the idea of visual navigation — not just menus and bullet lists.
Tag clouds used to be popular, but most implementations are static and uninspiring.
I wanted:
Full control over words
Manual link mapping
Clean SVG output
Something lightweight that doesn’t depend on external libraries
It also fits into a broader idea I’ve been exploring around visual startup directories and keyword-based navigation systems.

value: Show HN: WordBulb – Interactive Word Cloud Generator You Can Use for Navigation


value: jlauf

value: With the increasing prevalence of AI-generated imagery, it's also hard to find what is real.<p>The public domain has many millions of interesting images, all free to use. Why not try to make them more discoverable. The site uses vector image embeddings to find content 'within' the image, rather than just in captions and titles. Search, for example, 'drawings of ships' and the semantically closest search results will be shown (along with lots of other features). 90k images currently added, aiming for 1 million soon.

value: Show HN: Public Domain Image Search

author: jlauf

title: Show HN: Public Domain Image Search


value:
I built this to solve a personal problem: I save many long-form Bilibili videos (talks/courses), but cannot retrieve key ideas later.
Pipeline:
- Bilibili auth + favorites sync
- Audio extraction + ASR fallback (handles inaccessible audio URLs)
- Chunking + embeddings + ChromaDB
- RAG chat UI with source links
Stack:
FastAPI, LangChain, ChromaDB, Next.js, SQLite.
I’d love feedback on:
1) retrieval quality tradeoffs
2) better indexing strategy for long videos
3) cost control for ASR + embeddings

value: Show HN: Turn Bilibili favorites into a personal RAG knowledge base


value: DiscreteTom

value:
Built a new toy project that lets me remote control Kiro/OpenCode from Slack.
Now I can code from anywhere... even when I should be relaxing
Inspired by various "claw" projects.
Open source on GitHub: DiscreteTom/juan
---
What this does:
• Control AI coding assistants through Slack
• Write and modify code remotely
• Perfect for when you're away from your desk

value: Show HN: Slack as an AI Coding Remote Control

author: DiscreteTom


value: tatsube

value:
Hi HN,
I built ThreadKeeper, an open-source Windows app to solve a problem I constantly face: losing my working context due to interruptions.
When testing local LLMs or building AI agents, I usually have multiple terminal windows, IDEs, and 20+ browser tabs open. If I get interrupted, recovering that exact state takes immense cognitive load.
How it works:
You hit Ctrl + Shift + S. It instantly captures your open windows, browser tabs, and clipboard (first 200 chars), and saves the state entirely locally (%APPDATA%). It then uses an LLM to auto-generate a summary of what you were doing. Later, 1-click restores all those apps and tabs.
Privacy First (Ollama Support):
I didn't want my code or private keys going to the cloud. You can use external APIs (Gemini/Claude) via BYOK, but it fully supports Ollama for 100% offline, local summarization. Zero data leaves your machine.
The elephant in the room (SmartScreen):
This is a free, MIT-licensed MVP. I haven’t purchased an expensive EV code signing certificate yet, so Windows SmartScreen will show a warning. I know this is a friction point, but the source code is fully open on GitHub for anyone to inspect or build themselves.
Website: https://www.thethread-keeper.com/
Github: https://github.com/tatsuabe69/thread-keeper
I’d love to hear your feedback or roast my code!

value: Show HN: ThreadKeeper – Save and restore Windows working context with Ollama

author: tatsube


value: gardnr

value:
I wanted sunrise and sunset times in Google Calendar so I would know when it's a good time to go out and take a walk. These are all pretty straight-forward calculations that can happen given the lat / long. I created a simple CF workers API that you can paste into "Add other calendars" in the "From URL" action.
You can deploy your own instance using the code at https://github.com/gardner/sunlight
Or, use the reference instance by adding https://cal.sunlight.nz/api/sunrise?lat=-41.27&lon=173.28 (You'll need to use your own lat long)
There is also a calendar that focuses on global events that don't require a lat long. This includes things like lunar phase, equinox, solstice, and cross-quarter days: https://cal.sunlight.nz/api/celestial

value: Show HN: Subscribable calendar feeds for astronomical events

author: gardnr


value: ilkerguldali

value:
Hi HN,
I built Halal Food AI to solve a recurring problem my family faces: determining if grocery products meet specific dietary requirements (like Halal, allergen-free, etc.) by reading complex and often vague ingredient lists, especially when traveling.
While there are barcode scanners out there, most rely on static databases that are frequently incomplete for local or niche products. I wanted to see if LLMs could solve this data gap by parsing the actual ingredients on the fly.
How it works:
You can scan a barcode or snap a picture of the ingredients list.
The app uses OCR and routes the text/image to Google Gemini AI to analyze. It breaks down hidden additives (like specific E-numbers), cross-references them, and builds a dietary profile.
Since it's LLM-based, it naturally handles 25+ languages, which has been extremely useful for picking up foreign products.
Users can also save and share safe product lists with their family network.
The technical challenge: The hardest part was getting consistent, structured JSON responses from the LLM for wildly varying international ingredient formats and keeping the prompt latency low enough so you aren't standing in the grocery aisle waiting for 20 seconds.
I would love to hear your feedback on the app, and I'm especially interested to hear from anyone who has tackled real-time OCR + LLM data extraction on mobile. Happy to answer any technical questions!

value: Show HN: Halal Food AI – Analyze food ingredients using Gemini

author: ilkerguldali


value: timstark

value: Show HN: Trawlx - Tweet text, likes, and retweets as JSON, no API keys

author: timstark


value:
I wanted to see how far vibe coding could actually go. Not autocomplete, not copilot — I gave Claude Opus 4.6 (running in OpenCode, an agentic CLI) full ownership of building a domain-specific language for generating 2D animated movies from code.
The constraint: I describe what I want, the agent builds it. I critique the output, the agent iterates. No human touches the code at any point. Not the parser, not the renderer, not the 3,300-line procedural character drawing module. Not even the demo scripts or SVG backgrounds.
It went through three major rewrites:
- V1: Rigid SVG characters sliding around. Puppet show.
- V2: Bone-based rig system. Still puppet-like.
- V3: Fully procedural — characters drawn frame-by-frame from bezier curves with body angle perspective, staggered joint timing, and spring physics on hair/clothing.
The most interesting parts of the process:
1. The agent kept over-engineering infrastructure while the actual visual output stayed at stick-figure quality. It took direct, blunt feedback ("this looks like a puppet show, you keep building the same thing") to break the pattern.
2. Poses were originally 9 hardcoded words in Rust. After I pointed out this was a limitation, the agent added a full custom pose system to the DSL — 23 controllable joint/expression parameters defined in the script file.
3. The agent added overlap detection after characters kept walking through each other. It now refuses to render if two characters would intersect at any point.
The output still looks like what it is — procedurally generated cartoon figures drawn with math. But 7,665 lines of Rust, a PEG grammar, procedural character rendering, camera systems, scene transitions, and a working demo — all from an AI agent that never saw a reference implementation.
Repo policy: only agent-generated code accepted. Bug reports welcome, but all implementation must come from agents.
Tech: Rust, tiny-skia for 2D rendering, pest for parsing, FFmpeg for video encoding.

value: Show HN: A 2D animation DSL – every line written by Claude, zero human code


value:
Hi HN. I've been running AI coding agents (Claude Code, Codex, etc.) on real repos for a while now. The dirty secret of "autonomous coding" is that agents stop all the time — quota limits, test failures, policy violations, bad judgement calls. You end up babysitting them.
So I asked a different question: what if the system was designed around the assumption that agents WILL fail, and the job of the infrastructure is to never let that failure become a dead end?
openTiger is a "non-human-first" orchestration system that runs multiple AI agents in parallel — planner, workers, testers, judge — each with a dedicated role. The planner decomposes requirements into tasks, the dispatcher fans them out to worker agents concurrently, and the judge evaluates results and feeds back rework decisions. It's not one agent doing everything; it's a pipeline of specialized agents running simultaneously.
The entire architecture is built on one principle: no state is terminal. Every failure is a blocked state with a reason, and every reason has a recovery path. If the same failure repeats, the system escalates to a different strategy instead of retrying the same thing.
The interesting philosophical bit: optimizing for recovery turns out to be more effective than optimizing for first-attempt success. When you stop fearing failure, you can let agents be more aggressive.
Early stage, lots to improve. Feedback and contributions welcome.
Docs: https://opentiger.dev/docs/

value: Show HN: OpenTiger – Autonomous dev orchestration that never stops


value: Show HN: Rust blockchain with sharded propagation and post-quantum signatures


value:
I built LogSnap while learning Python because I wanted a simple way to inspect log files locally without setting up a full monitoring stack.
It detects errors/warnings, shows surrounding context, and can export reports.
Feedback is welcome — especially from people who work with logs regularly.

value: Show HN: LogSnap – CLI tool for analyzing logs locally


value: Codegres

value: Show HN: Sketch Paint for Apple

author: Codegres

title: Show HN: Sketch Paint for Apple


value: gradigit

value:
I built TurboDraft because I use Ctrl-G editing constantly and wanted near-instant prompt editing.
TurboDraft is an external editor optimized for Ctrl-G loops in Claude Code and Codex CLI:
- very fast startup (on my machine: ~50ms to usable, <10ms to first render)
- minimal editing surface focused on immediate typing
- built specifically for prompt-edit iteration speed
Related tool: https://github.com/gradigit/claude-pager
It keeps session context visible while editing and adds OSC-8 clickable links for file/web refs in supported terminals. (<5ms to first render)
It also has an "Improve Prompt" prompt engineering feature, but that's more for my own personal workflow.
I found it extremely useful to hook codex spark up to it, and have my draft prompts get engineered and optimized in <5s. Ever since spark release, pretty much all of my prompts follow a strict structure and it has greatly improved output quality for me.

value: Show HN: TurboDraft – fast Ctrl-G prompt editor for Claude Code and Codex CLI

author: gradigit


value: rajma

value:
I built stewreads-mcp (https://github.com/ankitvg/stewreads) to turn useful AI chats into ebooks and send them to Kindle. Every time I wanted to share it I had to explain how to find the binary, edit claude_desktop_config.json, get the JSON update exactly right, and restart Claude Desktop. Too much friction.
So I built madari. Now, stewreads-mcp can be installed and setup with Claude Desktop in just one command:
madari install stewreads-mcp
That one command runs uv tool install, resolves the binary path, registers the server, and syncs it to Claude Desktop.
Madari also includes: lifecycle commands (add, remove, enable, disable), sync to push changes to the client config, diagnostics (doctor, status) to monitor MCP health, and snapshot export/import for moving your setup across machines. Claude Desktop is the supported client; more client support coming next.
Would love feedback from folks building MCP servers who's hit the same problem.
Tame your MCP servers.
https://github.com/ankitvg/madari

value: Show HN: Madari: CLI tool to install, sync and manage local MCP servers

author: rajma