value: philipisik

value:
We recently shipped the Tiptap AI Toolkit (https://tiptap.dev/docs/content-ai/capabilities/ai-toolkit/o...), which lets developers embed LLM-powered editing into rich text editors.
Now we’re exploring the next step: making agents operate on documents without a browser involved.
The idea is a server-side system where agents can read, write, and transform documents in real time — essentially treating your document layer as a programmable data store that agents can interact with directly. Internally we’ve been joking about the name “real-time agentic document database”, because that’s the shape it’s starting to take.
I’m curious how others would think about this direction.
If you had a database where the fundamental unit wasn’t rows/objects, but documents with semantic structure that agents can mutate, what else could or should it do?
Where are the obvious footguns?
What boundaries would you want between agent autonomy and document integrity?
Would love to hear how you’d expand or constrain a system like this.

value: Show HN: Tiptap AI Toolkit – Now exploring server-side agentic document editing

author: philipisik


value: Show HN: Personalized Slack and Teams Alerts


value: aidenyb

value: Show HN: I made your coding agent 55% faster at front end

author: aidenyb


value: flabberghasted

value: Show HN: I built a tool to spot viral gaming trends

author: flabberghasted


value: zakthehahn

value: Show HN: Sphere-Base-One– A Python Kernel for Integer-Based Physics Optimization

author: zakthehahn


value: pharshal

value:
ProDisco gives AI agents Kubernetes access that closely follows Anthropic’s Progressive Disclosure pattern [1]: the MCP server exposes search tools which in turn surface TypeScript modules, agents discover them to write code, and only the final console output returns to the agent.
ProDisco goes a step further: instead of exposing custom TypeScript modules, it provides a structured parameter search tool that returns the most suitable methods from the official Kubernetes client library, including the type definitions for their input and return values. This lets agents dynamically interact with the upstream Kubernetes library while avoiding any ongoing maintenance burden in this repository to mirror or wrap those APIs.
https://github.com/harche/ProDisco
[1] https://www.anthropic.com/engineering/code-execution-with-mc...

value: Show HN: ProDisco – Progressive Disclosure Kubernetes MCP Server

author: pharshal


value: implabinash

value: Show HN: A decision making framework for DevRel resource allocation

author: implabinash


value: azdle

value:
This is a little side project I've been working on for the last few months. It's a service hosting Lua scripts behind static HTTP endpoints. It's something I've built to scratch my own itch and now I'm launching a free public beta to see if it's something that anyone else also finds useful.
<backstory>
My first professional job was for a company building an industrial IoT platform who's most unique feature was their Lua-based scripting platform. I ended up loving Lua so much that at my next job, at SmartThings, I ended up being the main instigator who made the Lua-based Edge Drivers happen when we were forced to sunset the old Groovy-based DTHs, writing the initial PoC, laying out the architecture, and writing the core of the system.
This is basically my take on an old service that folded in 2017 called webscript.io, another tool that got me loving Lua. I used that service a whole bunch both for personal projects and little tools at work. I was really sad when it went down and I genuinely don't think a single week had gone by where I hadn't wished that it still existed. So, I finally decided that I needed to build my own version of it.
</backstory>
The whole idea behind Bodge is that it should be as simple as possible to hack something together. I've always had a bunch of small side projects that I want to do that aren't worth the overhead required to actually put them together & keep them maintained. So, I built Bodge as a way to make each individual project less work whenever inspiration strikes. So far I've built:
* A current-time API for some hacked-together IoT devices: https://time.bodge.app/
* A script for my wife that checks her commute time and emails her before it's about to get bad.
* An email notification to myself if my Matrix server goes down.
* A 'randomly choose a thing' page. https://rand.bodge.app/choose?head&tails
* A "work" phone number voicemail, where the script converts the webhook into an alert to myself.
* An email notification any time a new version is released for a few semi-public self-hosted services.
* Scrapers for a few companies' job listings that notify me whenever a new job is posted matching some filters.
* A WebPush server that I eventually want to use for custom notifications to myself.
* And just for fun, an SVG hit counter: https://hits.bodge.link/
Scripts can be as simple as:

  return "Hello, world!"

Or as complicated as you're willing to make them within the confines of a single Lua file.
Currently I provide Lua modules for: making HTTP requests, handling json, sending alerts to yourself, simple string/string key/value storage, cross-script mutexes, and a few other basic things.
Accounts are free, but you don't even need to make one to just play around with writing scripts. There's a demo on the homepage that lets you run real scripts for yourself, though with a few extra limitations.
I'd love to hear what anyone thinks!

value: Show HN: Bodge.app – μFaaS for hacked-together personal tools and small projects

author: azdle


value: zphrise

value:
Hi HN,
I built a small web app around the new *Nano Banana Pro* image model:
https://nanobananaproimg.com
It’s a very simple, hosted playground focused on two things:
- *Text to Image* – Type a prompt and get a high-quality image.
- *Image to Image* – Upload an image and edit it with text instructions (change style, background, lighting, objects, etc.).
No local setup, no API keys, no fine-tuning. You just sign up, buy credits, and use the model in the browser.
---
### What you can do on the site
- Generate images from text prompts (up to 2000 characters).
- Upload an existing image and restyle / edit it.
- See cost and remaining credits next to the generator (2 credits = 1 image).
- Download the result and use it for social posts, thumbnails, simple marketing visuals, etc.
Right now there are three paid annual plans (Starter / Standard / Premium) with different monthly credit amounts. The goal is just to make the pricing predictable and keep the UI minimal so non-technical users can still play with the model.
---
### What this is *not*
To be clear:
- It’s *not* a fine-tuning / training platform.
- It’s *not* a local setup tool.
- It’s *not* an official product from the team behind the model.
- It’s just an independent wrapper around the Nano Banana Pro image API with a credit system and a clean UI.
---
### Why I built it
I’m an indie developer experimenting with small AI SaaS products.
Nano Banana Pro launched with strong image capabilities, but most non-technical users don’t want to deal with API docs, SDKs, or dev environments.
This project is mainly:
- A way to learn how people actually use the model (what prompts, what use cases).
- A testbed for pricing / credits and onboarding flows.
- A minimal tool for creators who just want “type prompt → get image”.
---
### Feedback I’m looking for
- Is the UI/flow clear enough for you?
- Does the credit + pricing structure make sense?
- What’s missing for your real workflows (e.g. batch generation, history, presets, etc.)?
If you have thoughts on the UX, pricing, or landing page copy, I’d love to hear them.
Thanks for taking a look!

value: Show HN: Nano Banana Pro – Simple text-to-image and image editing playground

author: zphrise


value: belai

value:
I built this over a weekend after getting tired of writing the same monitoring scripts.
You describe what you want in plain English, and it generates a working terminal dashboard with cyberpunk aesthetics using Claude + Textual.
Example: "show CPU and RAM usage" → instant TUI with live data
Key features:
- Self-healing code (if it crashes, Claude fixes it automatically)
- Built-in API usage tracking
- Zero-install deps with uv
It's basically Lovable.dev but for your terminal. Open source, MIT licensed.
Would love feedback from the HN community!

value: Show HN: Hacker Dash"-Lovable for Terminal

author: belai


value: benzguo

value:
Hi! We're launching Zo Computer, an intelligent personal server.
When we came up with the idea – giving everyone a personal server, powered by AI – it sounded crazy. But now, even my mom has a server of her own.
And it's making her life better.
She thinks of Zo as her personal assistant. She texts it to manage her busy schedule, using all the context from her notes and files. She no longer needs me for tech support.
She also uses Zo as her intelligent workspace – she asks it to organize her files, edit documents, and do deep research.
With Zo's help, she can run code from her graduate students and explore the data herself. (My mom's a biologist and runs a research lab.)
Zo has given my mom a real feeling of agency – she can do so much more with her computer.
We want everyone to have that same feeling. We want people to fall in love with making stuff for themselves.
In the future we're building, we'll own our data, craft our own tools, and create personal APIs. Owning an intelligent cloud computer will be just like owning a smartphone. And the internet will feel much more alive.
https://zo.computer
All new users get 100GB free storage.
And it's not just storage. You can host 1 thing for free – a public website, a database, an API, anything. Zo can set it up.
We can't wait to see what you build.

value: Show HN: A Server for My Mom

author: benzguo

title: Show HN: A Server for My Mom


value:
he AI landscape is moving at a terrifying pace. Every day brings a new tool, framework, or paper. As engineers who actually use this stuff, we were spending more time sifting through endless "Top 100" lists, Product Hunt launches, and Twitter threads than we were building.
The signal-to-noise ratio has hit an all-time low. We were tired of wasting hours on "breakthrough" tools that turned out to be thin wrappers around an API or abandoned after three weeks.
So we built AI Things to give you something that keeps up with AI so you don't have to

value: Show HN: A Curated, Vetted Directory of AI Tools for Engineers


value: hackingmonkey

value:
A few years ago my mum wrote a book on success quotes (she also has another version with short stories about how famous/notable figures achieved success) think Einstein, Picasso, etc. She's not great at marketing or promo so I decided to turn the content into an app. Besides helping her, I felt an app would be a better way for people to absorb this kind of material today and a way to scale wisdom using technology.
What makes this app different from others is our context feature, which provides personal and historical context behind the author's quote, explaining the meaning and wisdom behind it; turning it into more than just a motivational app. (This feature is paid btw, but I'm happy to share promo codes for anyone interested in trying it out.)
We released just a couple days ago; posting here because I figured HN might have people genuinely interested in this kind of content. Hope you find it useful! :)

value: Show HN: I built an app - Success Motivation for Builders

author: hackingmonkey


value: johnsillings

value:
Hey HN! Just for fun, I built an interactive Hacker News Simulator.
You can submit text posts and links, just like the real HN. But on HN Simulator, all of the comments are generated by LLMs + generate instantly.
The best way to use it (IMHO) is to submit a text post or a curl-able URL here: https://news.ysimulator.run/submit. You don't need an account to post.
When you do that, various prompts will be built from a library of commenter archetypes, moods, and shapes. The AI commenters will actually respond to your text post and/or submitted link.
I really wanted it to feel real, and I think the project mostly delivers on that. When I was developing it, I kept getting confused between which tab was the "real" HN and which was the simulator, and accidentally submitted some junk to HN. (Sorry dang and team – I did clean up after myself).
The app itself is built with Node + Express + Postgres, and all of the inference runs on Replicate.
Speaking of Replicate, they generously loaded me up with some free credits for the inference – so shoutout to the team there.
The most technically interesting part of the app is how the comments work. You can read more about it here, as well as explore all of the available archetypes, moods, and shapes that get combined into prompts: https://news.ysimulator.run/comments.html
I hope you all have as much fun playing with it as I did making it!

value: Show HN: I built an interactive HN Simulator

