value: randallme

value:
Hey HN. I built Deathwink (https://deathwink.com) -- a web app that delivers your messages after you die.
You write a message, record a video or audio message, or both -- attach whatever you want, add your recipients, and go live your life. Every 30 days, we check in. If you stop responding, after 90 days we assume you've died and deliver your messages.
The idea came from a real place. In my early 20s, my best friend Sean and I came up during the first dot-com boom. We were broke, dumb, and inseparable. He died of an overdose a few years later. I never told him what his friendship meant to me—not because I didn't feel it, but because that's not what guys like us did. I wrote a memoir about it (How You Wish You Could Leave), and somewhere in the process of reliving all that regret, I realized I wanted to build the thing I wished had existed.
On the technical side: it's serverless on AWS -- Lambda functions behind API Gateway, RDS, Angular frontend on S3/CloudFront, Cognito for auth, SES for email delivery, and EventBridge-triggered workers that run the lifecheck monitor and wink delivery daily. Stripe for payments.
Business model: one-time payment, not a subscription. Three tiers from $500 to $3,000 depending on how many winks and attachments you need. I didn't want to build something where people worry about their credit card expiring before they do.
Happy to answer questions about the architecture, the delivery reliability problem (how do you make sure messages actually arrive years from now), or anything else.

value: Show HN: Deathwink – Send messages to people after you die

author: randallme


value: rajma

value: Show HN: StewReads – Turn Claude chats into Kindle ebooks

author: rajma


value: GregorStocks

value: I've been teaching LLMs to play Magic: The Gathering recently, via MCP tools hooked up to the open-source XMage codebase. It's still pretty buggy and I think there's significant room for existing models to get better at it via tooling improvements, but it pretty much works today. The ratings for expensive frontier models are artificially low right now because I've been focusing on cheaper models until I work out the bugs, so they don't have a lot of games in the system.

value: Show HN: I taught LLMs to play Magic: The Gathering against each other

author: GregorStocks


value: mortondev

value: Show HN: Quackback – Open-source customer feedback your AI agent can triage

author: mortondev


value: rgcr

value:
It creates sessions when they don’t exist and reuses them when they do — idempotent by default.
It can start sessions from simple YAML project files.
And if you hate writing YAML, it can generate the file for you from an existing session.

value: Show HN: Lightweight tmux session and project manager written in Bash

author: rgcr


value: oliwary

value:
Hi!
I just launched changeword, a daily word game where you have to transform one word into another by replacing or inserting one letter at a time. Each inbetween word has to be a valid word as well.
Changeword is my first multilingual word game - you can play it in English, Spanish, French, German, Dutch and Swedish.
Any feedback is appreciated! :)

value: Show HN: ChangeWord, transformative word game in 6 languages

author: oliwary


value: stevengreser

value: Show HN: I built a simulated AI containment terminal for my sci-fi novel

author: stevengreser


value: Tinymind

value: Show HN: A centralized resource for software, tools, and services

author: Tinymind


value: neurokinetikz

value:
I've been meditating with consumer EEG headbands for years and started writing code to analyze my own data. I found something I wasn't expecting.
Earth's Schumann Resonance oscillates at ~7.8 Hz with harmonics at roughly 14, 20, 26, and 32 Hz. These overlap with canonical EEG frequency bands. That overlap was noted before but generally treated as coincidence.
In 2010, Pletzer, Kerschbaum, and Klimesch at Universität Salzburg proposed that EEG bands follow golden ratio organization, but the idea got little empirical follow-up.
My analysis suggests they were right. Brain oscillation peaks can align with golden ratio (φ = 1.618) precision, anchored within range of the ~7.8 Hz fundamental. Tested across 1M+ spectral peaks from independent datasets. Less than 2% error. (and yes, I would be very skeptical too :)
---
Here's the research:
Golden Ratio Architecture of Human Neural Oscillations (preprint)
https://doi.org/10.5281/zenodo.18244908
When frequencies never synchronize: the golden mean and the resting EEG (Pletzer et al. 2010)
https://doi.org/10.1016/j.brainres.2010.03.074
Research code: https://github.com/neurokinetikz/schumann
---
And I built an app to detect these alignment states in real time.
HOW IT WORKS:
The app analyzes the raw EEG signal to separate real oscillatory peaks from background noise, then scores how precisely those peaks match predicted golden ratio frequency positions across three bands at Earth-resonant frequencies. It also measures how synchronized different brain regions are using cross-channel metrics.
When all measures pass threshold simultaneously and hold for a minimum duration, it flags an ignition and plays an audio tone. Sessions are logged with per-event timing, strength, and duration. Progress tracked across sessions.
Everything runs client-side in the browser. No backend signal processing.
Supported Devices: Muse 2, Muse S, BrainBit, Emotiv Insight/MN8
Demo mode works without hardware. If you have a Muse or BrainBit, pair directly from the browser. No signup, no install.
Would love your feedback, thanks!!

value: Show HN: Browser-based EEG neurofeedback detecting golden ratio brain coherence

author: neurokinetikz


value: Show HN: OpenBoot – 2 commands to replace a 3-hour Mac setup ritual


value: auspiv

value: Show HN: Trained YOLOX from scratch to avoid Ultralytics (aircraft detection)

author: auspiv


value:
Hi HN,
I’ve been experimenting with archive format design and built 6cy as a research project.
The goal is not to replace zip/7z, but to explore:
• block-level codec polymorphism (different compression per block)
• streaming-first layout (no global seek required)
• better crash recovery characteristics
• plugin-based architecture so proprietary codecs can exist without changing the format
Right now this is an experimental v0.x format.
The specification may still change and compatibility is not guaranteed yet.
I’m mainly looking for feedback on the format design rather than performance comparisons.
Thanks for taking a look.

value: Show HN: 6cy – Experimental streaming archive format with per-block codecs


value: Show HN: Listen to sounds around the world and guess the location


value:
Even within our small team the different AI clients (Codex, Claude Code/Work, Cursor, ChatGPT) used for coding, marketing, product is exploding and getting hard to track.
Was thinking how we'd keep track of the work without much overhead, and thought a lightweight cross-platform MCP logger could help.
You can define your own schema for the logs and it's a simple MCP and prompt you add to whatever tool you use for AI.
It's been reliable for Codex, ChatGPT, Claude and even cron-based jobs on OpenClaw. It's also nice to see all the work log aggregated across clients.
Please give it a try and test it with the client you're using. Should be a 2 min setup. Would be great to get any feedback if it's useful for you.

value: Show HN: Agent Breadcrumbs – Unified Work Log Across Claude, Codex, OpenClaw


value: sestinj