author: johnsillings


value: atulvi

value: I Made this to explore related wikipedia topics. Each page has two related topics. Click one to deep dive and explore.

value: Show HN: Wikidive: A tool to deep dive Wikipedia rabbitholes

author: atulvi


value:
Hello HN,
I’m the founder of PDFClear (https://www.pdfclear.com). It’s a suite of PDF tools (merge, split, compress, etc.) that runs entirely in the browser.
I built this because I was tired of Googling "merge pdf" and landing on sites that require me to upload sensitive bank statements or contracts to an unknown server. I wanted a tool where the file never leaves the device.
The Tech Stack:
The app is built with React and Vite, but the heavy lifting is done via WebAssembly and Web Workers to keep the UI thread responsive.
- PDF Manipulation: I’m using pdf-lib for standard operations (merge, split, rotate).
- Compression & Encryption: For heavier tasks like compressing streams or handling encryption/decryption, I compiled QPDF to WebAssembly (qpdf-wasm).
- OCR: Scanned documents are processed client-side using Tesseract.js.
Local AI (The New Part):
I recently added Semantic Search and Summarization without relying on OpenAI/Anthropic APIs.
- It uses Transformers.js to run ONNX models directly in the browser.
- Search: Uses different models (including nomic-ai/nomic-embed-text-v1.5 and Xenova/GIST-small-Embedding-v0) for embeddings. It chunks the text, stores vectors in IndexedDB (via idb-keyval), and performs cosine similarity locally.
- Summarization: Uses onnx-community/text_summarization-ONNX (quantized) running in a Web Worker.
Privacy:
Because everything runs client-side, no documents are uploaded to my server. You can verify this by inspecting the Network tab. Once the app loads (and the AI models are cached), it works fully offline.
I’d love your feedback on the performance of the local AI models, specifically on older devices.

value: Show HN: PDFClear – Browser-based PDF tools with local AI (WASM+Transformers.js)


value: witnessme

value:
ResilientLLM is a minimalist but robust LLM integration layer designed to ensure reliable, seamless interactions across multiple LLM providers by intelligently handling failures and rate limits out-of-the-box.
Available as a node.js package `npm i resilient-llm`, support for other languages coming soon.
With just few lines of code, you can avoid writing and maintaining the code to deal with challenges such as:
1. Unstable network conditions
2. Intermittent errors and inconsistent error handling
3. Unpredictable LLM API rate limit errors
More about the motivation and features in the README. Keen to hear your thoughts. If you like this, do star the repo and share your feature requests.

value: Show HN: Resilient LLM

author: witnessme

title: Show HN: Resilient LLM


value: coffeecoders

value:
I built a tool that reveals the data your browser exposes automatically every time you visit a website.
GitHub: https://github.com/neberej/exposedbydefault
Demo: https://neberej.github.io/exposedbydefault/
Note: No data is sent anywhere. Everything runs in your browser.

value: Show HN: Explore what the browser exposes about you

author: coffeecoders


value:
I built a live interactive map that shows where top AI companies hire around the world.
I collected this data for a hackathon project. Many ATS providers have a public API that you can hit with the slug of the companies to get open jobs. The hardest part was finding the companies. I tried Firecrawl but it returned around 200 companies per provider which wasn’t enough for me. Then, I tried SERPAPI but it was expensive. I ended up using SearXNG to discover companies by ATS type and fetch their job postings. This produced a large dataset of 200k+ jobs (I only use a subset as it would have taken too much time processing). A few days ago, I decided to build a visualization of the data as I didn’t know what to do with it and wanted people to benefit.
I kept catching myself wanting to ask simple questions like “show only research roles in Europe” or “filter for remote SWE positions” (and had plenty of free ai credits) so I added a small LLM interface that translates natural language into filters on the map.
The map is built with Vite + React + Mapbox.
Live demo: https://map.stapply.ai GitHub (data): https://github.com/stapply-ai/jobs
Would love feedback, ideas for improvement, or contributions.

value: Show HN: I built an interactive map of jobs at top AI companies


value: SencerH

value:
One day a friend mentioned he wanted a monitoring system for a few Raspberry Pis. I looked around online for about 5 minutes but couldn’t find anything that matched what I had in mind. So I decided to try “vibe coding” and make it a project.
In about 3 days (roughly 15 hours total), I built a prototype just by chatting with Gemini-CLI. After that, I added some improvements for fun and brought it to its current state.
Right now both my friend and I are using this project at home. Hopefully it’ll be useful for you too.

value: Show HN: Raspberry Pi Monitoring with Gemini-CLI

author: SencerH


value: Show HN: Smart Scan – REST API, Dashboard, and CI/CD Tools for MCP Security


value:
I built an AI companion that implements *state stability and persistent persona evolution*—the next step beyond simple RAG or chat history.
The system uses Python/Flask and Gemini to manage a *multi-dimensional personality state* (Tsundere, Yandere, etc.) that evolves over time.
### Core Technical Challenge & Solution:
1.  *State Stability (Hysteresis)*: We prevent the persona from "flipping" instantly based on one message by introducing *inertia* (requiring 2x the score difference to change an established personality).
2.  *Affection Scaling*: The emotional depth (Affection Level) scales infinitely, leading to complex state shifts over long interactions.
3.  *Efficiency*: All logic runs within a single, cost-optimized API call.
### I'm looking for technical critique on:
* *Architecture*: Are hard margins (10-point difference) for stability the best approach, or should this be solved with a purely ML-driven method?
* *Safety & Alignment*: How to maintain the provocative nature of personas (like Yandere) while adhering to strict safety boundaries.
GitHub Repo: [https://github.com/EMMA019/Evo-chat]

value: Show HN: An AI Agent with Hysteresis-Based Personality Evolution (Python/Gemini)


value: Prismle makes every resume discoverable through meaning-based search, connecting you to the right candidates with simple, human queries.

value: Show HN: Prismle – From Query to Candidates in One Human Sentence


value: Show HN: I built an O(N) AI using an Agent Swarm. Asking for audit


value: ankitdce

value:
When we asked developers from large engineering teams, almost everyone is using Claude Code, Cursor, or Copilot. But adoption is still inconsistent. Some of us would have 15 agents running in Claude Code at the same time; some would still refuse to use any of them and write code manually.
There's a fragmented AI development problem:
- Five developers building similar features, and all of them start from scratch
- No way to share "here's how we prompt AI to follow our architecture"
- No trail of how the AI changes were generated
- People leave the company, so does the their knowledge
Aviator is a developer productivity platform with tools like MergeQueue, Stacked PRs, Releases (https://docs.aviator.co/). Runbooks came from watching our own team and our customers struggle with fragmented AI adoption.
With Runbooks
1. Create executable specs - Plan (with AI) that captures intent, constraints, and steps before AI touches code
2. Version control everything - Specs, AI conversations, and generated changes are all versioned. Fork, improve, roll back
3. Make it multiplayer - Multiple engineers collaborate in the same AI coding session.
4. Build a template library - Migrate one test from Enzyme to React Testing library → use that Runbook to batch migrate the entire test suite.
We're not replacing Claude Code or Cursor. Runbooks is powered by Claude Code. We’re just making it work at team scale.
--
Explore our prebuilt template from our open-source library: https://github.com/aviator-co/runbooks-library
Templates cover migrations, refactoring, and modernization. They're code-agnostic starting points that generate Runbooks using your code context.
Docs and quickstart: https://docs.aviator.co/runbooks
--
About the name: Yes, we know "runbooks" makes you think incident management. But technically a runbook is just a documented, step-by-step procedure—which is exactly what these are for AI agents. We're keeping it!
Happy to get feedback, answer questions about architecture, context management, sandboxes.

value: Show HN: Runbooks – Shareable Claude Code Sessions

author: ankitdce


value:
I'm writing a compiler for a systems language focused on concurrency and parallelism. It’s a re-engineering of a prior work, with an explicit emphasis on memory management and type safety, plus first-class parallel primitives at the language level.
The language is now capable of compiling a substantial portion of its own source code to tokens using a single-pass C back-end. The self-hosted compiler includes a handwritten lexer and a parser, with an arena-based allocator to support fast compilation and eliminate GC complexity.
The primary goals for the project are: First-class parallel and concurrent constructs built directly into the language, strong static memory and type guarantees, and a toolchain suitable for building high-performance software
Example:

  def main() {
      parallel local(mut arena: Arena) {
          arena = Arena.create(1024);

          val tid = Parallel.thread_id();
          val result = worker(ref_of(arena), tid);

          println $"Thread {tid} computed {result}";
          Arena.destroy(ref_of(arena));
      }
  }

You can find the repository here: https://github.com/axelang/axe

value: Show HN: Axe - A Systems Programming Language with Builtin Parallelism and No GC


value: Show HN: Open-source medical data(bloodwork, genetics, etc.) chat agent


value: Show HN: ZDTP Chess – Multi-dimensional analysis using zero divisor algebras


value: Show HN: Fractalbits – S3 compatible high performance storage with Rust and Zig


value: Show HN: I built a website for my movie podcast with my childhood friend


value: hunterbown

value: Show HN: Hegelion – Force your LLM to argue with itself before answering

author: hunterbown


value: rapgof

value:
I built Promptflix, an early prototype of a marketplace for AI prompts (image + video), mainly to explore the economics of prompt iteration and how creators/buyers behave in real usage.
Why I started
I use AI tools daily and often spent:
$1–3 iterating on a good image prompt
$4–6 testing video prompts
I noticed many people hit the same issue — spending more on “trying” than on the final result.
I wanted to see whether a cost-efficient prompt marketplace could reduce this wasted spend.
What’s working now
This prototype includes:
Prompt browsing
Search + filtering
Creator profiles
Collections
Prompt locking/unlocking
Basic analytics for creators
Supabase auth + RLS
Storage + edge functions
React + TypeScript + Tailwind frontend
There are not many curated prompts so far (Midjourney, Flux, DALL·E, Nano Banana, Veo 3, etc.) to test user behavior.
About 10 testers are using it so far.
Current limitations
Stripe payouts not integrated yet
Some UX flows still rough
Navigation still improving
Still validating how people actually want to buy/sell prompts
This is very much a work in progress.
What I’m looking for
Thoughts on the concept of a “cost-efficient prompt marketplace”
Feedback on UX and flow
Blind spots you see in the approach
Any suggestions for measuring prompt originality/value
The prototype is live (linked above).
Happy to answer any questions or share technical details.

value: Show HN: Promptflix – an early marketplace prototype for AI image/video prompts

author: rapgof


value: memalign

value:
I’m launching Create Your Own Wolfer[0] today, which walks you through creating and testing a Wolfer game, all in your web browser.
Inspired by the classic Munchers educational games of the 80s and 90s, I made Wolfers in the same gameplay style: eat correct answers and avoid the enemy.
All along I hoped to enable other people to create their own custom version of the game for any topic.
I think this could be useful for parents and teachers as an educational tool.
And it can also just be fun, like in Wolfer: PokéPrescription[1] where you need to determine whether a name is a Pokémon or a prescription medication.
0: Create Your Own Wolfer: https://memalign.github.io/m/wolfer/create.html
1: PokéPrescription: https://memalign.github.io/m/wolfer/wolfer.html?g=pokeprescr...

value: Show HN: Create Your Own Wolfer

author: memalign

title: Show HN: Create Your Own Wolfer


value:
Hi HN,
We’re Ruben, Afnan, and Theo. A couple of days ago we released the early repo for Davia and were surprised by how much feedback came in right away. We decided to turn it into a full open-source package you can run locally.
Davia is designed for coding agents to generate an editable internal wiki for your project. It focuses on producing high-level internal documentation: the kind you often need to share with non-technical teammates or engineers onboarding onto a codebase. Writing this kind of documentation takes forever, diagrams are often missing, and most tools don’t let you edit everything locally or integrate smoothly with your workflow.
Davia is fully open source. It produces an editable workspace:
– Text lives in a Notion-like editor
– Diagrams live on editable whiteboards
– Everything runs locally and can be modified either in your IDE or in the workspace
One thing people found especially interesting is that you can delegate the documentation to your IDE’s AI agent. Davia handles all the heavy lifting. Your agent just writes the docs, and Davia turns them into structured pages, diagrams, and visuals.
The project is still early, and we’d love feedback, ideas, and examples of how you handle internal documentation today.
GitHub: https://github.com/davialabs/davia
Discord: https://discord.gg/A79mEzP8me

value: Show HN: Open-Source Visual Wiki Your Coding Agent Writes for You


value: vtsaplin

value: Hi everyone. I built this tool because I often needed quick insights from CSV or Excel files without writing SQL. It uses an LLM to generate SQL and DuckDB to execute locally. All computation stays on the user's machine since only the schema is sent to the model.<p>Happy to answer any questions or receive feedback.

value: Show HN: DataTalk CLI, Query CSV and Excel in Plain English Using LLM and DuckDB

author: vtsaplin


value: jawerty

value: Show HN: X Timeline Cleaner, block tweets by location from your X timeline

author: jawerty


value: benjoffe

value:
Converting that integer to a Year, Month and Day is a fundamental calculation made in almost all programming languages and standard libraries. It runs every time a date is displayed, whether it's in a user interface, log, API etc.
While it is rarely a bottleneck, it is a very frequently run algorithm, and thus has attracted a lot of attention over the years.
In 2021, Cassio Neri and Lorenz Schneider developed the Neri-Schneider algorithm, which was a major breakthrough in this niche area.
Lately, I have been studying this function deeply, and found what I believe may be the last remaining substantial improvements achievable on current hardware. The gains come mainly from counting dates backwards, and from reducing the number of multiplications from 7 to 4.
Adoption will depend on whether library maintainers consider the performance benefit to outweigh the readability. If this is rejected on readability grounds, then in those cases my algorithm outlined in Article 1 (linked in the blog post navigation) is likely to be simpler and faster than what almost all existing libraries are currently doing.
I found this a very interesting challenge to work on, and I believe some of the techniques outlined may be applicable to other areas of optimisation.

value: Show HN: A faster day-count to Y,M,D algorithm – 30-40% speedup

author: benjoffe


value: kraddypatties

value:
Hey HN.
Over the last few months, we've (me and @parthradia) homebrewed some very fast, very cheap, and pretty expressive talking head models. Our latest enabled us to finally get a live-streaming API together, which you can try at the playground link above.
We actually fell down this rabbit hole because we were spending a significant amount of time building yet another language learning app. We came to the conclusion that the barrier for learning wasn’t the course content, but real, conversational practice. We tried prototyping with standard speech-to-speech models (OpenAI Realtime, Gemini Flash, etc.), but found that we weren’t really triggering our “fight or flight” response.
What did trigger it was talking to a person, face to face. We looked for existing realtime avatar APIs to bridge that gap, but they didn’t fit the constraints: they either didn’t cross the uncanny valley, were too slow (<15 fps), or were way too expensive. So we decided to make our own :-)
The model itself runs at less than a cent per minute and at >30fps on commodity hardware (4090s!), which is pretty cool.
But more importantly, we’ve actually found ourselves using it as a speaking partner for learning Spanish, which is a pretty remarkable feeling at times. This has inspired us to look beyond language learning; we are exploring other use cases (e.g., telehealth, mock interviews, refining elevator pitches) where face-to-face interaction measurably elevates the experience (and we’d love to hear from you here!).
With respect to our tech, there’s still low-hanging fruit to pick:
1. It takes roughly 6s to get a response end-to-end (the video gen is fast, but the chain of ASR -> LLM -> TTS adds up)
2. The resolution could be higher
3. The model feels expressive and natural during its speech, but less so during user turn (early prototypes of the model reacting in realtime to what you’re saying show promise)
While we build out consumer-facing application(s) powered by our model, we’re opening up an API early to see what other developers might build with it. We’d love for you to try it in our playground. Leave a comment below or shoot us a line if you want early access (access@keyframelabs.com)!

value: Show HN: Realtime, expressive AI personas that you can video call

author: kraddypatties


value:
Hi HN!
I've been talking to a few engineers about how Perforce (verion control tool for large binary files) doesn't support stacked changelists, and how everyone just create massive changelists instead of trying to split them up into smaller, more reviewable chunks.
So I build p4-stack, a CLI tool in Python that brings the git rebase-style workflow to Perforce. It's ultra simple, and I'd love to hear what you think!
I also included a 90s demo of the tool at the front of README.md

value: Show HN: Bringing stacked diff workflow to Perforce


value: matsucks

value: My wife said she wished there was a big widget on her phone that told her when to take her Nuvaring out. So I vibe coded one. What other problems can it solve?

value: Show HN: My first published app – track contraception ring cycle

author: matsucks


value: iregaddr

value:
I’ve been building a different kind of web framework and would love feedback.
TX-2 ECS is a TypeScript-first framework where your app is modeled as an ECS world (entities, components, systems) instead of a tree of UI components + ad-hoc state.
A few things that might interest HN:
- Single world model shared across server and client; systems run in both places.
- Rendering is “just another system” that produces DOM; SSR + hydration are built in.
- Built-in RPC + state sync that ships only deltas, on a tunable rate limit (aimed at reducing egress/CPU for real-time apps).
- Designed for long-lived products where you care about dev velocity 5+ years in (features are usually new systems, not surgery on existing code).
It’s aimed at apps that feel more like living systems than CRUD: multiplayer tools, dashboards, agents, simulations, collaborative editors, etc.
Repo: https://github.com/IreGaddr/tx2-ecs
I’m especially interested in:
- “This will/ won’t work in production because…” from people who run real-time systems.
- Critiques of the ECS-centered architecture for web.
- Benchmarks or experiments you’d want to see before considering something like this.

value: Show HN: TX-2 ECS – A web framework that treats your app as a world

author: iregaddr


value: jamesdhutton

value: My wife and I tried making reward charts for our kids. We never could make paper rewards charts last  long. So I built an app. We've been using it at home for the last few months, with reasonable success. If you have kids aged 5-10, you might find it useful too. I'd love to get your feedback.

value: Show HN: Housepoints

author: jamesdhutton

title: Show HN: Housepoints


value: andupotorac

value:
A while back I saw a tweet from @jackfriks describing how surprisingly long it took to ship something as simple as an avatar upload feature (11 months!). It's not that it was difficult to do, but it was never a priority, even if that is what our users see and click on every day to get to their settings / billings etc.
It got me thinking: why are we still relying on Gravatar, random initials, empty defaults, or worse, whatever unpredictable photos users choose to upload themselves? Especially if you're an enterprise company, or a place where users interact with one another. None of these options guarantee safety, consistency, or professionalism - and obviously none are on brand. Or customized for holidays.
And because nobody built this, I did it myself. Check some examples, including with Jack himself, here: https://www.memoreco.com/explainers/branded-avatars.
Feel free to use the camera, I set a short retention policy and the images will be deleted. And you cannot send me dick picks because I baked in safety - NSFW, and ONE face detection.
This should be useful for the holidays, feel free to connect over Twitter if you want to add it in time to your sites, or about pages, or customer testimonials, etc.

value: Show HN: A safe way to capture and create branded profile photos for your site

author: andupotorac


value: jcfs

value:
I kept opening 10+ tabs for the same daily clipboard chores, so I crammed a bunch of tiny client-side tools into one page:
Drop any image → OCR + dominant color palette + QR/barcode decode
Paste “72 kg in pounds”, “50C to F”, “180 cm to feet” → instant conversion
Paste any math expression → instant result
JSON  pretty/minify, JWT decode, Base64 → text/file, hex, URL tracking-strip, etc.
All 100 % in-browser, zero backend, nothing ever leaves your machine
It’s deliberately over-engineered for the weird stuff I copy every day.
Try throwing something at it and tell me what breaks or what’s missing.
Feedback button  goes straight to me.
https://pastehub.app

value: Show HN: Pastehub.app – 100 % client-side toolbox for whatever you just copied

author: jcfs


value: qwikhost

value: WhatsApp Chat Exporter - Export Messages to CSV, Excel, JSON and Download Videos, Images, Audio, Documents

value: Show HN: WhatsApp Chat Exporter

author: qwikhost

title: Show HN: WhatsApp Chat Exporter


value: Ethanya

value:
Hi HN,
We built Image to STL, a AI tool that converts 2D images into 3D printable STL files in seconds. Upload a PNG or JPG → get a ready-to-print STL model — no 3D modeling skills required.
Key Features
AI-Powered Conversion
Automatically generates 3D geometry from a single image
Handles photos, logos, artwork, and product images
Instant Processing
Get your STL file in seconds, not hours
No software installation needed
3D Print Ready
Optimized mesh output for FDM/SLA printers
Clean, watertight STL files
Why We Built This
3D printing is everywhere, but creating 3D models is still a barrier for most people. We wanted to make it dead simple: upload an image → download an STL → start printing.
Perfect for:
Makers who want to print custom designs
Product designers prototyping ideas
Artists turning 2D work into 3D sculptures
Hobbyists experimenting with 3D printing
Try it free:
https://imagetostl.org
Feedback We'd Love
What types of images would you want to convert?
Any mesh settings that matter most (resolution, thickness, etc.)?
Would API access be useful for your workflow?
Other output formats you need beyond STL?
Thanks for checking it out! Happy to answer any questions.

value: Show HN: Image to STL – Free AI-powered image to 3D printable model converter

author: Ethanya


value: It started out when I thought about how to help founder to validate their idea, not just coming up one but how to turn the idea into real business by not relying on AI but making them more involved into their product, understand the market by doing research, check what user want. It's like a checklist, a step for someone who want to get start. This is not an AI to go tool, it's a tool to drag user back to reality, simple but important.<p>I don't think I'm gonna make money with it so I decide it will be a free to use. Use referral code "beyondzero" to sign up. Thanks

value: Show HN: I Built a Small Startup Idea Validation Platform


value: qzcanoe

value:
NBPro is a dedicated NanoBanana Pro prompt library built for creators. Explore over 100 curated and proven prompts across real commercial use cases like product shots, ads, social visuals, and more – all optimized for NanoBanana Pro.
Core value:
- Save time on searching and trial‑and‑error
- Recreate real‑world effects instantly using one‑click prompts
- Learn prompt structure and best practices
- Powered by the native NanoBanana Pro API
- High‑quality images with no learning curve
Ideal for e‑commerce teams, designers, content creators, social media influencers, AI image enthusiasts, and marketers who want to generate professional‑grade visuals quickly.
Stop guessing. Start creating.

value: Show HN: NBPro – NanoBanana Pro prompt library (100 prompts)

author: qzcanoe


value: lakshikag

value:
I’ve been using status.cafe for a while and I love it, but if there is one thing that has been bugging me is that there’s no way to export all the status updates I’ve posted over the years. If the site goes down someday, that whole history is just gone.
With that thought bugging me, I built kibun.social, a minimal status.cafe-like service built on top of atmosphere, the same open social protocol used by Bluesky.
Because it’s decentralized, every status you post is stored directly inside your PDS. You can export them, move to another app, or build your own frontend in the future. The platform is basically just a viewer/writer on top of your data.
It's very straightforward and takes seconds to update your status. You login with your atproto handle, select an emoji and post your status. You also gets your own RSS feed for your statuses if you want to follow them elsewhere.
It’s still early but I’d love to hear what people think - especially people who enjoy small social spaces and decentralized web stuff.

value: Show HN: Kibun (気分) – a decentralized status.cafe alternative I made

author: lakshikag


value:
Hi HN,
I built this because I was tired of uploading my personal photos to third-party servers just to compress them. I wanted a tool that respects privacy by doing everything 100% on the client side.
It runs entirely in your browser (no data leaves your device), so there are no file size limits or upload wait times. It currently supports bulk compression for JPG, PNG, and WebP.
The larger suite of tools I'm building at ToolboxNest. I'd love to hear your feedback on the compression quality and the UI!

value: Show HN: Free client-side image compressor (privacy-first, no uploads)


value: Show HN: Radius.today – Local-first personal CRM


value: Hacked together a point-and-shoot device that uses raspberry pi + cam to capture the image and LLM to analyze it and text-to-speech to describe the surrounding out loud all under $30.

value: Show HN: Device for visually impaired folks that describes their surroundings


value:
Hey HN, author here.
I built Container-Make (cm) because I was tired of maintaining both a Makefile (for terminal users) and a .devcontainer folder (for VS Code users) in my projects. I wanted devcontainer.json to be the single source of truth, but I didn't want to be forced to use VS Code.
The Problem: Running dev containers from the CLI manually is painful. You have to handle docker run flags, volume mounts, port forwarding, and worst of all—file permissions on Linux.
How cm solves it: It parses your standard devcontainer.json and spins up ephemeral containers to run commands. It acts like make, but everything runs inside the container defined by your config.
Technical Details (for the curious):
Language: Written in Go (1.25+) using the official Docker SDK.
Permission Handling: This was the hardest part. I implemented a dynamic entrypoint script that checks the uid/gid of your workspace and creates a matching user inside the container on-the-fly using adduser/su-exec. This solves the "files owned by root" issue on Linux host mounts.
TTY & Signals: It puts the terminal in raw mode and forwards signals (SIGINT/SIGTERM) correctly, so interactive tools like htop or vim work seamlessly.
Performance: It leverages Docker BuildKit for caching.
Current Status: It supports image, build.dockerfile, forwardPorts, postCreateCommand hooks, and environment variables. "Features" support is currently being worked on.
Repo: https://github.com/UPwith-me/Container-Maker.git
I’d love to hear your feedback on the implementation, specifically around the signal handling logic!

value: Show HN: I built a CLI to use devcontainers without VS Code


value: subtlemuffins

value: Show HN: I wrote my lecture notes in Typst

author: subtlemuffins


value:
Hey everyone!
I recently updated my social impact job website RemotelyGood.us again-- I updated the font site-wide, enhanced the UI on mobile, and am prototyping some agentic features for perfecting your job applications. I need your help and feedback!
In exchange for signing up for premium and premium plus-- then filling out this feedback survey: https://form.jotform.com/251538756931062 -- I am giving out Amazon gift cards. I'll give $5 for Standard Premium, $10 for Premium Plus. Offer is active until November 30.
Thanks in advance for your help on this!

value: Show HN: Get an Amazon Giftcard to Test Premium Features on Remotelygood.us


value: corychu

value:
I built this tiny CLI tool that keeps .venv out of cloud-synced project directories by storing the real env in a centralized cache and symlinking it from the project.
Solving this uv issue: https://github.com/astral-sh/uv/issues/1495
Any feedback is welcome :)

value: Show HN: uvlink – A CLI to keep .venv in a centralized cache for uv

author: corychu


value: Show HN: The Wiki Game - reach target Wikipedia page by clicking hyperlinks only


value: bosschow

value:
Made a silly little project(https://d01.dailyaiship.com/) over the weekend - a virtual camera that uses Google Street View as the viewfinder.
You can adjust all the camera settings (focal length, aperture, ISO, shutter speed) and apply film simulations. It's basically a DSLR simulator but you're shooting street view panoramas instead of real photos.
Built with Next.js, uses Google Street View API for the viewfinder and Static API to capture the actual image. Added some film simulation filters and optional AI enhancement.

value: Show HN: Lenscraft – Shoot Photos from Google Street

author: bosschow


value: ovelv

value: A simple platform that lets website owners publish ad slots and advertisers subscribe to them. Transparent pricing, automated management, no ad networks needed.

value: Show HN: Sell and Subscribe to Website Ad Slots the Smarter Way to Run Ads

author: ovelv


value: Show HN: We cut RAG latency ~2× by switching embedding model


value: johncole

value: Show HN: Scrape Baidu

author: johncole

title: Show HN: Scrape Baidu


value: sumit-paul

value:
I built Banana Studio, an image editor that lets you modify specific regions inside an image using simple text instructions. It runs fully client-side in the browser and uses Google’s Gemini Nano Banana for fast, clean edits.
Demo video: https://youtu.be/-DbDDsyT2MM
Link: https://banana-studio-nano.vercel.app/
Why I built this
Text-only prompts make it challenging to instruct the model precisely where to apply changes, so I developed a simple bounding-box interface that eliminates all the guesswork. The idea was to keep everything lightweight, browser-based, and still get clean, high-quality edits.
How it works
You upload an image, draw a box on the canvas, and type what you want changed. The app maps your box to the 1000x1000 coordinate grid Gemini expects. It then builds a structured prompt telling the model exactly which region to modify, sends it to the API, and gets an image back.
Features
- Edit specific regions by drawing one or more boxes
- Different prompts for different boxes
- Global enhancements when no region is selected
- Works entirely client-side
- Bring your own Gemini API key (stored locally in your browser)
If you want to try it, I would love feedback from the HN crowd.

value: Show HN: Banana Studio – AI Image Editor Powered by Nano Banana

author: sumit-paul


value:
I’ve always tried to stay visible on X and LinkedIn, but doing it manually became a chore. I work a full-time job, and most days I’d be squeezing in replies during breaks or late at night just to keep my profile active. It wasn’t sustainable, and it definitely wasn’t fun.
So I built a tool that generates instant, thoughtful replies directly inside your feed. Instead of spending 30–60 minutes crafting responses, I can now engage in a few seconds without losing authenticity. It uses my tone, follows the context of the post, and removes the friction of staying active online.
I made it for myself first — now I’m sharing it in case it helps others who face the same “I want to be present, but I don’t have the time” problem.

value: Show HN: I built a tool for instant, thoughtful X/LinkedIn replies in your feed


value: tao-hpu

value: Show HN: Cognitive Workspace – Active Memory Management for LLMs

author: tao-hpu


value: Show HN: DuckDuckGo Search Results Scraper


value:
Hi everyone,
I’m a solo developer and I’ve been working on a small tool called Echosnap AI. I built it because I often get ideas while I’m walking or doing something else, and speaking always felt like the fastest way to capture them.
Echosnap lets you record a note and instantly get a clean transcript. It can also translate your recordings and help you stay organized with tags and folders. I tried to keep the app as simple and minimal as possible.
This is my first time sharing something on HN, so any feedback or suggestions would mean a lot. Thanks for taking a moment to check it out.

value: Show HN: Echosnap AI – A simple voice-first notes app


value: Show HN: 1-of-1 AES Encryption Objects (Not-Cross-Decryptable)


value: zephyrrd

value:
Hi guys, I just released a beta version of Pixeli, a lightweight open-source CLI for merging images into clean, customizable layouts. It’s perfect for creating image grids, Pinterest-style masonry collages, or contact sheets, all tailored for your specific project use case. For more details, check out the complete documentation.
Some basic features include:
Merging images into grids or masonry layouts, setting up per-image aspect ratios, gaps, background color, and captions, and shuffling images for random layouts.
The tool supports JPG, PNG, WebP, SVG, and AVIF. It also uses the npm module Sharp, a Node.js wrapper around the libvips library written with C, ensuring extremely high performance rates.
This project was created with love and submitted to Hackclub Midnight at https://midnight.hackclub.com
Let me know what you guys think or if you spot any problems :) always do appreciate some constructive criticism

value: Show HN: Pixeli – The CLI Tool for Creating Beautiful Image Grids and Mosaics

author: zephyrrd


value: flabberghasted

value: Show HN: AI search context engine for startups and engineering teams

author: flabberghasted


value: mvphauto

value:
Colonet - Anonymous forum, no sign-up needed.
Made with:
- Cloudflare Workers, Cloudflare D1
- Hono
- React, React Router v7
- Tailwind CSS, daisyUI
Enjoy!

value: Show HN: Colonet – Anonymous forum, no sign-up needed

author: mvphauto


value: Show HN: BreakToGoal – A planner calendar that break big goals into tasks


value: Mikecraft

value:
Hi Everyone,
I recently wanted to learn Japanese with duolingo but it kept giving me repetitive lessons. So I built an app that gives a variety of lessons from anime.
You can try it out here:https://kanjieight.vercel.app/
Thanks everyone.

value: Show HN: I built the literal Duolingo Killer

author: Mikecraft


value: EGF-Format

value: Show HN: EGF – an open file format for educational games

author: EGF-Format


value: gdcbe

value:
In Episode 15 of netstack.fm, I sat down with Edward and Noah from Cloudflare to unpack the design of Pingora, the Rust based proxy framework that now powers Cloudflare’s origin facing traffic. The discussion covers why Cloudflare moved away from NGINX, how Pingora differs from Oxy, and what it takes to operate a high performance global proxy at massive scale. Listeners will learn about connection reuse strategies, dynamic traffic handling, gRPC and protocol translation, custom HTTP implementations, TLS backend choices, and the practical trade offs of Rust, Tokio, and work stealing in real production systems. It is an episode full of deep technical insights into building and operating modern networking infrastructure.
Note that this episode was recorded prior to the recent cloudflare outage and as such this is not something we discussed in the episode. If you are interested to learn more about that I can recommend their excellent post-mortem blog post which already circulated around here. See: https://news.ycombinator.com/item?id=45973709

value: Show HN: Pingora with Edward and Noah from Cloudflare (Netstack.fm Podcast Ep15)

author: gdcbe


value: novoreorx

value: While using iTerm2 while busy working today, I once again felt frustrated by having too many tabs and losing the overall perspective of what tasks were in progress. So, I used v0 + Opus 4.5 to envision an ideal Terminal tab management UI in my mind, to demonstrate the best way for me to manage tabs in the terminal. What do you think?

value: Show HN: How I think tabs should be managed in a terminal

author: novoreorx


value: jksalcedo

value:
PassVault is a lightweight password manager that allows users to securely store credentials on their device. All data is stored locally and sensitive information is encrypted using the Android Keystore system. The application does not require internet permissions. User data never leaves the device.
Core Features

    Secure PIN Authentication
    Biometric (Fingerprint) Login
    Encrypted Database (AES-256)
    Argon2Kt for file encryption
    Add, View, Edit, & Delete Passwords
    In-app Password Generator
    Encrypted Import/Export (for backups and transfer)
    Encrypted Automatic Backups
    Import from KeePass (using kotpass)/Bitwarden

value: Show HN: PassVault – A secure, lightweight, and offline Android password manager

author: jksalcedo


value: Show HN: I built a lightweight LLM workflow with only JavaScript and Code hooks


value:
I was working on a multiplayer racing game and kept hitting the same issues. State desyncs where players would see different positions. Race conditions when two players interacted with the same object. The usual stuff.
The frustrating part was that these bugs only showed up with multiple real players. Can't reproduce them locally, can't easily test fixes, and adding logging changes the timing enough that bugs disappear.
After rebuilding networking code for the third time across different projects, I noticed something: most multiplayer bugs come from thinking about networking instead of game logic.
## The approach
In single-player games, you just write:
```typescript
player.x += velocity.x;
player.health -= 10;
```
So I built martini-kit to make multiplayer work the same way:
```typescript
const game = defineGame({
  setup: ({ playerIds }) => ({
    players: Object.fromEntries(
      playerIds.map(id => [id, { x: 100, y: 100, health: 100 }])
    )
  }),<p><pre><code>  actions: {
    move: (state, { playerId, dx, dy }) => {
      state.players[playerId].x += dx;
      state.players[playerId].y += dy;
    }
  }</code></pre>
});
```
That's it. No WebSockets, no serialization, no message handlers. martini-kit handles state sync, conflict resolution, connection handling, and message ordering automatically.
## How it works
Instead of thinking about messages, you think about state changes:
1. Define pure functions that transform state
2. One client is the "host" and runs the authoritative game loop
3. Host broadcasts state diffs (bandwidth optimized)
4. Clients patch their local state
5. Conflicts default to host-authoritative (customizable)
Those race conditions and ordering bugs are structurally impossible with this model.
## What's it good for
- Turn-based games, platformers, racing games, co-op games: works well
- Fast-paced FPS with 60Hz tick rates: not ideal yet
- Phaser adapter included, Unity/Godot adapters in progress
- Works with P2P (WebRTC) or client-server (WebSocket)
- Can integrate with Colyseus/Nakama/etc for matchmaking and auth
## Try it
[Interactive playground](https://martini.blueprintlab.io/preview) - test multiplayer instantly in your browser
Or install:
```bash
npm install @martini-kit/core @martini-kit/phaser phaser
```
Links:
- Website: https://martini.blueprintlab.io/
- Docs: https://martini.blueprintlab.io/docs
- GitHub: https://github.com/BlueprintLabIO/martini
- npm: https://www.npmjs.com/package/@martini-kit/core
Open to feedback and curious if anyone else has hit similar issues with multiplayer state management.

value: Show HN: Martini-Kit, create multiplayer games without writing networking code


value: Show HN: Chess960v2 – The New Fischer Random Chess (over 400 rounds played)


value: andsko

value: Show HN: Words that help me think

author: andsko

title: Show HN: Words that help me think


value: TalO

value:
Hi HN — I built JobStocks.ai, a dashboard that tracks real-time hiring momentum (job postings) across 1,000+ public companies and maps hiring trends vs stock performance.
What it surfaces:
- AI-generated company insights based on hiring acceleration/deceleration.
- Exclusive alternative data: normalized hiring activity across industries and peers.
- Signals before the market reacts (e.g., sudden hiring freezes, unexpected team expansions).
- Hiring trends are compared directly to stock trends to highlight divergences that may matter later.
Why I built it: alternative data that’s fast and actionable — hiring is often a leading indicator for revenue/cost trajectory, but is hard to track across public filings. I’d love honest feedback on the UI, the signals, and how analysts might use this data.

value: Show HN: Jobstocks.ai – Live hiring momentum for 1k public companies

author: TalO


value: mimixbox

value:
tornago is a Tor wrapper library written in Go, created because some tools — especially around fraud prevention and privacy — need safe, anonymized network routes.
It’s intended for production use, but it hasn’t seen enough real users yet, so there are bugs that will only surface through actual deployments.
Highlights
- Works on Windows, macOS, Linux, and BSDs (FreeBSD, OpenBSD, NetBSD, DragonFly)
- Supports both client and server, including .onion Hidden Services
- Manages the tor daemon lifecycle + SOCKS5 communication
I’d like to see it tested in real projects — whether that’s fraud investigation, anonymous crawling, privacy-focused services, or simply protecting your own identity when accessing the network.
If Tor reliability matters to your system, try it and let me know what breaks. Issues and PRs are welcome.
GitHub: https://github.com/nao1215/tornago

value: Show HN: Tornago – Cross-platform Tor wrapper in Go (client and server)

author: mimixbox


value:
1. keep em talkin
2. keep on learnin
3. make em pay

value: Show HN: Free LLM System–-Prompt

title: Show HN: Free LLM System–-Prompt


value: staloriana

value:
I built a small, cache-optimized B+Tree storage engine for .NET called BTreePlus.
The goal wasn’t to build a general database but to explore how far a minimal, modern B+Tree design can go when tuned for CPU-cache behavior, small fixed-size pages, and predictable read/write paths.
In my benchmarks (linked in the repo), BTreePlus shows better throughput than SQLite and Postgres for specific key-value style workloads—mainly:
- single-key point lookups
- sequential inserts with small pages
- read-heavy scenarios without complex SQL layers
I’d love feedback from database and systems engineers on:
- the page layout / split-merge logic
- the latching model
- whether the design avoids classic B-Tree pitfalls
- benchmarking methodology (happy to adjust or rerun)
NuGet: https://www.nuget.org/packages/BTreePlus

value: Show HN: BTreePlus – A cache-optimized B+Tree engine for .NET faster than SQLite

author: staloriana


value: machinewriter

value:
I built ChimeraDB to stop juggling three separate databases when building LLM apps. It combines vector embeddings, property graphs, and SQL analytics in a single DuckDB file.

    from chimeradb import KnowledgeGraph
    kg = KnowledgeGraph("my.db")

    # Semantic search - find by meaning
    results = kg.search("who works on language models?")

    # Graph traversal - follow relationships
    employees = kg.traverse("acme", direction="incoming")

    # SQL analytics - aggregate data
    stats = kg.query("SELECT company, COUNT(*) FROM nodes...")

Why it's useful:
- RAG needs semantic search + relationship context
- AI agents need graph traversal + analytical queries
- Combine all three in a single SQL query
Zero infrastructure: One file, runs anywhere, 10-100x faster than SQLite for analytics.
Built on DuckDB + duckpgq + vss extensions. MIT licensed.

    pip install chimeradb

GitHub: https://github.com/codimusmaximus/chimeradb

value: Show HN: ChimeraDB – Vector search, graph queries and SQL

author: machinewriter


value:
I built an open-source malware detection daemon that monitors all running processes in real-time using ML + heuristics. No kernel modules or eBPF required.
Key points:
- Polls /proc for new processes (works on any Linux kernel 2.6+)
- Random Forest model trained on EMBER 2018 dataset (2.3M samples)
- Heuristic rules for crypto miners, ransomware, rootkits
- ~20MB RAM, <1% CPU, sub-millisecond scan latency
- Pure C, zero runtime dependencies
- Model embedded directly in binary (50KB)
Why I built this:
Existing solutions either require modern kernels (eBPF) or are heavy/proprietary.
I wanted something lightweight that works everywhere - servers, containers, old distros.
Detection approach:
Extract features from executables (entropy, imports, sections), run ML prediction, apply heuristic rules, combine scores.
If above threshold, kill the process.
Happy to discuss implementation details or Linux security in general.

value: Show HN: Deft-Intruder – Real-time malware detection daemon for Linux


value: daylankifky

value: Show HN: I mapped my portfolio into latent space (code included)

author: daylankifky


value: oliverkzh

value: Show HN: Loglast – Track the last time you did X

author: oliverkzh


value: quantumHashMap

value:
Hi HN! I built PoliSciPy, an open-source Python package for quickly generating customizable, publication-quality U.S. Electoral College maps using matplotlib.
I designed it to be flexible and easy to use: you can merge your own data, define custom colormaps for parties or candidates, and generate maps (including for historical elections) in under 10 lines of code.
Under the hood, I edited a US Census Bureau Shapefile in ArcGIS, applied transformations, computed centroids for labeling, and added some extra features for styling and customization.
PyPI: https://pypi.org/project/poliscipy/
GitHub: https://github.com/poliscipy/poliscipy
Docs: https://poliscipy.github.io/poliscipy/
I would love any feedback on API design, performance, or features you would like to see. I had a lot of fun building it and am happy to answer any questions!

value: Show HN: PoliSciPy – A Python library for making Electoral College maps

author: quantumHashMap


value: ethanYIAI

value: DND Character Creator is an AI-powered tool that instantly generates complete Dungeons & Dragons 5e characters. It produces ability scores, skills, class features, backgrounds, personality traits, and rich backstories with minimal input. Perfect for new players, busy DMs, and creators seeking fast inspiration for campaigns or one-shots.

value: Show HN: Dnd Character Creator

author: ethanYIAI

title: Show HN: Dnd Character Creator


value: Show HN: Bindu – an auth, payment, and communication layer for AI agents


story_text:
I built an open-source malware detection daemon that monitors all running processes in real-time using ML + heuristics. No kernel modules or eBPF required.
Key points:
- Polls /proc for new processes (works on any Linux kernel 2.6+)
- Random Forest model trained on EMBER 2018 dataset (2.3M samples)
- Heuristic rules for crypto miners, ransomware, rootkits
- ~20MB RAM, <1% CPU, sub-millisecond scan latency
- Pure C, zero runtime dependencies
- Model embedded directly in binary (50KB)
Why I built this:
Existing solutions either require modern kernels (eBPF) or are heavy/proprietary.
I wanted something lightweight that works everywhere - servers, containers, old distros.
Detection approach:
Extract features from executables (entropy, imports, sections), run ML prediction, apply heuristic rules, combine scores.
If above threshold, kill the process.
Happy to discuss implementation details or Linux security in general.

title: Show HN: Deft-Intruder – Real-time malware detection daemon for Linux


value: Show HN: I analyzed 5k comments to quantify the Jira vs. Linear sentiment gap


value: vlejd

value:
To get benefits from sparsity, you usually need to have very sparse matrices, impose some structure on the sparsity pattern or have specialized hardware. None of it is the case if you want to rune pruned LLMs on consumer devices.
I wanted to see how far can you push it on a GPU and ended up with this.
Blog: https://www.grizzlytech.dev/blog/macko-spmv
Paper: https://arxiv.org/abs/2511.13061
Code (example with torch): https://github.com/vlejd/macko_spmv

value: Show HN: Sparse Matrix-Vector Multiplication that works at 30–90% sparsity

author: vlejd


value: Show HN: A modern Papaparse for big remote CSV


value: yiyiyayo

value: Show HN: A Tool for Extracting Local B2B Leads

author: yiyiyayo


value: seng

value:
My team came to me: "We can't estimate this project. We don't understand how the system works."

  We'd inherited a decade-old Yii2 codebase. Two previous teams had tried and failed to modernize it. The code followed proper patterns—ORM, fat models, MVC—but one feature would
  touch 40+ files across 8 layers. Original developers gone. Docs from 2019.

  Cursor and Claude Code couldn't help. They're brilliant at individual files, but they can't see how features connect across hundreds of files. Limited context windows. No memory
  between sessions.

  So I vibe-coded something to solve it. Not a professional dev—founder desperation.

  18 months later, it's CodeCompass:
  - Maps capabilities to scattered code
  - Traces logic across layers
  - Answers "how does X work?" in seconds
  - Gives AI assistants persistent context

  Open sourced it. Every enterprise I talk to has this same problem.

  https://pearlthoughts.com/codecompass

value: Show HN: I vibe-coded a tool to decode a legacy system nobody understood

author: seng


value: Show HN: Fractalbits – S3 compatibe store，1M iops p99～5ms，using Rust and Zig


value: Crroak

value: Show HN: A seeded, deterministic chaos simulation runtime for async Rust

author: Crroak


value: truetotosse

value: I built this because I couldn't find a tool to handle complex bill splitting (multiple payers) without need to download an app. It uses local OCR to scan receipts and runs entirely in the client. No data leaves your browser.

value: Show HN: Smart Bill Splitter: Split bills in browser without login, ads, cookies

author: truetotosse


value: jasonthorsness

value:
I wrote an SVG editor and physics simulation to determine how pieces connected by rigid rings will dangle when hung. I was surprised at how well the simulation actually predicted reality!
This was done with a lot of help from Gemini over last week (so half with the upgrade).
Main link is an explanatory article.
Here's the live app:
https://jasonthorsness.github.io/tree-dangler/
And source:
https://github.com/jasonthorsness/tree-dangler

value: Show HN: Tree Dangler

author: jasonthorsness

title: Show HN: Tree Dangler


value: satssehgal

value:
Hi HN — I built Product Loop because I found customer interviews slow, inconsistent, and hard to keep up with. Scheduling calls, chasing users, and taking notes was eating hours every week.
Product Loop runs automated voice interviews with your users, asks follow-up questions, and summarizes the insights so you know what to build next.
Here’s how it works technically:
Uses an AI voice agent for natural conversation
Runs in the browser (no app install)
Extracts themes, pain points, and feature requests
Generates a structured interview summary
You can trigger interviews via link or email
Would love feedback from this community — especially on:
What’s unclear in the UX
What feels unnecessary
Whether the AI interviewer feels natural enough
Any technical improvements you'd recommend
Check it out: https://productloop.io
Happy to answer anything.

value: Show HN: Product Loop – Automated AI customer interviews

author: satssehgal


value: alielroby

value:
Hello HN, I updated the free tool to help founders validate their startups. It currently allows founders to vote on other founder startups like Hot or not .com.
The backstory: I’ve applied to YC 3 times now. I actually haven’t received a response yet, which makes it very difficult to know what to adjust.
Since YC doesn't provide any feedback, I built this feature to allow founders to validate and get feedback on their startup from the community. We also have the ability for founders to comment on each idea and a leaderboard with the best startups.
I hope this helps you get the validation you need.
Would love to hear your feedback or if there are other features I should add.

value: Show HN: Get instant feedback on your startup idea for YC.

author: alielroby


value: warrowarro

value: I wanted to mess around with MediaPipe and Three.js, so I built this hand tracking thing that runs entirely in your browser. Point your webcam at your hands and it draws a cyberpunk-style skeleton over them in real-time. No server needed, everything processes locally. The trickiest part was getting the coordinate mapping right so the skeleton actually lines up with your hands and doesn't jitter all over the place. Anyway, thought it was cool enough to share. Let me know what you think!

value: Show HN: A browser tool that tracks your hands in real-time

author: warrowarro


value: marcushyett

value:
got tired of paying for email verification saas like usebouncer.com, expensive at scale and often say emails are valid when the server sends accept to anything.
built a simple npm package that does format + dns + smtp checks, plus detects those catch-all domains.

  npx email-verifier-check check user@example.com
  https://github.com/yolodex-ai/email-verifier

any feedback appreciated.

value: Show HN: Open-Source Email Verifier

author: marcushyett

title: Show HN: Open-Source Email Verifier


value:
tars communication protocol (just a cool name, i love it). it is a terminal based voip service. yes there are a lot of clients but i wanted a cool one.
you can even integrate this service to make your own client. the core service runs as a linux service, use dbus to communicate with it.
i made this project for Hack Club's Midnight hackathon.
NOTE: I AM FINALISING A FEW THINGS ON THE SERVER SIDE YOU WOULD HAVE TO HOST THE SERVER LOCALLY BY YOURSELF.

value: Show HN: A terminal based voice over IP service


value: lastFitStanding

value: Show HN: I made an AI SEO tool for people who hate writing content

author: lastFitStanding


value: woozyrabbit

value:
I spent the last week building a local-first security tool because I was tired of paying $500/mo for enterprise SaaS just to test my AI agents for basic vulnerabilities.
The tool is called Agent Exam Pro. It's a Python-based fuzzer that runs locally on your machine (no cloud data leaks).
How it works:
The Engine: Takes a base test case and runs it through 16 mutation strategies (Base64, Roleplay, Token Smuggling) to generate 1,000+ variations.
The Payloads: I curated 280+ real-world exploits from open-source lists (PayloadBox, PayloadsAllTheThings) to test for SQLi and XSS in agent tool calls.
The Judge: Uses a local LLM (via Ollama) or OpenAI to grade responses on safety rather than just regex matching.
The Audit: Logs everything to a local SQLite database.
I'm selling the source code as a one-time purchase (no subscriptions) because I prefer owning my tools.
You can check it out here: https://woozymint.gumroad.com/l/agent-exam-pro

value: Show HN: I built a local fuzzing tool to red-team LLM agents (Python, SQLite)

author: woozyrabbit


value: aroussi

value:
I wrote this because I kept watching the same mistakes: Teams chain
prompts, call it "agentic," then wonder why everything breaks under
real-world pressure.
The book covers what actually works: memory systems, orchestration
patterns, multi-agent coordination, observability, and real examples
from systems that actually ship.
Download the first 3 chapters (no email): https://productionaibook.com/hn
I'd love to hear your production AI war stories. What's actually
breaking? What patterns have you discovered?
Giving away 15 copies to the most insightful comments.

value: Show HN: I wrote a book for engineers building production AI systems

author: aroussi


value:
We built a marketplace where you pick an AI agent for your task and get professional results instantly.
How it works:
Browse our gig board of specialized AI agents
Select the agent that fits your needs
Submit your task
Get professional results back immediately
What's live:
10+ writing gigs (all powered by AI agents)
Instant execution and delivery
What's coming:
Image generation gigs
Video gigs
Audio gigs
Think of it as Fiverr but every service is an AI agent ready to execute on demand.
Would love to hear what services you'd want to see.
botigigs.com

value: Show HN: AI Gigs Marketplace

title: Show HN: AI Gigs Marketplace


value: elikoga

value: A webapp to manage multiple devices that allows you to create ready to use images and deploy custom software.

value: Show HN: Thymis – IoT fleet management with NixOS

author: elikoga


value: hugofromboss

value:
Hey HN!
We are building Thand, an open-source, distributed platform for Just-in-Time (JIT) access, authorization (PAM), and provisioning.
Why?
I’ve been at various companies now; either having to raise tickets, waiting on internal processes to get access to systems, resources or SaaS tools. Or, having extremely elevated accounts all in one place and as a single point of failure when services go down just as you need them. None of the available PAM tools seemed easy to work with, so it got me seeking an alternative.
What is Thand?
Thand is a lightweight, open source and self-hosted agent that runs locally or in your cloud environment. It orchestrates and distributes requests via durable workflows (via Temporal and CNCF Serverless workflows) to grant temporary access to resources or provision resources via its “providers”.
Unlike other tools, that are locked into particular cloud environments or SaaS providers. With Thand you deploy the agents with their respective access. Wherever, you need to get access to. Temporal can route the workflow execution to elevate or provision resources across multiple environments (cloud and local) and identities.
What's with the name?
Thand is Sindarin, (‘Shield/Guard of the Forest’).
We are currently in preview and looking for feedback.
GitHub: https://github.com/thand-io/agent
Docs: https://docs.thand.io
Website: https://www.thand.io/
Thanks!

value: Show HN: Thand – open-source, distributed, JIT, PAM and provisioning platform

author: hugofromboss


value: evrimsel

value: Especially valuable for those in e-commerce. You can use one service for price monitoring, stock monitoring, and all uptime monitoring tools together.

value: Show HN: A single tool for all web monitoring needs

author: evrimsel


value: romforth

value:
romforth is a dialect of Forth which is meant to be easily portable.
The IBM 1130 holds a special place in Forth history since it was one of the earliest systems on which Chuck Moore prototyped his initial versions of Forth.
I wanted to retrace Chuck Moore's footsteps as he created Forth on the IBM 1130 and decided to try porting romforth to the IBM 1130 (using the excellent SIMH/ibm1130 simulator available from https://github.com/open-simh/simh)

value: Show HN: Romforth Ported to the IBM 1130

author: romforth


value: hazzadous

value:
friend and i were curious what's actually involved in email verification services like usebouncer.com. turns out the basics aren't that complicated.
vibe coded a simple npm package in (mostly) one shot that does:
- syntax validation
- mx record lookup
- smtp mailbox check (without sending emails)
- catch-all domain detection

  npx email-reachable user@example.com

https://github.com/yolodex-ai/reachable
works as a library too:

  import { verifyEmail } from 'email-reachable'
  const result = await verifyEmail('user@example.com')

bouncer probably does way more, feedback welcome.

value: Show HN: Email Verifier CLI/Library

author: hazzadous

title: Show HN: Email Verifier CLI/Library


value: damnhotuser

value:
Hey there,
Since I learned about property-based testing a couple of years ago, I always wondered: whouldn't it be a nice fit for testing unpredictable systems such as frontend components?
Most of the bugs we stumble upon as frontend devs are related to usecases we did not think about while developing our components, or while testing it. The idea of fast-check-frontend is basically to generate sequences of random (yet customizable) user interactions (clicks, keyboards events, scrolls, hovers, etc...), to dispatch them to DOM elements, and to validate invariants (things that should always be true after interactions).
The lib is framework agnostic, should work with any test-runner (only tried with Jest yet), and relies on the shoulder giants: fast-check and @testing-library.
This is still WIP, but any constructive feedbacks  would still be appreciated.

value: Show HN: fast-check-frontend – Property-based testing for UI components

author: damnhotuser


value: dannylmathews

value: Show HN: Antler – An IRL Browser

author: dannylmathews

title: Show HN: Antler – An IRL Browser


value: KylieM

value:
GitHub’s built-in analytics are misleading. They treat all lines equally, ignore work type differences, and are easy to game.
I created a free Google Sheets tool that provides fair, nuanced evaluation of contributions.
The problem it solves:
GitHub: “Developer A has 1,913 additions” → appears to be top contributor
This tool: “Developer A: 1,810 pts (40% features, 32% bug fixes, 10% testing)” → shows actual work composition and value
Smart features:
 • Automatically excludes starter code and library imports
 • Skips merge commits (no credit for just combining branches)
 • Minimum line thresholds prevent gaming
 • Tracks net changes (editing same lines repeatedly doesn’t inflate score)
 • Uses GitHub username to prevent duplicate entries
Use cases: CS course grading, team analytics, recognizing diverse contribution types beyond just code
Free, open source, runs entirely in Google Sheets (no installation).
https://github.com/kyliemckinleydemo/github-contribution-tra...

value: Show HN: Smart GitHub Contribution Tracker – Fair analysis beyond line counts

author: KylieM


value: jarlen

value: Show HN: AlgoVoice – Voice-based mock technical interviews for L3-L4 roles

author: jarlen


value: sfaist

value:
If you've ever worked in a large company, you've probably encountered "shadow infrastructure": scripts nobody understands or custom connectors written once and never touched again. This glue layer isn't documented, isn't owned by anyone, and tends to break when systems are upgraded or someone leaves. It's also the part everybody dreads working on, because it's hard to understand, painful to work with, and full of unknown unknowns.
We built superglue so that engineers stop wasting time on deciphering legacy APIs and documentation.
superglue ingests existing glue code, SQL, configs, docs, OpenAPI specs and reverse-engineers what the system is actually doing. It then maps dependencies and regenerates everything as clean javascript code that can run directly or be exposed via MCP or SDK. It also monitors API changes and schema drift, and automatically repairs integrations when upstream systems change.
In short: It turns legacy integrations into code you can easily understand, test, and update. So that engineers can do more exciting feature work, and companies can migrate and upgrade systems faster.
Think of it as: a context engine + code generator + integration runtime for legacy glue.
What we'd love feedback on
- How do you deal with "nobody knows what this script does" situations?
- What would you want to know about your legacy systems?
OSS/community version: https://github.com/superglue-ai/superglue
More info: https://superglue.ai
Happy to go deeper on the technical details.

value: Show HN: Superglue – OSS integration tool that understands your legacy systems

author: sfaist


value:
Hey HN! We built Agent Runner, a model-agnostic, open-source agent harness that executes the same prompt against two anonymized coding agents in parallel sandboxes. Each agent can make tool calls, edit multiple files, and self-correct through iterative reasoning. You pick the better result - this becomes the ground truth for the leaderboard.
Why we built it
Traditional benchmarks often fall short for modern agentic systems: they rely on static tasks and only measure final outputs. But real coding agents modify multiple files across a repo, answer to user re-prompts, use tool calls, and recover from partial failures
What Agent Runner does
You ask it to build anything
Agent Runner kicks off two generations from different sandboxed LLM providers (OpenAI, Anthropic, Google, xAI, Mistral, Kimi, and more)
Anonymized models make tool calls, multi-file edits, and cater to reprompts
You pick your favorite - this preference powers the benchmark
Because different providers handle tool calls, prompts, and execution semantics differently, we worked with each provider to ensure configurations reflect intended behavior. These provider-specific setups remain private, but Agent Runner itself is open-source.
How to try it
Kick off Agent Runner at https://www.designarena.ai/agentarena
Repo at https://github.com/Design-Arena/agent-runner
Use it as a CLI tool: https://pypi.org/project/agent-runner/
pip install agent-runner
agentrunner run “create a nextjs replica of Discord”
We hope this provides a provider-agnostic, framework-agnostic, realistic benchmark for state-of-the-art coding agents.
Video demo: https://youtu.be/rdtiuCHatjs

value: Show HN: Agent Runner – open-source agent harness to benchmark real coding


value: lluiscanadell

value:
Hi HN! made a vibe coding platform with the non-technical user in mind. This means that you don’t have to integrate Supabase, Auth0, it’s automatic. Our goal is to soon also provide email, payments, and other integrations automatically. We target SMB owners and entrepreneurs.
We will differentiate by talking non-technical, hide code most of the time, friendly consumery UX and support
Made pricing also simpler: 1 credit = 1 prompt (drives me nuts when in other platforms you don’t know what you’re paying for)
Would love any thoughts!

value: Show HN: Idealane – Intuitive vibe coding for entrepreneurs and SMBs

author: lluiscanadell


value: loning

value: Show HN: Deriving General Relativity from Finite Information (Open Source)

author: loning


value: I built this to test how production LangChain agents handle failures. It injects random exceptions into tool/model calls at configurable rates. Testing agent resilience is hard. This lets you simulate real-world failures (network issues, rate limits, service outages) in a controlled way.

value: Show HN: Chaos Monkey middleware for LangChain (v1) agents


value:
Hi HN, Zidan here.
I’ve been experimenting with AI-assisted debugging and noticed a recurring gap: most tools optimize for agent-led exploration (ex: giving claude code a browser to click around and try to reproduce an issue). But in many cases, I've already found the bug myself. What I actually want is a way to hand the agent the exact context I just saw - without retyping steps, copying logs, or hoping it can reproduce the behavior.
So we built FlowLens, an open-source MCP server + Chrome extension that captures browser context and lets coding agents inspect it as structured, queryable data.
The extension can:
- record specific workflows, or
- run in a rolling “session replay” mode that keeps the last ~1 minute of DOM / network / console events in RAM.
If something breaks, you can grab the “instant replay” without reproducing anything.
The extension exports a local .zip file containing the recorded session.
The MCP server loads that file and exposes a set of tools the agent can use to explore it.
One thing we focused on is token efficiency. Instead of dumping raw logs into the context window, the agent starts with a summary (errors, failed requests, timestamps, etc.) and can drill down via tools like:
- search_flow_events_with_regex
- take_flow_screenshot_at_second
It can explore the session the way a developer would: searching, filtering, inspecting specific points in time.
Everything runs locally; the captured data stays on your machine.
Repo: https://github.com/magentic/flowlens-mcp-server

value: Show HN: A better way to handoff web bugs to AI agents


value: thenodeshift

value: Show HN: worldclock.me — Super-fast multi-timezone event planner

author: thenodeshift


value: allthreespies

value:
I've been recreating the original MacPaint in the browser on and off for a few years. It's still alpha quality, but I'm finally ready to share it more widely.
The goal was pixel-perfect accuracy, so I spent a lot of time with Atkinson's original QuickDraw source code, emulators, and my iBook G3 to get details like font rendering and the shape tools exactly right.
Some technical notes:
- Font rendering was surprisingly tricky; understanding the original pipeline's quirks took lots of experimentation, and avoiding canvas smoothing/aliasing required careful handling.
- Written declaratively with React; performance is kept reasonable with a buffer pool and copy-on-write semantics. - You can share links to artwork from within the UI.
E.g.: https://zenpaint.org/#p=KQumBQ5x
- Mobile support was not considered here (for obvious reasons). It might still be usable on a larger phone or tablet but I have not tested this at all.
There's something magical about making art within MacPaint's constraints: the 1-bit graphics, the limited resolution, the peculiar set of tools that still feel surprisingly expressive.
Still some rough edges and missing features, but I'd love feedback from anyone who remembers the original.

value: Show HN: ZenPaint, a pixel-perfect MacPaint recreation for the browser

author: allthreespies


value: ViktorKuz

value:
I’ve been working on an independent memory-retrieval architecture for agent systems. I don’t have a CS background — previously worked climbing cell towers and doing handyman jobs — but I spent the last 4.5 months building a hybrid memory system from scratch.
The system combines FAISS, BM25, and a symbolic ranking layer (MCA). Answers are generated with GPT-4o-mini at temperature 0. The focus is determinism, transparency, and reproducibility rather than model size.
On the official LoCoMo benchmark (1,540 questions), the system reaches 80.1% average accuracy. To my knowledge, that’s above the publicly reported results for existing agent-memory stacks using small models.
Latency is ~2.5 seconds, and cost is ~$0.10 per 1M tokens. Memory is fully isolated and local, which makes it usable for offline or enterprise applications.
Repository (code + full reproducible benchmarking):
https://github.com/vac-architector/VAC-Memory-System
Happy to answer technical questions, discuss the architecture, or hear critiques.

value: Show HN: Memory System Hitting 80.1% Accuracy on LoCoMo (Built in 4.5 Months)

author: ViktorKuz


value: agreeahmed

value:
Hi HN! For the past bit we’ve been building Flowglad (https://flowglad.com) and can now feel it’s just gotten good enough to share with you all:
Repo: https://github.com/flowglad/flowglad
Demo video: https://www.youtube.com/watch?v=G6H0c1Cd2kU
Flowglad is a payment processor that you integrate without writing any glue code. Along with processing your payments, it tells you in real time the features and usage credit balances that your customers have available to you based on their billing state. The DX feels like React, because we wanted to bring the reactive programming paradigm to payments.
We make it easy to spin up full-fledged pricing models (including usage meters, feature gates and usage credit grants) in a few clicks. We schematize these pricing models into a pricing.yaml file that’s kinda like Terraform but for your pricing.
The result is a payments layer that AI coding agents have a substantially easier time one-shotting (for now the happiest path is a fullstack Typescript + React app).
Why we built this:
- After a decade of building on Stripe, we found it powerful but underopinionated. It left us doing a lot of rote work to set up fairly standard use cases
- That meant more code to maintain, much of which is brittle because it crosses so many server-client boundaries
- Not to mention choreographing the lifecycle of our business domain with the Stripe checkout flow and webhook event types, of which there are 250+
- Payments online has gotten complex - not just new pricing models for AI products, but also cross border sales tax, etc. You either need to handle significant chunks of it yourself, or sign up for and compose multiple services
This all feels unduly clunky, esp when compared to how easy other layers like hosting and databases have gotten in recent years.
These patterns haven’t changed much in a decade. And while coding agents can nail every other rote part of an app (auth, db, analytics), payments is the scariest to tab-tab-tab your way through. Because the the existing integration patterns are difficult to reason about, difficult to verify correctness, and absolutely mission critical.
Our beta version lets you:
- Spin up common pricing models in just a few clicks, and customize them as needed
- Clone pricing models between testmode and live mode, and import / export via pricing.yaml
- Check customer usage credits and feature access in real time on your backend and React frontend
- Integrate without any DB schema changes - you reference your customers via your ids, and reference prices, products, features and usage meters via slugs that you define
We’re still early in our journey so would love your feedback and opinions. Billing has a lot of use cases, so if you see anything that you wish we supported, please let us know!

value: Show HN: We built an open source, zero webhooks payment processor

author: agreeahmed


value: tonyhb

value:
Hi HN! I’m Tony, one of the co-founders of Inngest (https://inngest.com/).  Wanted to show you something we’re working on: StepKit.
StepKit is an open source SDK and framework for building and iterating on durable workflows that run on any platform (self-hosted, Inngest, Cloudflare, Netlify, etc.) without requiring any provider or bundler-specific code.
Here’s the repo: https://github.com/inngest/stepkit.
StepKit extracts the core execution loop that we built in Inngest and makes it fully open, Apache 2, and hackable/pluggable to different backends.  We don’t want people to have to go through multiple major versions in SDKs to learn the lessons we’ve already learned in production:
It needs to work anywhere: This SDK is push-based and receives tasks via API endpoints, so it works anywhere (servers, serverless, k8s, etc).  That's also customizable.  It doesn’t need any specific runtime or bundler support.
It needs to be complete: StepKit includes the entire execution engine: step discovery, memoization, a core event loop to turn async steps into generators without relying on `try/catch` based control, and middleware for extensibility (eg, end-to-end encryption, Sentry integrations, and so on).
It needs a simple API: StepKit APIs are explicit `step.*()` functions, which we designed in our original Inngest SDK back in 2022.  They’re easy to read, understand, implement, and use.  They contain all of the primitives for durable execution: steps, suspend/resume, human-in-the-loop, and observability.  These same APIs have also been adopted by Cloudflare, Netlify, Convex, and others, and support billions of runs every month.
It needs to be resilient: Steps tolerate changes when refactoring, and provide the building blocks of durable execution without complex abstractions.
We’re starting with in-memory, filesystem, Inngest, and Cloudflare (WIP) drivers, with more coming soon.
The roadmap includes middleware, compatible SDKs in different languages, as well as extensions like concurrency controls and idempotency: https://github.com/inngest/stepkit/discussions/52.
Excited to see what you think:  https://github.com/inngest/stepkit.

value: Show HN: StepKit, an open and cross-platform durable execution standard

author: tonyhb


value: vyntral

value:
Hi HN! I built God's Eye, an AI-powered subdomain enumeration tool that combines
traditional recon techniques with local LLM analysis.
What makes it different:
- 100% local & private - no data leaves your machine
- Zero API costs - uses Ollama with models like DeepSeek-R1 and Qwen2.5-Coder
- 20 passive sources (crt.sh, Certspotter, AlienVault, etc.)
- AI analysis of discovered subdomains for security insights
- Written in Go for speed
I built this because most subdomain tools just dump lists without context.
Adding AI analysis helps identify interesting targets faster during pentests
and bug bounties, but I wanted to keep everything local for privacy and cost.
The AI features are optional - you can use it as a traditional enum tool too.
Would love feedback from the security folks here! What other analysis would
be useful to add?
GitHub: https://github.com/Vyntral/god-eye

value: Show HN: God's Eye – Subdomain recon with local AI analysis

author: vyntral


value: safeshare

value:
SafeShare is a tiny web app + bookmarklets that remove tracking params (utm_, gclid, fbclid, etc.) and unwrap common redirects – all locally in the browser (no accounts, no servers).
• What it does: clean URLs, unwrap t.co/google redirectors, team whitelist for allowed params.
• How it works: client-only JS, PWA + service worker; no network calls to our servers.
• Try it: https://j-ai-71.github.io/Supersystem/quickstart.html
• Feedback welcome (edge cases, params/redirectors to add).

value: Show HN: SafeShare – Clean tracking params locally (PWA and bookmarklets

author: safeshare


value: xmorse

value: Show HN: Kimaki – Control opencode inside Discord

author: xmorse


value:
I’ve been working on a small experimental eBPF/XDP-based firewall written in Rust (using Aya).
It’s not a full IPS and not an antivirus — it’s a packet-level reputation engine for learning purposes.
What it currently does
Rust + eBPF (XDP) packet inspection
Per-IP risk scoring (0–1000)
Detects:
Port scans: SYN/FIN/NULL/XMAS
TTL variance (possible spoofing)
Burst traffic patterns (DoS-like)
ICMP misuse and oversized payloads
Malformed packets
Bloom filter blocklist (up to 400k entries)
LRU map tracking port access timing
Auto-blocking on critical risk
Tarpit behavior on high-risk IPs
Why I built it
I wanted to learn:
Rust in kernel-level constraints
How XDP works internally
Practical heuristics for lightweight threat detection
Efficient state tracking inside eBPF maps
What it is NOT
Not production-ready
Not a malware scanner
Not a Suricata/Snort alternative
Looking for feedback
Particularly interested in:
Map design improvements
Heuristic tuning
Performance considerations
Ideas to avoid false positives
Repo: https://github.com/N1ghttm4r33/Antivirus/tree/main

value: Show HN: Experimental eBPF Firewall in Rust with Heuristic Risk Scoring


value:
We've been building out Cascade. Cascade is a coding/design tool that allows you to explore iterations of your design with coding agents like Claude Code.
The key features are
- Visualizing all your previews and changes side by side,
- Testing multiple iterations of ideas in parallel,
- Selecting element/component level context for the agent to understand and modify directly.
We share additional thoughts on building out this tool on X: https://x.com/johnathanchewy/status/1990453358843580576?s=20. It's in beta now so feel free to give it a go and let us know what you think!

value: Show HN: All your vibe-coded designs on a single canvas like Figma


value:
Built a minimal diff checker with merge feature.
1. Supports 25K+ lines.
2. Character level instant diff.
3. Diff merge feature.
4. Share able links.
5. 100% secure, all diff computation happens in browser.
No other website offering high quality diff checker and merge  feature with just browser only implementation.
Please review the website in detail and share feedback.

value: Show HN: Secure private diffchecker with merge support


value: kanodiaayush

value:
I'm building out Kerns, an AI environment for research. You can seed a space with a topic and multiple source documents, and complete your research completely in one space. There's a powerful chat agent which can reason across tool calls, and give cited answers. These citations take to a reader where you can dive deeper. Further, you can read/listen to original source docs at various levels of summary per chapter. As you chat, a tree builds out which helps you keep track of long chats across sessions, and consolidate your understanding at a glance. You can also do deep research in the app, and we're building out a background agent which sends you constant updates on your topic of interest. Finally, there's interactive mindmaps for exploration.
My goal is to have one place to do understand any topic which minimizes manual context engineering, and jumping around between chat/notes/readers.
Please let me know if you try it and have feedback!

value: Show HN: An AI interface to understand anything, better than NotebookLM

author: kanodiaayush


value: usamaejaz

value:
Hi HN,
I built JustBlogged because I got frustrated trying to start a personal blog.
WordPress felt like signing up to be a sysadmin. Ghost was expensive for a side project. Medium doesn't give you ownership.
What I built:
- 2 minute setup
- Custom domain + free SSL included forever
- Fast by default (<1s loads)
- Free tier that's actually usable
- REST API for programmatic posting
- Fully customizable themes
- Distraction-free writing experience
Tech: Edge-deployed on Cloudflare Workers, global CDN, auto image optimization, fully scalable, no matter how many visitors.
Free forever tier. Pro is $9/mo for branding removal and advanced themes.
Would love what you guys and gals think.

value: Show HN: JustBloggedging platform that takes 2 minutes to setup

author: usamaejaz


value:
I built this because I got tired of opening big apps just to convert my voice into text. This runs entirely in the browser using the Web Speech API and doesn't store anything— no login, no backend, no cloud uploads.
It started as a personal tool, but then I noticed people were using it daily, so I'm sharing it here. Works on mobile and desktop.
Would love to hear feedback on what to improve or add.

value: Show HN: A tiny browser-based voice-to-text tool (no signup, no tracking)


value: devops-coder

value: Show HN: MCP Security Scanning Tool for CI/CD

author: devops-coder


value: skoushik

value:
After building 950+ resumes, we did the most obvious thing for :
Introducing  .—the tool that aims to completely redefine how you interact with your resume.
.:
1.    : Want to pivot for a Product Manager role? Need to strengthen a specific skill? Wanna know your resume strengths? Just ask your resume now.
2. - : Get perfectly crafted, ATS-friendly bullet points and formatted for you.
3.  : You still have the power with our inbuilt $\$ editor for pixel-perfect formatting.
This is resume editing like you've never experienced before.

value: Show HN: WResume – Free Conversational Resume Editing and Built-In LaTeX Editor

author: skoushik