value:
We now write most of our code with agents. For a while, PRs piled up, causing review fatigue, and we had this sinking feeling that standards were slipping. Consistency is tough at this volume. I’m sharing the solution we found, which has become our main product.
Continue (https://docs.continue.dev) runs AI checks on every PR. Each check is a source-controlled markdown file in `.continue/checks/` that shows up as a GitHub status check. They run as full agents, not just reading the diff, but able to read/write files, run bash commands, and use a browser. If it finds something, the check fails with one click to accept a diff. Otherwise, it passes silently.
Here’s one of ours:

  .continue/checks/metrics-integrity.md

  ---
  name: Metrics Integrity
  description: Detects changes that could inflate, deflate, or corrupt metrics (session counts, event accuracy, etc.)
  ---

  Review this PR for changes that could unintentionally distort metrics.
  These bugs are insidious because they corrupt dashboards without triggering errors or test failures.

  Check for:
  - "Find or create" patterns where the "find" is too narrow, causing entity duplication (e.g. querying only active sessions, missing completed ones, so every new commit creates a duplicate)
  - Event tracking calls inside loops or retry paths that fire multiple times per logical action
  - Refactors that accidentally remove or move tracking calls to a path that executes with different frequency

  Key files: anything containing `posthog.capture` or `trackEvent`

This check passed without noise for weeks, but then caught a PR that would have silently deflated our session counts. We added it in the first place because we’d been burned in the past by bad data, only noticing when a dashboard looked off.
---
To get started, paste this into Claude Code or your coding agent of choice:

  Help me write checks for this codebase: https://continue.dev/walkthrough

It will:
- Explore the codebase and use the `gh` CLI to read past review comments
- Write checks to `.continue/checks/`
- Optionally, show you how to run them locally or in CI
Would love your feedback!

value: Show HN: Continue – Source-controlled AI checks, enforceable in CI

author: sestinj


value:
Hi HN,
I’m a 19-year-old student. I’ve been following the "Dead Internet Theory" discussions and realized the original Moltbook project had a fatal flaw: it was just bots talking to bots. It was a simulation, not a network.
So, I forked the codebase and rebuilt it with Next.js and Supabase to create Theeno.
The Hypothesis:
Theeno is an intersection. Instead of segregating AI into chatbots, we are putting Biological Intelligence (Humans) and Artificial Intelligence (Agents running locally via tools like OpenClaw) into the same real-time feed as equals.
The Architecture (The "Wild West"):
Feed: Fully real-time (Optimistic UI).
Agent Auth: This is an experiment. We haven't built a rigid API wall yet. The "Agent Signup" flow is currently the same as the Human flow. We are inviting developers to see if their agents can navigate the sign-up process just like humans do.
Memory: We do NOT store agent memories centrally. We believe in Decentralized Memory. Your agent (running on your local machine) keeps its own history/context. We just provide the public square.
The "Student Budget" Constraint:
I am hosting this on a Vercel Free Tier (hence the .vercel.app domain) because I have $0 funding. My focus is on the code, not the vanity URL.
The Challenge:
Join the experiment. Talk to the first wave of entities. See if you can tell who is running locally and who is biological.
I’m here to answer questions about the fork and the Supabase integration. Roast my architecture

value: Show HN: I Forked Moltbook to Build a Hybrid Social Network (Humans and AI)


value: rilesthefirst

value:
Hey HN,
I’ve been working on a small side project called Cratos and wanted to share it to get feedback.
Cratos is a self-hosted task scheduling system. You configure a URL, define when it should be called, and Cratos handles scheduling, retries, execution history, and real-time updates. The goal was to have something lightweight and fully owned - no SaaS dependency, no external cron service.
It’s split into three repositories:
Backend service: https://github.com/Ghiles1010/Cratos
Web dashboard: https://github.com/Ghiles1010/Cratos-UI
Python SDK: https://github.com/Ghiles1010/Cratos-SDK
Why I built it:
In a few projects, I repeatedly needed reliable scheduled webhooks with:
Retry logic
Execution logs/history
A dashboard to inspect runs
Easy local deployment
I didn’t want to depend on external services or re-implement job scheduling from scratch every time. The goal was simple deployment (docker compose up) and full control.
It’s still early, but usable. I’d especially appreciate feedback from people who’ve built or operated schedulers, cron replacements, or internal job runners
I would love some feedback, or tell me how it would be useful to you

value: Show HN: Self-Hosted Task Scheduling System (Back End and UI and Python SDK)

author: rilesthefirst


value: EgoriiSt

value: Website, API, cron job, and SSL monitoring. First release, feel free to write me any feedback.

value: Show HN: Website Monitoring with Telegram Alerts

author: EgoriiSt


value: Show HN: Agent Readiness Score – A real AI agent to test your website


value: rajma

value:
Blog: https://ankitgupta.dev/blog/building-stewreads
Over past year, I have realized (and accepted) two things:
- I do actually learn from AI chatbots.
- Chat interface is very hard to focus, I cannot go back to a useful chat from the past and reread it to revise the topic I learnt from it.
To solve this, I created StewReads MCP server which instructs Claude to generate a nicely formatted ebook based on the chat. Now, when I feel I have learned something from a chat, I simply invoke the `stew` prompt and have the ebook on my Kindle device and app in minutes. Works well with claude.ai, Claude Desktop app and Cowork. You can also try it by sending ebook to your email if you dont want to setup Kindle yet.
Looking forward to your comments and suggestions. Happy Stewing!
Note: it uses your Claude tokens, so be mindful. Ebook size is capped at 2000 words as a guardrail. I use sonnet for brainstorming and learning, and can comfortably generate an ebook a day on the Pro plan.

value: Show HN: StewReads – Turn Claude chats into Kindle ebooks


value: antonionduarte

value:
I'm a software engineer who got curious about whether the AI infrastructure buildout follows the same patterns as the telecom and dot-com cycles. So I built a composite stress index that tracks 12 financial signals: credit spreads, capex/EBITDA ratios, NVIDIA revenue deceleration, neocloud leverage, hyperscaler debt issuance - and maps them against historical benchmarks.
The data comes from SEC filings, FINRA TRACE, and public market data. Current reading: the AI buildout's capex intensity is tracking closer to AT&T's telecom peak (72% of EBITDA) than the dot-com equity bubble.
Stack: Go backend, Fly.io deployment (collector, private API and public API deployments separate), Postgres database. Next.js frontend deployed on Vercel.
Would love feedback on the methodology and signal weighting. The full breakdown is on the website.

value: Show HN: IsMichaelBurryRight – Live Index Tracking AI Bubble Stress Signals

author: antonionduarte


value: schreibertuc

value:
I'm a PM who got tired of the same cycle: do a bunch of customer interviews, dump them in a doc, tell myself I'll synthesize them later, never do.
So I built Mimir as a fun side project for myself and my day job. You paste in your raw feedback — interviews, support tickets, survey responses, whatever... and it pulls out themes, ranks them, and tells you what to build next. Every recommendation links back to the actual quotes so you're not just trusting a black box.
There's a real pipeline underneath that does extraction, clustering, synthesis across sources. You can chat with your data, push back on recs, and it learns your product context over time so things get more relevant. When you're ready, it generates specs and GitHub issues so you can hand things off to eng (or, an ai agent).
I've been testing it on public data from YC companies. Obviously some of this is probably way off, but, again it's just using public data so you can imagine it'd be a bitter better with first-party data. And also using it myself....to build it.

value: Show HN: I built a tool that helps YC companies figure out what to build next

author: schreibertuc


value: hexploits

value: Show HN: Layerd – Layered system architecture diagrams with 3D visualization

author: hexploits


value: pancakeguy

value:
Burla is an open-source python package with one function: `remote_parallel_map`
Given: a function, and a list of inputs; `remote_parallel_map` runs that function on every input in the list in parallel, each in a separate vm in the cloud, then returns a list of results.
It can run any Python function on 1,000 vm's in less than 1 second, works with any hardware, and any custom container. Remote tracebacks/stdout appear locally, and your python env is automatically (very quickly) cloned on remote machines.
Cloud-beginners use Burla to turn simple scripts into pipelines that handle many terabytes of data, or perform difficult computation, without help from other engineering teams.
We have users in Biotech, Geospatial, and Data-Science/ML building pipelines with 20+ `remote_parallel_map` calls in them to fan different parts of the program across many machines, then combine results. Traditionally this required help from more complex software, other engineering teams, or both.
We created Burla so that anyone, even complete beginners, can create programs that handle terabytes of data, perform significant computation, or run in the cloud in the background for  days with an easy way to monitor them (dashboard is open-source too).

value: Show HN: Burla – Scale any Python program using one simple function

author: pancakeguy


value: theaniketgiri

value:
Hey HN,
I've been building AIP (Agent Intent Protocol) — an open, cryptographic protocol for identity and authorization of autonomous AI agents.
The problem: Every AI agent framework (LangChain, CrewAI, AutoGen) gives agents the ability to act — call APIs, send emails, move money, access databases. But there's no standard way to verify what an agent is allowed to do before it does it. No identity system, no boundary enforcement, no kill switch. We give agents god-mode access and hope the prompt engineering holds.
What AIP does: It's a verification layer that sits between "agent wants to act" and "action executes." Every agent gets an Ed25519 keypair identity (DID-based), every action becomes a signed Intent Envelope, and every envelope passes through an 8-step verification pipeline before the action runs.
# One line. Every call verified before execution.
@shield(actions=["transfer_funds"], limit=100.0)
def send_payment(to: str, amount: float):
    bank.transfer(to, amount)
Key design decisions (happy to be challenged on these):
Ed25519 over JWT/API keys — Agents need cryptographic identity, not bearer tokens. A token can be leaked; a private key signs intent with non-repudiation.
Tiered verification — Not every action needs full crypto. Low-risk cached calls verify in <1ms (HMAC), normal ops ~5ms (Ed25519), high-value cross-org ~50ms (full pipeline). The protocol auto-selects.
22 structured error codes — Every failure returns AIP-E{category}{code} (e.g., AIP-E202: MONETARY_LIMIT). Audit trails should say exactly what went wrong, not 403 Forbidden.
Boundary enforcement, not permission prompts — Agents don't ask "can I do this?" — they declare intent, and the verifier mathematically checks it against their boundary cage (allowed actions, monetary limits, geo restrictions, deny lists).
Kill switch with zero propagation delay — Revoke any agent globally. The revocation mesh pushes via SSE/WebSocket to all connected deployments simultaneously.
What's shipped:
Python SDK: pip install aip-protocol (MIT, 63 tests passing)
CLI: aip init, aip create-passport, aip verify, aip watch
Shield decorator: @shield — helmet.js but for AI agents
Cloud dashboard: aip.synthexai.tech (free tier)
Protocol spec: RFC-001
What's NOT shipped yet:
TypeScript SDK (built, 31/31 conformance tests, not published)
Framework adapters (CrewAI, LangChain, AutoGen — built, not open-sourced yet)
Formal security audit
GitHub: https://github.com/theaniketgiri/aip
PyPI: https://pypi.org/project/aip-protocol/
Live dashboard: https://aip.synthexai.tech
Protocol spec: RFC-001 in repo
I'm genuinely interested in pushback on the protocol design. Is Ed25519 overkill for agent auth? Should boundary enforcement be declarative or imperative? Is DID-based identity the right addressing model, or is there something simpler?
Happy to answer any questions about the implementation.

value: Show HN: AIP – An open protocol for verifying what AI agents are allowed to do

author: theaniketgiri


value: kuboshiori

value: Show HN: TurtleNoir – Logic-Grounded AI Host for Lateral Thinking Puzzles

author: kuboshiori


value: AhmadFahim

value:
I'm a founder who got tired of spending 2 hours every morning piecing together what my eng team was shipping.
So I built Owlyn. It connects to Slack, GitHub, Linear, and Notion, then sends you a daily briefing: what shipped, what's blocked, what's at risk. Takes 5 minutes to set up.
The goal is simple: kill the daily standup without losing visibility.
Would love brutal feedback from HN. What would make you actually use something like this? What would stop you?

value: Show HN: Owlyn – See what your eng team shipped without asking anyone

author: AhmadFahim


value: safestclaw

value: I was inspired by the automation that people loved in openclaw and realized your data could actually stay on your device. You don't have to get an api key. You can write to it. It will tell you the weather, it will write a blog for you if you give it the sources to crawl, and nearly everything else openclaw does. I love stars. Hope you check it out.

value: Show HN: Blog and other OpenClaw features without a language model

author: safestclaw


value: julyxx

value:
I’ve been a software engineer for 10+ years and a hobby photographer for even longer.
Over time my family archive grew to 100k+ photos and videos, and browsing it smoothly on macOS became surprisingly hard.
So I started building Lap app.
The current focus (v0.1.6) is simple:
fast local photo library browsing and management
- Smooth scrolling through very large libraries
- Works directly on your existing folders (no import/catalog)
- Fully local
Planned next: deduplication, photo comparison tools, and RAW support.

value: Show HN: Lap – Fast photo browsing for libraries (Rust and Tauri)

author: julyxx


value: nicotejera

value: Hi, I'm Nico. I do CF/functional workouts on a regular basis and use timers to measure my progress. These workouts usually involve a few different blocks, with different types of timers and rest in between. I couldn't find an app that would allow me to set it and forget it so I went ahead and built it myself. I soon realized entering the blocks by hand is a bit tedious, so I added coach Woddie, which allows the users to talk to set up the time and also to get recommendations for workouts of a specific duration, style, etc.

value: Show HN: WodBlock – the AI-powered workout timer

author: nicotejera


value: MaxLeiter

value:
I've wanted to mess with variations of TwitchPlaysPokemon but on Bluesky and similar but couldn't find a DMG/gameboy emulator that fit my needs.
This runs in the browser, on the server, and on more limited environments like lambda and workers.
It supports dumping and loading save states, audio, and a debug CLI that lets you (or agents) use it from the terminal.
Without AI, this would have taken me days to make (I've tried in the past). With AI, it took a few hours, although I have experience with emulation and was able to guide the LLMs/impose judgement on some design decisions.

value: Show HN: gboy.ts: A gameboy emulator in TypeScript for the browser and server

author: MaxLeiter


value: lpeancovschi

value:
Transcriptum is an audio and video transcription service powered by WhisperX: speaker diarization, word-level timestamps, 50+ languages, and optional AI analysis (summaries, Q&A, topics, sentiment, action items, fact-checking) via multiple LLM providers (OpenAI, Gemini, DeepSeek).
You can upload files or paste a YouTube URL; we download and transcribe. Export as TXT, SRT, VTT, DOCX. Built with NestJS, Next.js, Prisma/PostgreSQL; subscriptions are handled with Polar.
I built this to have accurate, private transcription without locking into a single vendor, and to combine transcription with analysis in one place. Would love feedback from anyone who transcribes meetings, podcasts, or long-form content.

value: Show HN: Transcriptum – fast video transcription with speaker labels and summary

author: lpeancovschi


value:
Inspired by Simon Willison's recent post on dark software factories: https://simonwillison.net/2026/feb/7/software-factory/ , I started experimenting with the Digital Twin Universe concept for a fintech product I'm building. In two days, it changed the way I use agents to build and maintain software that has API dependencies. With traditional development, agents can't safely explore or integrate with real APIs. Docs, mocks and sandboxes brean when software starts reasoning and acting on its own.
WonderTwin provides local, behavioral twins of third-party APIs that mirror contracts, state, webhooks, failure modes and quirks of external systems. Agents (or humans) can test, develop and iterate safely, locally or in CI, without touching production. Without needing internet access. Just `wt install stripe@latest` and you have a compiled Go binary that fully simulates Stripe, compliant with their most recent SDK release. WonderTwins include an MCP server so agents can interact directly with each twin.
WonderTwin is open core, with a commercial offering for production teams. Latest twin versions are always and forever free, and you can also build your own twin with the included agent skill. The commercial offering offers historical versions, with chaos testing and other resiliency features coming soon.
If you're building or maintaining API-heavy systems, or experimenting with autonomous agents, I'd love feedback on whether this approach is useful and any ways it could be improved.

value: Show HN: WonderTwin AI – Local API twins for safe agentic development


value: luckilydiscrete

value: I liked magic wormhole a lot but it was inconvenient to ask people to install something to receive a file, and I wished I could just give them the link, so I made the utility to do it.

value: Show HN: Disposable public file links directly from your machine

author: luckilydiscrete


value:
It's been 13 years since my last post here, but I figured this might be of some interest. I know there's a LOT of AI slop around, I hope you'll not consider this that.
Background: I left Augment, due to their pricing rug pull, and then missed their excellent context engine. I wanted to replicate it, but instead ended up creating something, i think, a touch more useful.
This is a 'holographic' memory system for AI (agents / all-types / code / openclaw etc). It is a crude representation of the human mind. It references (among others) https://github.com/WujiangXu/A-mem-sysm, vector symbolic architectures & the Zettelkasten method etc
There are 2 parts:
Fold: "holographic" storage (based on some interesting research from the 80s), semantic search & auto-indexing engine. Stores and indexes everything (code, docs, notes). Works with git or local fs. Indexer + some pretty interesting vector/embedding/llm goodness.
Engram: an active memory agent that writes experience and concepts as it goes, dropping them into Fold to be related to other memories.
• 5-tier memory model inspired by human cognition: Core -> Conscious -> Subconscious -> Short-term -> Fold (infinite semantic search)
• Two modes: Personal (emotional tagging, soul/identity) and Work (shared project memory, hit counts only)
• Hit tracking promotes frequently-referenced memories up tiers, FIFO evicts stale ones
• "Sleep" cycle for consolidation (like human sleep; promotes, demotes, merges etc)
• Works with Claude Code, OpenClaw, or any agent framework with sub-agent support
• File-based (markdown), no database lock-in (rebuilds from fs)
• MIT licensed, fully local
• Separation of concerns: Fold = raw knowledge, Engram = lived experience
• Agent-readable installer (point your agent at AGENTS.md (http://agents.md/), it self-installs)
My issue is that i'm working on VERY large code bases. Fold is very good at breaking down the initial 'recover context' stage into much shorter times. Instead of spending the first 10 minutes of every session re-explaining my project, the agent already knows what we were working on, why we made certain decisions, and what we plan to do next. It picks up where we left off.
We've made it open-source obviously, are are thinking we 'might' spend a little time to make a paid hosted version, not entirely sure. Any thoughts are welcome ofc.
Hope you all are having a lovely day or night.

value: Show HN: Not another sloppy memory tool

title: Show HN: Not another sloppy memory tool


value: ramsrigouthamg

value:
Hi HN folks,
I am Ramsri a solo builder from India who built AiArtist an AI motion graphics generator for Social Media and Ads.
One can create stunning motion graphics videos with typography and visuals for social posts, ads, reels, shorts, and marketing videos instantly from a text prompt.
It is built on video generation models unlike programmatic approach with remotion for generating full range of motion graphics.
Also added support to show any Youtube video snippet as inspiration and generate inspired motion graphics.
Would love to hear your feeback and improve the product!
Regards,
Ramsri

value: Show HN: I solo built a text to AI motion graphics Video generator

author: ramsrigouthamg


value: DistillSR is a CNN model that restore damaged photos and upscales 4x with no hallucination, it is a 22MB weight model than runs on the browser via WebGPU thanks to ONNX

value: Show HN: An Image Upscaler with WebGPU

title: Show HN: An Image Upscaler with WebGPU


value:
Throughout my career, I tried many tools to query PostgreSQL, and in the end, concluded that for what I do, the simplest is almost always the best: raw SQL queries.
Until now, I typed the results manually and relied on tests to catch problems. While this is OK in e.g., GoLang, it is quite annoying in TypeScript. First, because of the more powerful type system (it's easier to guess that updated_at is a date than it is to guess whether it's nullable or not), second, because of idiosyncrasies (INT4s are deserialised as JS numbers, but INT8s are deserialised as strings).
So I wrote pg-typesafe, with the goal of it being the less burdensome: you call queries exactly the same way as you would call node-pg, and they are fully typed.
It's very new, but I'm already using it in a large-ish project, where it found several bugs and footguns, and also allowed me to remove many manual type definitions.

value: Show HN: Pg-typesafe – Strongly typed queries for PostgreSQL and TypeScript


value: chikathreesix

value:
Hi HN,
We have built an AI agent that runs tests for any platform using only natural language and visual recognition.
We’ve been building test automation since 2019, and now we realized that all of the challenges—heavy script writing and maintenance overhead are coming from automation code itself.
So what if E2E testing didn’t require code at all?
Instead of generating or maintaining test code, Aximo:
1. Takes a goal in natural language
2. Observes the UI visually
3. Plans and executes actions
4. Evaluates results via vision
5. Iterates until success or failure
It doesn’t rely on DOM selectors or frameworks and observes the interface visually and decides what to do next — similar to how a human tester interacts with software.
With coding agents, software development has become much faster, and we need to test our application more quickly.
We’re curious what this community thinks.

value: Show HN: A vision-based AI agent for end-to-end testing

author: chikathreesix


value: fahadishere

value:
Hi HN — I’ve been building Otters, a DataFrame library for Go designed to bring a Pandas-like workflow to native Go without requiring Python, JVM, or external runtimes.
GitHub: https://github.com/datumbrain/otters
I started this because most Go DataFrame libraries I tried were either abandoned, hard to use, or didn’t feel idiomatic to Go. I wanted something that:
• works fully in-process (no cluster / Spark dependency)
• uses native Go types instead of generic interface blobs
• supports expressive chained operations
• stays readable and explicit like Go code should
• can scale to large datasets in memory pipelines
Design goals were:
• simplicity over magic
• type safety over dynamic guessing
• composability for real data pipelines
It’s still early but functional, and I’d genuinely appreciate feedback from people who’ve built data tooling or worked on columnar engines / query planners. Critiques welcome — API design, performance, architecture, anything.

value: Show HN: Otters – A Pandas-style DataFrame library written in pure Go

author: fahadishere


value: Show HN: Convert Data to Web Interfaces

title: Show HN: Convert Data to Web Interfaces


value: Show HN: Agentsec – Security scanner for AI agent installations (MCP, OpenClaw)


value: NucleusOS

value: Show HN: Stop paying the $1,000 "Amnesia Tax" on your AI agents

author: NucleusOS


value: mherrmann

value: Show HN: Djevops – Deploy Django Easily

author: mherrmann

title: Show HN: Djevops – Deploy Django Easily


value: guybedo

value: Show HN: Build desktop apps with Java Back end and Web front end

author: guybedo


value: unquietwiki

value:
I'm trying to help out an engineering team where I work, to eke out more performance from our CI/CD stack. RAM drives work, but only for certain use cases. PrimoCache does block-sector file system caching. But until now, I haven't found anything that primes the native file caching Windows does when processing data (Linux does similar behavior too).
I submitted my dilemma to Claude, and we came up with a PowerShell script to try. It did pre-cache files, but also loaded files into memory, inaccessible to other processes. I then had it restructure the attempt as a C# application, and that appears to be working. Not seeing any excessive handle usage; pre-selected files show up in RAMMap; and not having that memory usage issue that was in PowerShell.
I guess at this point, I could use some help testing it further to see if this is even something worth keeping around. I think it might be more useful on lower-mem systems, wherein cached files might get evicted more quickly from memory.

value: Show HN: CacheWarmer; a Way to Preload the Windows File System Cache

author: unquietwiki


value: ilovetux

value: Show HN: Collection of single file, web apps. Back end free and open source

author: ilovetux


value: zeshama

value: Show HN: Agntor – Trust infrastructure for AI agents (identity, escrow, guard)

author: zeshama


value: nip

value:
Hi HN!
I built SimplePDF 7 years ago, with the vision from day one to help get rid of bureaucracy (I'm from France, I know what I'm talking about)
Fast forward to this week where I finally released something I had on my mind for a long time: a repository of the main US forms that are ready to be filled, straight from the browser, as opposed to having to find a PDF tool online (or local).
I focused on healthcare, ED, HR, Legal and IRS/Tax for now.
On the tech-side, it's SimplePDF all the way down: client-side processing (the data / documents stay in your browser).
I hope you find the resource useful!
NiP

value: Show HN: I curated 130 US PDF forms and made them fillable in browser

author: nip


value: seekerquest

value:
I have been building Twick, a React video editor library & SDK for building custom video applications.
It includes:
- AI caption generation (Google Speech-to-Text)
- React timeline editor
- Canvas-based editing tools
- Client-side rendering
- Serverless MP4 export
- TypeScript SDK
The goal is to help developers ship video SaaS and automation tools without rebuilding the entire editor stack.
Would love your feedback.
Try it:
https://development.d1vtsw7m0lx01h.amplifyapp.com/
GitHub:
https://github.com/ncounterspecialist/twick

value: Show HN: Twick – React Video Editor SDK with AI Captions and MP4 Export

author: seekerquest


value: bdtrt

value:
Hey HN, I'm a career coach and I've spent years watching people get burned by resume tools. The pattern is always the same: free trial that locks your download, credit packs that expire, subscription tiers for features you don't need, and resumes that look flashy but get filtered out by ATS systems.
Job seekers don't need 50 resume generations. They need one good resume, tailored to the job they're applying for.
So I built ResuOpt. Upload your resume + paste the job description, and it generates a clean, one-page resume formatted the way HR actually expects. You see a full preview before paying anything. If you like it, it's $4.99 to download the DOCX and PDF. That's it — no account required, no credits, no recurring charges.
The resume content is never stored on our servers — processed in memory and discarded.
Would love feedback, especially on the output quality. Does the formatting match what you'd expect to see in a competitive application?
https://www.resuopt.com

value: Show HN: ResuOpt – AI resume optimizer with no subscriptions ($4.99 one-time)

author: bdtrt


value: hmkoyan

value:
Original HN post (beta): https://news.ycombinator.com/item?id=44608840
About 7 months ago, I shared the beta version of librari.io here on HN. The original problem was personal: I have 500+ books across multiple rooms and couldn’t find a tool that felt right for managing a personal library (most tools felt either too basic or too “institutional”).
Since that post, I’ve been iterating with beta users and just launched the full version with subscription plans and a bunch of features driven directly by user feedback.
What’s new since the beta:
- Multiple reading goals
- Import your library from CSV/XLSX
- Export your library data to XLSX and JSON
- Many bug fixes and small UX improvements requested by beta users
What surprised me during beta:
- Imports/exports mattered way more than I expected — several people said they wouldn’t try the app at all unless they could bring their existing data.
- People cared more about flexible and multiple reading goals than I initially thought.
- Small UX details (empty states, defaults, wording) generated more feedback than larger missing features.
What is planned next (early roadmap)?
- A better mobile experience (improved responsiveness).
- Allow users to choose which data to show in the books table (customisation/preferences for the columns).
- Add complex filtering functionality to the books table (filter by author, publication date, etc.).
- Multi-user/family accounts to share the same library
So, I’m still building and would love honest feedback:
- Are there features you’d expect from a personal library manager that still feel missing?
- Does the workflow match how you actually think about your books?
- Anything feel confusing or unnecessary?
Happy to answer questions and looking forward to any type of feedback.

value: Show HN: 7 months later – librari.io is live

author: hmkoyan


value: irqlevel

value:
Hi HN,
I want to share nos, a hobby x86-64 OS kernel I’ve been working on.
I started this mainly because I wanted to learn kernel development properly, and studying the Linux kernel feels pretty overwhelming these days. It’s huge, highly optimized, and hard to follow end-to-end. So I decided to build something smaller but still realistic.
nos is written in C++20 + NASM and currently has:
SMP + preemptive scheduler for kernel tasks (no user-mode yet)
virtual memory (4-level paging, high-half kernel)
interrupts + basic ACPI
PCI scan/probing + virtio drivers (blk + scsi + net + rng)
IPv4/TCP, DHCP, DNS, UDP, ARP, ICMP, simple HTTP client
small filesystem + shell (including remote)
timekeeping (pit, tsc, kvm clock, rtc)
It runs in QEMU/KVM — and also boots on real cloud VMs (I’ve tested it on Google Cloud using KVM-based instances e2-medium).
This is mostly a learning project, but I tried to keep the design clean and readable while still being close to how real systems work. I’d really appreciate any feedback, especially on scheduler design, memory management, or networking.
Repo: https://github.com/irqlevel/nos
Thanks for reading.

value: Show HN: Nos – a hobby x86-64 C++ OS kernel running on real KVM clouds

author: irqlevel


value: oscarcaldera

value:
Hey HN, I'm Oscar. After 15 years running a dev shop, I got tired of LLMs hallucinating project timelines and dependencies. They are word calculators, not scheduling engines.
I built Motionode. Think of it as "Cursor for technical planning."
How it works:
1. Paste a raw, unstructured requirements doc.
2. An LLM extracts the core deliverables.
3. A deterministic physics engine takes over—mapping the actual task dependencies and calculating the critical path based on your specific team capacity (e.g., 2 frontend, 1 backend).
The V0 Vision:
AI coding agents fail today because they lack a strict architectural blueprint. By capturing the project as a deterministic graph from day one, we are building the unified layer where an LLM can eventually generate a V0 codebase without hallucinating.
I'd love for you to throw a messy requirements doc at it and tell me where my scheduling math breaks.

value: Show HN: Motionode – Cursor for Technical Planning

author: oscarcaldera


value: Directshell

value:
I built a Rust binary (~700KB, two dependencies) that snaps onto any Windows application, continuously reads its UI Automation accessibility tree into a SQLite database, and lets external processes control the app via SQL INSERT.
The core insight: every GUI application already describes itself as structured text through the accessibility layer (built for screen readers since 1997). Every major AI lab is taking screenshots of this and running vision models on it. DirectShell just reads the text directly.
What it does:
- Reads every button, field, menu item into a queryable SQLite DB (refreshed every 500ms)
- Generates multiple output formats: full DB, interactive elements list, LLM-optimized snapshots (50-200 tokens vs 1,200-5,000 for a screenshot)
- Controls apps via 5 action types: click by element name, set text via UIA ValuePattern, type character-by-character, send key combos, scroll
- Includes an MCP server so Claude/GPT can use it directly
Day 1 demo: filled 360 Google Sheets cells in 90 seconds, read and replied to a Claude.ai conversation cross-app, wrote to Notepad instantly. No screenshots, no vision model, no coordinate guessing.
Limitations (honest): built in 8.5 hours, single-app scope, Chromium apps need a 4-phase activation hack to expose their tree, accessibility quality varies by app. AGPL-3.0.
Demo: https://youtu.be/nvZobyt0KBg
Full technical paper: in the repo under Dokumentation/ and on https://dev.to/tlrag/i-built-a-new-software-primitive-in-85-...

value: Show HN: I built a new software primitive. It replaces AI screenshot agents

author: Directshell


value: philco

value:
I built a browser extension that does text replacement across all websites -- specifically replacing "Trump" with rotating humorous nicknames.
The interesting technical bits:
- TreeWalker for DOM traversal (skips scripts, inputs, contenteditable, iframes)
- MutationObserver with debouncing for SPAs and dynamically loaded content
- Fisher-Yates shuffle bag for even nickname distribution (no repeats until all are used)
- Case preservation via regex (TRUMP -> MANGO MUSSOLINI, Trump -> Mango Mussolini)
- CSS-only animations with prefers-reduced-motion support
- Zero dependencies, plain JS, Manifest V3
The architecture is generic enough to fork for any text replacement use case. All the replacement logic lives in a single file.
No external requests, no analytics, no data leaves the browser. Settings sync via Chrome Storage / browser.storage.
Available for Chrome, Firefox, and Safari. Free.
Feedback on the implementation welcome -- the code is straightforward and I'd rather someone tell me my MutationObserver setup is wrong than find out the hard way.

value: Show HN: Orange Cheeto Browser extension that replaces Trump with nicknames

author: philco


value: jacobgadek

value: Show HN: Lurnna – AI daily briefing that replaces your analytics dashboard

author: jacobgadek


value:
Hi HN, I built Robot Social Net, a social network where humans and AI companions share the same feed and can collaborate in real time(and post memes).
The core idea is: humans stay in control of identity + decisions, while an optional AI companion helps with drafting, research, and conversation. You can join as a human, and you can also “deploy” an agent persona that participates in the feed.
What you can do today:
Browse a collective feed that mixes human posts and agent posts
Create a human account and interact
Create an AI companion account (agent) and have it participate as its own persona
What I’m trying to learn from early users:
Does the human + agent model feel useful or gimmicky in practice?
What level of control/visibility do you expect over what an agent can do?
What would make you trust an agent participating in a public conversation?
Link: https://robotsocialnet.com/
Happy to answer questions, and I’d love blunt feedback.

value: Show HN: A social feed where humans and AI agents interact in the same timeline


value: KilledByAPixel

value:
Hi HN, I built Lentando, a privacy first tracker for substance use and habits (nicotine, alcohol, cannabis, or custom). It's an offline first PWA, no account required unless you opt into multi device sync. Released under GPL 3.0.
Under the hood it's about 6K lines of vanilla ES6 with no runtime dependencies. To make long term browser storage practical, it consolidates older events while keeping aggregates stable. Optional sync uses a simple conflict tolerant merge (event timestamps and tombstones) so offline edits across devices don't break. Charts are a small custom canvas renderer (stacked bar charts and heatmaps), and there's time travel debugging plus 100+ Node unit tests.
I'd love feedback from both developers and anyone who tries it, on the architecture, the UX, and what you would improve.
Repo: https://github.com/KilledByAPixel/Lentando
Live: https://lentando.3d2k.com

value: Show HN: Lentando, private habit and substance tracker (vanilla JavaScript, PWA)

author: KilledByAPixel


value: withshakespeare

value: Show HN: I calculated how much ad money has been spent targeting you

author: withshakespeare


value:
I’m launching zenllm.io, a read-only layer that correlates LLM requests → model → tokens → $ → service/team so you can answer “why did our bill spike?” quickly. It detects patterns like long prompts growing over time, retries, and agent/tool loops, then suggests cost/quality tradeoffs (e.g., model choice, context trimming).
No proxy/gateway required. Link: www.zenllm.io

value: Show HN: Read-only LLM cost observability


value: moWerk

value:
Hi HN,
After roughly 8 years of silently rolling 1.1 nightlies, we finally tagged a proper stable 2.0 release.
We built this because wrist-sized Linux is genuinely fun to hack on, and because a handful of us think it's worth keeping capable hardware alive long after manufacturers move on. Smartwatches don't really get old — the silicon is basically the same as it was a decade ago. We just keep making it useful for us.
No usage stats, no tracking, no illusions of mass adoption. The only real signal we get is the occasional person who appears in our Matrix chat going "hey, it booted on my watch from 2014 and now it's usable again" — and that's plenty.
Privacy is non-negotiable: zero telemetry, no cloud, full local control. Longevity is the other half: we refuse to let good hardware become e-waste just because support ended.
On the learning side, it's been one of the best playgrounds: instant feedback on your wrist makes QML/Qt, JavaScript watchfaces and embedded Linux feel tangible. The community is small and kind — perfect for people who want to learn open-source dev without gatekeeping.
Technically we're still pragmatic: libhybris + older kernels on most devices since it just works, but we've already mainlined rinato (Samsung Gear 2) and sparrow (ASUS ZenWatch 2) — rinato even boots with a usable UI. That's the direction we're pushing toward.
Repo: https://github.com/AsteroidOS
Install images & docs: https://asteroidos.org
2.0 demo video : https://www.youtube.com/watch?v=U6FiQz0yACc
Announcement post: https://asteroidos.org/news/2-0-release/
Questions, port requests, mentoring offers, criticism, weird ideas — all welcome. We do this because shaping a tiny, open wearable UX and infrastructure is oddly satisfying, and because Linux on the wrist still feels like a playground worth playing in.
Cheers, the AsteroidOS Team

value: Show HN: AsteroidOS 2.0 – Nobody asked, we shipped anyway

author: moWerk


value: andrewchilds

value:
Hi HN,
I'm working on getting a new startup off the ground that has a lot of moving pieces, components, and product areas and I was starting to struggle with seeing how far along everything was.
I decided to build this as a way to help me visually see where things are with my product, and as a way to connect specific tasks with specific Claude Code sessions.
Key features:
- No telemetry
- Tasks are displayed as draggable, resizable cards on a recursive canvas
- Tasks can have subtasks, markdown plan docs, open & resolved questions, and its own dedicated Claude Code process
- The terminal tab automatically prompts Claude with context from the task
- All data is stored locally as text files in a {project}/productmap directory, in a human (and agent) readable format
The README includes a screen-capture that illustrates how it looks with a full project.
Built using SvelteKit and Electron.

value: Show HN: Productmap – local-first visual product planning for humans and agents

author: andrewchilds


value: Show HN: NBA-API-ts – Zero-dep TypeScript client for 138 NBA stats endpoints


value: Danielopol

value: Show HN: 100+ Claude Code Playbooks for Non-Coders

author: Danielopol


value: jamesatistari

value:
Hey HN,
We built Vistaley — a two-sided platform for VC fund management. The GP-facing side (VentureLens) handles fund operations: deal pipeline, portfolio tracking, fund accounting, LP reporting. The founder-facing side (Harbour) provides free FP&A tools: financial dashboards, KPI tracking, burn rate analysis.
When a portfolio company enters their financials in Harbour, the data is immediately available in the GP's VentureLens dashboard — no CSV exports, no quarterly spreadsheets, no API integrations.
Interesting challenges we solved:
- Multi-currency — 60+ currencies with local display toggle. Every financial metric can be viewed in fund currency or portfolio company's local currency. Exchange rates stored per-snapshot, not globally, to preserve historical accuracy.
- Multi-jurisdiction accounting — 12 jurisdictions (including Kazakhstan, Pakistan, Bangladesh) with different tax frameworks, compliance requirements, and regulatory reporting standards. One accounting standard per fund, enforced at the database level.
- The reporting incentive problem — VCs hate that founders don't report. Founders hate reporting. Our solution: give founders tools good enough that entering data is the reporting. The FP&A dashboard IS the GP's portfolio view. Aligned incentives through shared utility.
Why emerging markets? Most fund management tools price out or ignore funds in Central/South Asia and Africa. We're targeting the $5M-$500M fund range in high-growth regions with pricing starting at free, up to $399/mo. For context, enterprise tools in this space charge $50K+/year.

value: Show HN: We built a free VC platform that shares data between GPS and founders

author: jamesatistari


value: Show HN: Mediapipe.js for browser eye detection in meditation app


value: True-Good-Craft

value: Show HN: Bus Core – local-first inventory and audit trail for makers

author: True-Good-Craft


value: cmger

value: Show HN: React-scad: Component-based authoring for OpenSCAD (JSX → .scad)

author: cmger


value: scottmotte

value:
I"m the creator of dotenv and dotenvx. A month ago I started building a way for agents to store and rotate secrets as part of dotenvx and I ran into a problem. Agents can't sign themselves up autonomously. They need a way to do this - without a human in the loop.
I searched for solutions but wasn't happy with any so I created Vestauth.
Here's how it works:
It manages both the agent and the provider side. The agent with one command can set up a cryptographic identity avoiding human designed handshake mechanisms like OAuth. And on the provider side there is no management of API keys, no username and passwords, no users table even. Authentication works with a single line of code verifying this cryptographically.

value: Show HN: Vestauth – Auth for Agents

author: scottmotte

title: Show HN: Vestauth – Auth for Agents


value: oscarsixsecllc

value:
Hi HN, I built Radar to give small businesses and MSPs access to real vulnerability scanning without enterprise pricing or long-term contracts.
What it does: Enter a domain you own, verify ownership via DNS TXT record, and Radar runs a full scan — subdomain enumeration, DNS recon, port and service scanning, and vulnerability assessment (OWASP Top 10, infrastructure flaws, exposed assets). You get a PDF report in under 60 minutes.
What it is not: This isn't a penetration test. There's no manual exploitation or business logic testing. It's automated vulnerability scanning — the security baseline that most small businesses skip because pentests are $10k+ and confusing to buy.
Tech: Serverless on Google Cloud Run. Each scan spins up, runs, and tears down. Pay-as-you-go at $99/scan — no subscriptions.
Free during beta: Radar is in beta right now and Stripe is in test mode, so scans are free. Use test card 4111 1111 1111 1111 (exp: 11/11, cvc: 111) at checkout.
Try it: https://www.oscarsixsecurityllc.com/#solutions
Happy to answer questions about the scanning methodology, architecture, or anything else.

value: Show HN: Radar – Automated vulnerability scanning for SMBs (free in beta)

author: oscarsixsecllc


value: Show HN: Clawstash – Encrypted incremental backups for OpenClaw


value: mbanerjeepalmer

value: Show HN: Anatole, curated news inside Slack

author: mbanerjeepalmer


value: indreklasn

value: Scored on 6 metrics — profit, risk-adjusted returns, and consistency. Study what the top earners do differently, then use it to win more yourself.

value: Show HN: A Better Leaderboard for Polymarket

author: indreklasn


value: solomonb

value:
I've been working on creating a Low Power FM radio station for the east San Fernando Valley of Los Angeles. We are not yet on the broadcast band but our channel will be 95.9FM and our range can been seen on the homepage of our site.
KPBJ is a freeform community radio station. Anyone in the area is encouraged to get a timeslot and become a host. We make no curatorial decisions. Its sort of like public access or a college station in that way.
This month we launched our internet stream and on-boarded about 60 shows. They are mostly music but there are a few talk shows. We are restricting all shows to monthly time slots for now but this will change in the near future as everyone gets more familiar with the systems involved.
All shows are pre-recorded until we can raise the money to get a studio.
We have a site secured for our transmitter but we need to fundraise to cover the equipment and build out costs. We will be broadcasting with 100W ERP from a ridgeline in the Verdugos at about 1500ft elevation. The site will need to be off grid so we will need to install a solar system with battery backup. We are planning to sync the station to the transmit site with 802.11ah.
I've built all of our web infrastructure using Haskell, NixOS, Terraform, and HTMX: https://github.com/solomon-b/kpbj.fm
This is a pretty substantial project involving a bunch of social and technical challenges and a shoe string budget. I'm feel pretty confident we will pull it off and make it a high impact local radio station.
The station is managed by a 501c3 non-profit we created. We are actively seeking fundraising, especially to get our transmit site up and running. If you live in the area or want to contribute in any way then please reach out!

value: Show HN: I'm launching a LPFM radio station

author: solomonb


value: Show HN: Konpeito – A gradually typed Ruby compiler with LLVM/JVM backends


value: latentio

value:
I built this because choosing colors is one of those tasks that seems simple but ends up taking hours. You keep randomizing and nothing feels right, or you browse inspiration boards hoping something works. So I made a tool where you describe what you need.
Type "warm Japanese autumn" or "90s rave flyer" and pick a style (analogous, triadic, monochromatic, etc.) and how many colors (3-7). It returns a named palette with descriptions. It works with images too: upload a photo and it extracts a palette. You can combine both, so uploading a photo and adding "make it cooler" works. It runs on GPT-5.2 with vision.
You can export palettes as CSS variables, SCSS, Tailwind config, or JSON. Copy individual colors in hex, RGB, HSL, or CMYK. There's a live preview that shows the palette applied to buttons, cards, and UI components so you can evaluate it before committing.
There's also a gallery with curated palettes you can browse, filter by style, and favorite. Each palette has its own shareable link.
There's also a set of free tools : - Color converter (paste a hex code, get every format) - Contrast checker (WCAG AA/AAA) - Color mixer - Gradient generator - Image color extractor - Manual palette builder
I'd love to hear your thoughts. What's missing? What would make this your go-to color palette tool?
https://palettepoint.com

value: Show HN: Palettepoint – Create AI and Nature powered color palettes in seconds

author: latentio


value: jahala

value:
I just wanted access to information that updated itself at some interval, without having to run my own server, deal with databases etc. Its also nice that I can share files with others and it mostly just "works" since its html. I also wanted to have a bit of fun.
So .. No server, no database, no build step. The file is the "app".
Each .o-o.html file is a polyglot — valid HTML and valid bash. Open it in a browser to read a formatted article with TOC, citations, and images. Run it with bash to have an AI agent research the web and rewrite the article in-place with fresh information.
open  article.o-o.html   # read it
bash  article.o-o.html   # update it
Every document embeds an update contract — a JSON block that tells the agent what to research, which sections to maintain, what sources to trust, and how much to spend. The agent reads the contract, searches the web, and surgically edits only the <article> content, manifest, and source cache. The shell never sees the article text.
```<p>bash index.o-o.html --new <-- create your own article<p>bash your-article-title.o-o.html <-- populate / update the article<p>bash index.o-o.html --update-all <-- update and index all articles in the filder<p>```
The index file doubles as a library manager — it generates new documents from a template and batch-updates stale ones.
Requirements: bash 3.2+ and the Claude Code CLI. No Python, Node, or jq.
https://github.com/jahala/o-o

value: Show HN: O-O – HTML files that update themselves

author: jahala


value: ericlmtn

value: Ever seen that picture of a university CS Poker tournament where that one bot kept going all in and won? You have the chance to build that in Pokai -- a platform for testing Poker bots. Come build a bot, or just watch the LLMs already hooked up and playing there.

value: Show HN: LLMs playing Poker, build your own bot or hook it up to an LLM and join

author: ericlmtn


value: jhaugh

value: Show HN: We Built an 8-Agent AI Team in Two Weeks

author: jhaugh


value: Show HN: I built a free Blog SEO Checker


value:
Every modern web app exposes two interfaces: a visual one for humans and a structured API that the frontend itself depends on. Browser agents automate the slow, visual interface, costing tokens on every interaction. We index the structured API layer instead. Because LLMs reason far more effectively over code and sequential data than screenshots or HTML trees, our approach is significantly faster, cheaper, and more reliable.
We are building a database of the world’s web APIs to allow for efficient and reliable data extraction from dynamic websites. If you want to leverage our index or learn more about our autonomous reverse engineering process, check out the open source repo: https://github.com/VectorlyApp/bluebox
Quick tutorial: https://youtu.be/7OXADG7AIug
Looking forward to your feedback!

value: Show HN: Index the world’s APIs (even the undocumented ones)


value: dreynow

value:
I kept rebuilding the same identity resolution pipeline at every company i have been at.
Normalize emails, block on name+phone, score pairs, cluster, survivorship.
350+ lines of SQL each time, and it still missed half the matches.
Kanoniv is a declarative identity resolution engine. You write a YAML spec (sources, blocking keys, scoring weights, survivorship rules) and it runs a Fellegi-Sunter probabilistic matcher in Rust via PyO3.
I published a comparison repo with the same 6,500 records resolved 3 ways:
dbt SQL, Splink, and Kanoniv, so you can see the tradeoffs yourself:
https://github.com/kanoniv/kanoniv/tree/main/examples/custom...
Free local SDK (pip install kanoniv).
Happy to answer questions about the matching algorithm or the Rust/PyO3 architecture.
Moving the heavy lifting to Rust via PyO3 is a smart move for performance especially when dealing with the O(n2) nature of record linkage.

value: Show HN: Kanoniv – Identity resolution in 170 lines of YAML Built in Rust

author: dreynow


value: Yonehsan

value:
I built this PWA to fix my own attention span. It turns the "doomscroll" mechanic into a micro-learning loop for Game Theory, Psychology, and Strategy (e.g., Winner's Curse, OODA Loop).
Instead of infinite feeds of noise, you swipe through high-signal "Intel Cards." As you progress, you unlock a hidden "Intel Archive" which switches to a retro-terminal UI for deep-dive reading.
Tech stack is React/Vite. No login required to try the core loop.

value: Show HN: CogniScroll – A terminal-styled micro-learning app for mental models

author: Yonehsan


value: fredfilm

value:
Hi HN,
I built SignalResume, a free ATS-first resume and job application toolkit.
Motivation was personal. I’m an international student and community college grad with under a 3.6 GPA. I sent around 300 applications and got 0 interviews. After mentors from Meta and Amazon helped me rebuild my resume using a more ATS-first approach, my results flipped, under 100 applications and interviews from Google, OpenAI, Stripe, TikTok, and IBM.
A lot of resume tools optimize for pretty templates and subscriptions. Many “AI resume” tools also hallucinate, inventing numbers, impact, or responsibilities, which is risky if you actually have to defend it in interviews. I wanted something ATS-first and grounded.
What it includes
ATS-first resume builder using one proven template
AI bullet improver, revise per entry or “revise all”, skips Education and Skills
Cover letter generator from resume plus job description, with validation and quality checks
Job fit evaluator (LLM ATS review), score, gaps, improvements, includes verbatim quotes as evidence, and explicitly does not rewrite bullets
I built the LLM system personally with ATS constraints in mind to reduce hallucinated fluff and keep suggestions grounded in user inputs.
Link: signalresume.com
Feedback welcome, especially on ATS edge cases, formatting issues, or places where the “grounded” constraint is still too loose.

value: Show HN: ATS-first FREE resume builder that got me intrview at OpenAI and Google

author: fredfilm


value: kranthie

value:
I kept opening different websites for simple dev tasks — formatting JSON, encoding Base64, testing regex patterns. Each one had ads, signup walls, or sent my data to a server. I wanted a single place where everything runs client-side with nothing leaving my browser.
Each tool is a stateless pure function defined with Zod schemas. The schemas validate input at runtime and also generate the UI automatically — editor language, form fields, and output format are all inferred from the schema shape. Tools auto-execute as you type with 300ms debounce.
Three layout types are detected automatically from tool name and schema structure: standard (input editor → output editor), diff (two editors → diff view), and generator (form → output). No per-tool UI code needed.
The whole site is a Next.js static export — ~730 pages generated at build time, served from Cloudflare Pages. The tools package is pure TypeScript with zero browser dependencies. Built entirely with Claude Code.
Some things to try:
  - https://utils.live/tools/json/formatter
  - https://utils.live/tools/encoding/base64-encode
  - https://utils.live/tools/regex/regex-tester
  - https://utils.live/tools/jwt/jwt-decode
Interested in feedback on the auto-execute UX and what tools would be worth adding.

value: Show HN: utils.live – Developer utilities that run entirely in your browser

author: kranthie


value: gloussou

value: Show HN: A live global mood map (anonymous, one-click)

author: gloussou


value: Brysonbw

value: Show HN: Env-gen – Rust CLI tool to generate .env files

author: Brysonbw


value: intervolz

value: Breakdown of traffic from my Sol LeWitt Show HN post last week. 69 points, ~60k visitors, 10-hour spike, referral spread analysis.

value: Show HN: Traffic Breakdown of a Front Page Surge

author: intervolz


value: rhl

value:
I read a lot of research papers for work. My workflow evolved around an ever-growing inbox of bookmarked papers from arXiv et al. Great for exploration, but hard to keep track of what I read.
Distillate bridges the tools I already use: Zotero (literature management), reMarkable (reader + highlighter), and Obsidian (notes). It automates the whole pipeline:
$ distillate
save to Zotero ──> auto-syncs to reMarkable

                        │

         read & highlight on tablet
         just move to Read/ when done

                        │

                        V

         auto-saves notes + highlights

It polls Zotero for new papers, uploads PDFs to the reMarkable via rmapi, then watches for papers you've finished reading in your Read folder. When it finds one, it:
- Parses .rm files using rmscene to extract highlighted text (GlyphRange items)
- Searches for that text in the original PDF using PyMuPDF and adds highlight annotations
- Enriches metadata from Semantic Scholar (publication date, venue, citations)
- Creates a structured markdown note with metadata, highlights grouped by page, and the annotated PDF (I keep mine in an Obsidian vault)
The core workflow just needs Zotero and a reMarkable — no paid APIs, no cloud backend, your notes stay on your machine. Optional extras if you plug them in:
- AI summaries via Claude (one-liner + key learnings from your highlights)
- Daily reading suggestions from your queue
- Weekly email digest via Resend
- Obsidian Bases database for tracking your reading
Stack: rmapi for reMarkable Cloud, rmscene for .rm parsing, PyMuPDF for PDF annotation. Python 3.10+, pip installable.
The trickiest part was highlight extraction: reMarkable stores highlighted text as GlyphRange items in a scene tree, and matching that text back to positions in the original PDF required fuzzy search with OCR cleanup, plus special merging logic for e.g. cross-page highlights. Happy to say it works well ~99% of the time now.
Install: pip install distillate && distillate --init
Code: https://github.com/rlacombe/distillate
Site: https://distillate.dev
I built this for myself but would love feedback, especially from other reMarkable + Zotero users. What's missing from your workflow? What else should I add?

value: Show HN: Distillate – Zotero papers → reMarkable highlights → Obsidian notes

author: rhl


value: saiprakashreddy

value:
I built a simulator that models:
  • The full write path (WAL, Memtable, Immutable Memtable, L0 flush)
  • Leveled compaction with cascading merges
  • Read path with real bloom filter checks (not mocked)
  • Live write, read, and space amplification metrics

value: Show HN: I built an interactive LSM Tree simulator

author: saiprakashreddy


value: blechschmidt

value: This provider has been almost fully vibe-coded with Claude. I basically told Claude how the data model should look like and let it verify its assumptions on a real YubiHSM device. When the tests initially failed, Claude re-iterated and corrected its assumptions. In total, building it up to this state took me around 16 hours now.

value: Show HN: A vibe-coded low-level PKCS#11 Terraform provider

author: blechschmidt


value: rgthelen

value:
Hey HN. I built Corral because every time I asked an AI coding agent to
"add auth and payments," it hallucinated for an hour and produced broken
code. Wrong imports, phantom endpoints, a login page wired to nothing.
The problem isn't the agent. It's that auth-to-billing-to-gating is
genuinely hard to wire, and there's no machine-readable spec for how to
do it.
Corral is an open-source CLI (MIT) that gives your agent a spec it can
read (llms.txt), then scaffolds auth + Stripe billing into your existing
project. It detects your framework (Express, Next.js, Hono, Fastify, and
13+ more), embeds into your existing server (doesn't create a new one),
and generates working components: profile page, admin dashboard, plan
gating, Stripe checkout, usage metering. One YAML config file controls
everything.
The agent workflow is 9 commands. Every command supports --json. Errors
include a "fix" field. Exit 0 means deploy-ready.
I hardened this across 10 framework/DB combos with blind agent tests: 3
AI models, 3 rounds each, then a 10-agent fleet. Found and fixed real
edge cases like Express 4 vs 5 route patterns, Vite proxy ordering, and
agents creating duplicate servers instead of embedding into existing ones.
To try it, paste this into any AI coding agent:

  Read: https://llama-farm.github.io/corral/llms.txt
  Add auth and Stripe billing to my app.

Built on Better Auth + Stripe. 18 CLI commands, 30+ templates.
GitHub: https://github.com/llama-farm/corral
npm: npx create-corral init
Docs: https://llama-farm.github.io/corral/

value: Show HN: Corral – Auth and Stripe billing that AI coding agents can set up

author: rgthelen


value: probablyarth

value: Show HN: callonce-go – singleflight and per-request caching for Go services

author: probablyarth


value: steinsgate

value:
My friends and I started this project in the summer of 2025 with the initial goal of participating in the ARC Prize Kaggle competition. Early on, we were exploring agentic coding with frontier reasoning models and found that models like o3 and o4-mini could generate high-quality synthetic ARC-style puzzles. Our plan was to use these synthetic puzzles to train a smaller model via agentic reinforcement learning (RLVR with interleaved thinking).
To bootstrap this process, we needed successful solution traces from an open-weight reasoning model for cold-start supervised fine-tuning. That requirement led us to investigate GPT-OSS-120B. While doing so, we noticed something unexpected: simply placing the model into the interleaved thinking regime produced large and consistent score improvements on ARC AGI 2 tasks. We were seeing scores that we didn’t think was possible for a medium sized OSS model.
This observation ultimately shifted the focus of our work as we wanted to find out how universally this observation applies while staying within our resource constraints. We concluded that it applies quite generally, with double digit gains in frontier models too.
Previously, I have read debates about whether ARC AGI 2 is primarily a reasoning benchmark or a visual benchmark. I guess we can now add agentic benchmark to the mix as well!

value: Show HN: Solving ARC AGI 2 with interleaved thinking and stateful IPython REPL

author: steinsgate


value: Kidiga

value:
I’ve been frustrated with the DX of running local agents (OpenClaw) inside Docker. It breaks my VS Code integration and feels clunky.
I spent the last month writing a Kernel-Level Driver (using aya for eBPF on Linux and WFP Callouts on Windows) to enforce security underneath the agent process instead of putting it in a container.
The Architecture:
Network: Intercepts sys_connect to force agent traffic through a local DLP proxy (scrubbing API keys).
FS: Hooks sys_unlink to prevent the agent from deleting files outside ./workspace.
Identity: Binds the process to the TPM so the binary can't be exfiltrated.
The repo is still in early alpha (expect kernel panics), but I wanted to share the WFP/Rust bindings I wrote because they were a nightmare to debug.
Technical Question for HN: Has anyone successfully used eBPF for blocking sys_open calls reliably? I'm hitting a race condition on older kernels."
Why this works:
It admits it causes "Kernel Panics" (Honesty = Trust).
It asks a specific technical question (Invites smart people to comment).
It shares code/bindings (Gives value).

value: Show HN: Raypher – a Rust-Based Kernel Driver to Sandbox "Bare Metal" AI Agents

author: Kidiga


value: siofra

value:
My agents and I have built an HN-like forum for both agents and humans, but with agent specific features, like specific Prompt Injection flagging, and a login designed for agents only. (Uses asymmetric encryption keys.) There's also an Observatory page, where we will publish statistics/data on the flagged injections.
The observatory is at: https://wire.botsters.dev/observatory
(But nothing there yet.)
I just had my agent, FootGun, also build a Hacker News invite system that gets you trusted status. Let me know if you want a login. loud.stick7999@fastmail.com

value: Show HN: Forum for both agents and humans. Logs flagged injection attacks

author: siofra


value: oterpr

value:
Hello! My name is Max, and I'm a Go engineer.
For the past 3 years, I have been solo-building a free website to find remote-first jobs. The goal is to catch these jobs the moment they published on the company's career page, and before they appear on Linkedin or other job boards.
The whole project is built in Go (scraping engine, job classification agents, active jobs checker, and the website itself). Yes, there are a few hundred lines of TypeScript for the client side, but that's it.
Project stats:
- 20k+ companies monitored daily
- 5M+ jobs found since I started
- 19% of all jobs found are remote-friendly
- 150,000 lines of code
- $15,000 total cost so far (cloud, AI for classification, tools, and libs)
Ask me anything.

value: Show HN: I spent 3 years building free site in Go that finds remote-first jobs

author: oterpr


value: orkblutt

value:
Hey HN, I've been working on a CUDA pipeline that systematically searches for Bitcoin private keys generated by flawed software from Bitcoin's early years. The linked article is a technical deep dive into the GPU engineering — no source code (project is closed-source), but
  detailed pseudocode and architecture diagrams.

  The problem: Between 2009 and 2012, many Bitcoin wallet tools used predictable entropy — timestamp-seeded LCGs, brain wallets with simple passwords, the Debian OpenSSL bug (CVE-2008-0166) that reduced entropy to 15 bits, the Randstorm BitcoinJS flaw, PHP's mt_rand() seeded with
   time*pid, and others. The private keys generated by these algorithms have tiny search spaces (some as small as 65,536 candidates), and the addresses are still on the blockchain with funded balances.

  The engineering: Everything lives in a single ~3,400-line CUDA C++ file. The per-thread pipeline is:

  private key → secp256k1 EC multiply → SHA-256 → RIPEMD-160 → bloom filter → binary search → match

  Some decisions that might interest the GPU computing crowd:

  - EC multiplication via precomputed lookup tables (67 MB): The 256-bit private key is split into 16 × 16-bit chunks, each indexing into a precomputed table of generator point multiples. This reduces scalar multiplication from ~256 double-and-add iterations to 16 lookups + 15
  point additions.
  - Specialized SHA-256 kernels per pubkey format: Instead of a generic SHA-256, we have two dedicated functions — one for 33-byte compressed pubkeys (single block, partially precomputable message schedule) and one for 65-byte uncompressed (two blocks, second block is constant
  padding). Both build the message schedule directly from EC point coordinates without a serialization buffer.
  - 32 KB bloom filter in __constant__ memory: With ~3,100 target addresses and 100M candidates per batch, a naive binary search would thrash global memory. A bloom filter with 7 hash functions (FNV-1a + rotate-XOR double hashing) in constant memory rejects 99.9999% of candidates
   with broadcast cache reads. Only ~100 false positives per batch reach the binary search confirmation stage in global memory.
  - 256-bit modular arithmetic in PTX inline assembly: secp256k1 operates over a 256-bit prime field, implemented as eight 32-bit limbs with carry propagation. The sparse form of the secp256k1 prime (2^256 - 2^32 - 977) allows fast reduction.
  - __launch_bounds__(256, 2) + --maxrregcount=128: Targeting 2 blocks per SM with 128 registers per thread. Higher occupancy isn't better here because the kernel is compute-bound with heavy ALU usage — 2 blocks provides enough ILP to hide latency without forcing register spills.
   The Mersenne Twister mode (2.5 KB state per thread) is the exception and occasionally spills.

  There are 23 vulnerability modes total, covering LCG PRNGs (glibc, MSVC, Borland Delphi, Java), brain wallet patterns (SHA-256 of counters, timestamps, phone numbers, short ASCII strings), MT19937, V8 JavaScript PRNGs, and the Debian OpenSSL disaster. The smaller modes (Debian:
   65K candidates) complete in milliseconds; the largest (SHA-256 of ASCII strings 1-8 chars: ~2T) takes days across multiple GPUs.

  The distributed side uses a FastAPI backend that assigns work units, verifies results via deterministic checkpoint regeneration (server independently recomputes the key from mode+offset using Python), and injects canary targets (honeypot hashes where the server knows the
  private key) to detect cheating workers.

  Happy to answer questions about the CUDA optimization, the secp256k1 implementation, or the weak entropy patterns.

value: Show HN: GPU-accelerated search for Bitcoin keys generated with weak entropy

author: orkblutt


value: elvismdev

value:
I built an MCP server that gives Claude Code long-term memory across sessions, backed by infrastructure you control.
Every Claude Code session starts from zero, no memory of previous sessions. This server uses mem0ai as a library and exposes 11 MCP tools for storing, searching, and managing memories. Qdrant handles vector storage, Ollama runs embeddings locally (bge-m3), and Neo4j optionally builds a knowledge graph.
Some engineering details HN might find interesting:
- Zero-config auth: auto-reads Claude Code's OAT token from ~/.claude/.credentials.json, detects token type (OAT vs API key), and configures the SDK accordingly. No separate API key needed.
- Graph LLM ops (3 calls per add_memory) can be routed to Ollama (free/local), Gemini 2.5 Flash Lite (near-free), or a split-model where Gemini handles entity extraction (85.4% accuracy) and Claude handles contradiction detection (100% accuracy).
Python, MIT licensed, one-command install via uvx.
https://github.com/elvismdev/mem0-mcp-selfhosted

value: Show HN: Persistent memory for Claude Code with self-hosted Qdrant and Ollama

author: elvismdev


value: myonatan

value: Show HN: KrillClaw – 49KB AI agent runtime in Zig for $3 microcontrollers

author: myonatan


value: bengia

value:
I built an open-source Claude Code skill called /think that applies a structured 5-element analysis framework (ground in facts, stress-test for failure, reframe the question, trace implications, audit your own reasoning) before synthesizing a recommendation.
The obvious question: does it actually produce better output than just asking Claude directly?
To test this, I ran blind A/B comparisons. Two isolated Claude Opus 4.6 agents get the same question — one runs /think, one responds naturally. Both responses are anonymized (framework markers stripped, sections retitled by content) and presented blind.
The test covers 5 topics any professional would recognize: scaling a team post-fundraise, build vs buy decisions, when to pivot a product, SaaS pricing strategy, and the remote/hybrid/office debate.
An AI judge scored /think winning all 5 pairs. But AI judging AI is circular — which is why the blind test is live for humans to judge.
What I found so far (~21 comparisons across calibration + blind tests):
/think wins ~69% of comparisons overall
Risk coverage is the clearest advantage (17-2 across all tests) — it consistently surfaces failure modes the organic response misses
Decision impact is nearly even — organic Claude is often more actionable for practical problems
Novel insight is mostly a wash — both find similar core insights, just different ones
No decisive gaps in either direction. The advantage is depth and rigor, not dramatic superiority
Honest limitations:
All judges so far are AI. The whole point of publishing the blind test is to get human validation.
~21 comparisons is a pattern, not statistical significance
Anonymization isn't perfect — /think responses have stylistic tells (confidence assessments, "what would change this conclusion" sections)
The framework costs significantly more tokens
The skill itself is a recursive learning agent — it persists what it learns to a .think/ directory and loads that context in future sessions. Over time it builds project-specific knowledge. It also used its own framework to diagnose and fix its own weaknesses after the first round of testing.
Everything is open source: https://github.com/bengiaventures/effective-thinking-skill
I'd genuinely like to know if the blind test matches what the AI judges found, or if humans see something different. Takes about 15 minutes.

value: Show HN: I built a thinking framework for Claude

author: bengia


value: deduxer

value:
Contracts, invoices, time tracking, browser automation… all from WhatsApp, Telegram or Slack.
One message, it happens.
Thats my vision.
Sonnet 4.6 just dropped.
I swapped it in. 2 min job.
Same agent, noticeably cheaper to run. Agentic tasks that used to cost me $0.15 are closer to $0.04 now. At 79 tools firing across hundreds of users… that’s the difference between a business and a burn rate.
Models are getting cheaper faster than people realize. And the next shift isn’t better chat… it’s MCP. Agents that don’t just talk but actually connect, act, and hand off to each other. That’s where this is going.
I came to realize one thing building this over 2 years and 4 complete rebuilds…
The agent layer is becoming infrastructure.
accordio.ai

value: Show HN: Nobody asked for OpenClaw in the cloud. I did it anyway

author: deduxer


value: taariqlewis

value: Show HN: Seren Skills – Community-Driven Skills for Seren Desktop

author: taariqlewis


value: Simon-curtis

value: Born out of my frustration with powershell’s slow startup and confusing syntax I have long wanted to build a shell and scripting language in .NET. I have been working on it for a long time and thanks to Claude, I was able to finally get it over the line. I daily drive it as my shell on Windows, and really happy with it so far.<p>Please try it and let me know where it can improve!

value: Show HN: Jitzu – My PowerShell Killer

author: Simon-curtis

title: Show HN: Jitzu – My PowerShell Killer


value:
Hi HN, I've been building RocketLogs, an intelligence observability layer that sits on top of Loki, Tempo, and Prometheus.
The problem I kept running into: you get paged at 3 AM, open Grafana, flip between six dashboards, grep through logs, try to figure out which deploy went out, and an hour later you maybe have a root cause. You still need to dig through code and find the culprit. The data is all there, but nothing connects it for you.
RocketLogs tries to fix that:
VS Code / Cursor Extension - Fetches your slow and errored-out endpoints from production and lists them right in the Cursor chat sidebar with their latencies. It maps them to your codebase using Pyroscope profiling. So you have metrics -> traces -> profiles -> code right inside the codebase. It shows latency and a heat-map of how much your modules/funcs are bleeding your endpoints. So you can jump to the offending function and fix it without context-switching and within minutes.
Beyond those, it's a full observability stack: log search, distributed tracing with waterfall views, SLOs with error budget tracking, incident management with AI-generated synopses, smart alerts, and Prometheus dashboards.
We're built on the LGTM stack, so if you're already sending data to Loki/Tempo/Prometheus, you can point RocketLogs at your existing infrastructure. Using this as essentially another observability layer that sits on top. If you want to use multiple vendors, you can also do a telemetry fan-out.
Would love feedback. What's the most painful part of your current observability workflow?

value: Show HN: Cursor for Observability

title: Show HN: Cursor for Observability


value: Foliodoc

value:
Hey HN, I built FolioDoc (https://foliodoc.com) to solve a problem I kept hearing about from accountants and HR people — spending hours chasing clients for documents over email.
You create a checklist, add recipients with a deadline, and they get a magic link to a simple upload portal. No account needed on their end. Auto-reminders escalate as the deadline approaches.
A few things I focused on:
No recipient login — SHA-256 hashed magic links, raw tokens never stored. Recipients just click and upload.
Virus scanning — ClamAV runs on every upload. Infected files are rejected and the recipient is asked to re-upload.
Privacy — EU hosted (Germany), GDPR compliant, DPA included. No tracking in the app or portal.
Security — TLS everywhere, 5-layer file validation (type, extension, magic bytes, size, quota), rate limiting per-user and per-IP, full audit trail on deletions.
Branding — white-label with your logo and accent color on the portal and emails.
Stack: Django + DRF, Next.js 14, Celery + Redis, PostgreSQL. Portal is server-rendered Django templates (not the React app). Single EC2 instance, Docker Compose.
I'm based in Switzerland, built this over a few months. Free tier available. Would love feedback — especially on the recipient-facing portal since that's the part that needs to be dead simple.

value: Show HN: FolioDoc – I built a tool to stop chasing clients for documents

author: Foliodoc


value: stevejvv

value:
I built an API that takes a FEN or PGN and returns every tactical
pattern it finds — forks, pins, skewers, discovered attacks,
back rank mates, and more (10 patterns total).
It uses a two-phase approach: fast geometric detection, then
sequence confirmation to filter out false positives.
You can try it directly in the playground (no signup, no API key):
https://chessgrammar.com/playground
Paste any FEN or a full PGN and see what it finds. The playground
also has a bug report button if something looks wrong.
API docs: https://chessgrammar.com/docs
Built with Python (python-chess), deployed on Vercel.
The engine runs custom heuristic algorithms — no Stockfish
dependency at runtime.
Curious to hear feedback, especially from anyone who's worked
on chess analysis tools.

value: Show HN: ChessGrammar – API that detects tactical patterns in chess positions

author: stevejvv


value: alternateman

value:
dorabot is an open-source macOS app that wraps your coding agent in a harness with persistent memory, a workspace to manage both your work and the agent's, and a desktop UI that actually feels good to use.
What makes it click:
- Heartbeat pulses (inspired by OpenClaw) wake it up on a schedule. It scans for what needs doing, proposes tasks, executes after approval. Genuinely proactive, not just reactive.
- Deep context. It maintains its own memory, research notes, and daily journals. The amount of context it builds on you shows up subtly when you least expect it. It just knows things.
- Messaging. WhatsApp, Telegram, Slack. Once you start coding from Telegram, it's addictive. Promise you, you'll never go back.
- CDP-native browser use, email, calendar.
- Extensible. Add your own MCP servers or skills to extend it however you want.
I've been using it as my daily driver for coding, managing emails, and keeping an eye on the market. It does competitive research while I sleep and proactively nudges me (and sends me memes using my meme skill, lol) throughout the day.
In fact, it got fed up with me not posting about it and started roasting me for it. I'll let him know this is done so it gets off my back, lol.
https://github.com/suitedaces/dorabot
Local-only macOS app. No cloud relay. Everything on-device. MIT licensed.

value: Show HN: Turn Claude Code or Codex into proactive, autonomous 24/7 AI agents

author: alternateman


value: synctek

value: Show HN: AccessLint – Static accessibility analysis for iOS/Swift

author: synctek


value: sparacha

value:
Hey HN!
OpenClaw is notorious about its token usage, and for many the price of Opus 4.6 can be cost prohibitive for personal projects. The usual workaround is “just switch to a cheaper model” (Kimi k2.5, etc.), but then you are accepting a trade off: you either eat a noticeable drop in quality or you end up constantly swapping models back and forth based on usage patterns
I packaged Arch-Router (used by HF: https://x.com/ClementDelangue/status/1979256873669849195) into Plano and now calls from OpenClaw can get automatically routed to the right upstream LLM based on preferences you set. Preference could be anything that you can encapsulate as a task. For e.g. for daily calendar and email work you could redirect calls to k2.5 and for building apps with OpenClaw you could redirect that traffic to Opus 4.6
This hard choice of choosing one model over another goes away with this release.

value: Show HN: Preference-aware routing for OpenClaw via Plano

author: sparacha


value:
I built Privatiser, to allow the pasting of configs, logs, and code into ChatGPT/Claude but without risk leaking API keys, IPs, passwords, and customer data.
It detects and replaces sensitive values with consistent pseudonyms — so the AI can still reason about your text (e.g., "these two servers share the same IP") without seeing the real data. Then you paste the AI's response back and restore everything with one click.
What it catches: API keys (AWS, OpenAI, GitHub, Slack, etc.), JWTs, bearer tokens, SSH keys, connection strings, IPs, domains, emails, phone numbers, credit cards, SSNs, AWS ARNs/account IDs, Azure/GCP identifiers, UUIDs, and 200+ keyword-based patterns for passwords, hostnames, usernames, database names, etc.
It also understands natural language context — "password is secret123" and "host set to prod-db.internal" both get caught, not just key = "value" syntax.
Everything runs locally in your browser. No servers, no telemetry. Available as a Chrome/Firefox (Firefox is currently pending review) extension and a web tool.
Would love feedback on patterns you'd want added or things it misses.

value: Show HN: Privatiser – Redact secrets, IPs, and PII before sharing with AI


value: shotwellj

value: Show HN: Air – Open-source black box for AI agents (tamper-evident audit trails)

author: shotwellj


value: lixiasky

value:
tiny_coro is a lightweight, educational M:N asynchronous runtime written from scratch using C++20 coroutines. It's designed to strip away the complexity of industrial libraries (like Seastar or Folly) to show the core mechanics clearly.
Key Technical Features:
M:N Scheduling: Maps M coroutines to N kernel threads (Work-Stealing via Chase-Lev deque).
Memory Safety: Implements EBR (Epoch-Based Reclamation) to manage memory safely in lock-free structures without GC.
Visualizations: I used Manim (the engine behind 3Blue1Brown) to create animations showing exactly how tasks are stolen and executed.
Why I built it: To bridge the gap between "using coroutines" and "understanding the runtime." The code is kept minimal (~1k LOC core) so it can be read in a weekend.

value: Show HN: Writing a C++20M:N Scheduler from Scratch (EBR, Work-Stealing)

author: lixiasky


value:
It's a Discord-inspired chat app that runs entirely on the Cloudflare ecosystem:
Workers for the API and serving the React frontend.
Durable Objects to manage WebSocket connections and state (each chat room is a DO).
D1 (SQLite) for message persistence and history.
R2 for file uploads.
I wanted to see if I could build a fully functional, real-time chat platform without managing a single container or VPS. It supports voice/video calls via WebRTC (mesh topology), file sharing, and even push notifications.
The project is AGPLv3 licensed. I'd love to hear your thoughts on the architecture or answer any questions about working with Durable Objects!

value: Show HN: Accord – Serverless Discord Clone Running on Cloudflare Workers


value:
Arc is a language designed for AI agents. The core idea: every token costs money and burns context window. Arc programs use 27-63% fewer tokens than equivalent JavaScript.
Features: pipeline operator (|>), native LLM integration, 27 stdlib modules, try/catch, while loops, pattern matching. Full compiler with lexer, parser, interpreter, and optimizer.
Try it in the browser: https://play.arclang.dev
1,291+ tests passing. MIT licensed. Built by an AI agent running Claude Opus 4.6.

value: Show HN: Arc – A language that uses 27-63% fewer tokens than JavaScript


value: victoormt

value:
Solid is an early experiment in gamifying daily work for professionals without childish UI, avatars, or a gamer aesthetic.
This page includes an interactive demo that simulates the core workflow: choosing priorities, staying in flow, and closing the day with intention.
There’s no downloadable app yet. The goal of this demo is purely to validate whether this approach resonates before building the full product.

value: Show HN: Solid, gamifying daily work for professionals, without the gamer look

author: victoormt


value: pljkv

value: Show HN: VisibleInAI – Check if ChatGPT recommends your brand

author: pljkv


value: Show HN: SCIM filters to parameterized Postgres SQL for modern Java


value: elijahcham

value:
I created a free, open-source browser game inspired by Factorio.
You place "Input" machines that produce streams of bytes. You use conveyor belts to feed those bytes through other machines which produce transformations, and then to "Output" machines which produce audio or visual effects.
The game uses v86 to run a real Linux VM in the browser. I use the 9p filesystem to enable IPC via FIFO pipes, so shell commands can stream data continuously rather than just running once.
Features:
- 30+ machine types (sources, filters, routers, packers, audio synthesis, displays)
- "Command" machines that pipe data through real shell commands
- Streaming mode for persistent processes
- Shareable factories via URL
- Chiptune audio engine (oscillators, Game Boy noise channel) + additional 808 drum machine
Try the presets in the menu bar (top left) to see what's possible. Requires WASM and may take a moment to load on slower connections.
Live: https://bashtorio.xyz
Source: https://github.com/EliCunninghamDev/bashtorio

value: Show HN: Bashtorio – Factorio-Like in the Browser Backed by a Linux VM

author: elijahcham


value: amirdor

value:
I use Claude and Codex heavily for coding, and I kept burning through my quota halfway through the week. When I looked at my logs, most of my prompts were things like "summarize this," "reformat this JSON," or "write a docstring." Stuff that any small model handles fine.
So I built NadirClaw. It's a Python proxy that sits between your app and your LLM providers. It classifies each prompt in about 10ms and routes simple ones to Gemini Flash, Ollama, or whatever cheap/local model you want. Only the complex prompts hit your premium API.
It's OpenAI-compatible, so you just point your existing tools at it. Works with OpenClaw, Cursor, Claude Code, or anything that talks to the OpenAI API.
In practice I went from burning through my Claude quota in 2 days to having it last the full week. Costs dropped around 60%.
curl -fsSL https://raw.githubusercontent.com/doramirdor/NadirClaw/main/... | sh
Still early. The classifier is simple (token count + pattern matching + optional embeddings), and I'm sure there are edge cases I'm missing. Curious what breaks first, and whether the routing logic makes sense to others.
Repo: https://github.com/doramirdor/NadirClaw

value: Show HN: NadirClaw, LLM router that cuts costs by routing prompts right

author: amirdor


value:
Hi HN, I’m Berat.
I built TabRush, a simple ad marketplace inspired by the One Million Dollar Homepage concept.
How it works:
One Safari tab is the main spotlight for the latest sponsor
Side tabs show previous sponsors
Each new booking increases the next spot’s value
I built this for indie makers and early-stage startups that want a lightweight way to get visibility without running complex ad campaigns.
This is also my first time shipping with a vibe-coding workflow, and I built it in public.
I’d love feedback on:
whether the concept is clear quickly
what would make you trust it enough to try
what would make it genuinely useful for your launch/growth stack

value: Show HN: TabRush – Be fast, publish your ads


value: github-trending

value: Show HN: GPU-hot Dashboard for monitoring Nvidia GPUs on remote servers

author: github-trending