2025年9月18日 的 Show HN

Hello everyone! I created a short game in just a few days, just for fun, where you play as an ant and feed it apples

This game also features random landscape generation, with clouds and trees arranged in a chaotic pattern across all coordinates. This is what took me the longest time :)

I would appreciate your feedback ^ ^

Hey HN, manyminiapps is the world first massively multiplayer online mini app builder (MMOMA)

*Here’s what it does:*

You load the page. You write 1 prompt and you get a mini app back in under 2 minutes. There’s no sign up, and you can see what everyone’s creating in real-time!

Each mini app comes with it’s own database and backend, so you can build shareable apps that save data.

*What’s different*

There are a lot of app builders that promise you’ll build production software for others. But we think true production software can take a long time to get right. Even if you don’t need to program there’s a lot of work involved.

What if we turned the promise around? Instead of “you vibe code software companies”, it’s “you build fun software for yourself”.

If you cut the problem right, LLMs as they are today can already deliver personal software. manyminiapps is meant to be an experiment to demonstrate this.

You may wonder: do you really need personal software? We’re not 100% sure, but it’s definitely an interesting question. Using manyminiapps so far has been surprising! We thought our friends would just try to build the common todo app, but instead we found them building wedding planners, chord progression helpers, inspiration lists, and retro games.

*How it works*

Instead of spinning up VMs or separate instances per app, we built a multi-tenant graph database on top of 1 large Postgres instance.

All databases live under 1 table, on an EAV table (entity, attribute, value). This makes it so creating an “app” is as light as creating a new row.

If you have heard of EAV tables before, you may know that most Postgres experts will tell you not to use them. Postgres needs to know statistics in order to make efficient query plans. But when you use EAV tables, Postgres can no longer get good statistics. This is usually a bad idea.

But we thought it was worth solving to get a multi-tenant relational database. To solve this problem we started saving our own statistics in a custom table. We use count-min sketches to keep stats about each app’s columns. When a user writes a query, we figure out the indexes to use and get pg_hint_plan to tell Postgres what to do.

*What we’ve learned so far*

We’ve tried both GPT 5, Claude Opus, and Claude Sonnet for LLM providers.

GPT 5 followed the instructions the best amongst the models. Even if you told it a completely nonsensical prompt (like “absda”, it would follow the system prompt and make an app for you. But GPT 5 was also the “most lazy”. The apps that came out tended to feel too simple, with little UI detail.

Both Claude Opus and Sonnet were less good at following instructions. Even when we told them to return just the code, they wanted to returned markdown blocks. But, after parsing through those blocks, the resulting apps felt much better.

To our surprise, we didn’t notice a difference in quality from Opus and Sonnet. Both models did well, with perhaps Sonnet following instructions more closely.

To get good results we iterated on prompts. We initially tried giving point-by-point instructions, but found that a prompt with a full example tended to do better. Here’s what we landed on:

https://gist.github.com/stopachka/a6b07e1e6daeb85fa7c9555d8f...

Let us know what you think, and hope you have fun : )

Hi friends, I'm really excited to introduce KSON, which just entered public beta!

Anywhere a human is reading or editing YAML/JSON/TOML, KSON may be used as a more effective interface on that data. If you are such a human, we invite you to participate in this beta.

tl;dr Check out the website [1], play with the online playground [2], install the library for your programming language [3], edit in your favorite editor [4], discuss and give feedback [5], contribute to the project [6].

(A personal note about this project: I love software. Machines made of words! Such a wonder. KSON itself, as a collection of words that both make a machine and explain that machine, is an expression of a lot ideas I feel really passionately about around software and our relationship to it. I've put a lot of love into trying to make that expression eloquent and reliable. I hope some of that comes through clearly, and I look forward to discussing this more over time with anyone who's interested)

One of the key things KSON wants to say is: let's keep everything that's great about YAML and JSON as "Configuration User Interfaces", and let's make those interfaces more toolable, robust, and fun. Here's some of the ways we do that:

- KSON is a verified superset of JSON, has native JSON Schema support, transpiles cleanly to YAML (with comments preserved!), and is likely available wherever you want it—current supported platforms: JS/TS, Python, Rust, JVM, and Kotlin Multiplatform.

- KSON is also widely available in developer tools, with support for VS Code, Jetbrains IDEs, and anywhere you can plug in an LSP.

- KSON is fully open source, licensed under Apache-2.0, and you are invited to meet its words and tinker with how they make its machine. A lot of care, craft, attention and joy went into making the KSON project understandable and approachable for developers. We hope to see you around.

PS. This is an HN-friendly version of the official announcement at <https://kson.org/docs/blog/2025/09/17/introducing-kson/>.

[1]: https://kson.org/

[2]: https://kson.org/playground/

[3]: https://kson.org/docs/install/#languages

[4]: https://kson.org/docs/install/#editor-support

[5]: https://kson-org.zulipchat.com/

[6]: https://github.com/kson-org/kson

Hi HN!

I left Google earlier this year and created Dyad, a local, open-source AI app builder made with Electron.

The motivation: I tried one of the popular cloud-based AI app builders, but when I pulled down the app to run locally and debug in Cursor, it just didn’t work. So I created Dyad, an app builder that runs fully on your computer, making it easy to switch between Dyad and coding tools like Cursor or Claude Code.

Source code: https://github.com/dyad-sh/dyad/

Download (free, no sign-up): https://www.dyad.sh/

I've gotten questions about how it works under the hood so I wrote an architecture doc explaining how it does tool calling using XML tags, etc: https://github.com/dyad-sh/dyad/blob/main/docs/architecture....

Let me know what you think and happy to answer questions about building an Electron app, etc!

Today we're releasing Nanobot an open-source framework for building AI agents on top of the Model Context Protocol (MCP).

MCP servers are a great way to expose structured tools, but they’re usually just that—collections of functions. Nanobot makes it simple to wrap any MCP server with reasoning, a system prompt, and orchestration so it behaves like a real agent. Even better, Nanobot fully supports MCP-UI, so agents can pass rich interactive components (forms, dashboards, even mini-apps) directly into chat.

A simple example: if you had a Blackjack MCP server with tools like deal, bet, and hit, you could wrap it with Nanobot to create a dealer agent that knows how to explain the game, guide a player, and render an interactive Blackjack table inside chat.

We built this because we wanted agents that go beyond text and function calls, into actual interactive experiences—something useful for everything from games to e-commerce to developer tools.

Code is on GitHub: https://github.com/nanobot-ai/nanobot

Live demo (Blackjack): https://blackjack.nanobot.ai

We’d love feedback from this community—on the framework, the design, and what you’d like to see next.

Being inspired by old third-party scripting environments such as AutoIt or AutoHotkey, I've developed my own scripting environment for Windows. I've always been fascinated by creating an own programming language and I made the syntax in a way it feels more like something that contains a personal flavor.

The language matured over the years and I both use it for administration and automation tasks, but also for fully scripted applications as well.

On the homepage, you'll find various production scripts as well as links to scripted applications.

The scripting environment is free and open-source software, released under the MIT license.

New Zealand Members of Parliament are required to annually disclose their financial interests (shareholdings, directorships, consultancies, etc.) but this gets published annually as an unwieldy 80+ page PDF that's hard to search effectively.

I processed structured data out of the PDF and built a searchable interface: https://open-register-of-pecuniary-interests.joshmcarthur.co....

You can search across all MPs' disclosed interests by name, company, or interest type. For example, you can quickly find which MPs have interests in specific sectors or companies, filter by category or political party.

The data extraction was interesting - I found that a two-pass approach worked well with Gemini 2.5 Flash - one to pull out MP names and referenced page numbers, then I extracted the specific pages each MP appeared on and extracted structured data just from these pages.

The approach could work for similar transparency registers in other countries - most seem to publish open data as PDF, which technically ticks the box, but isn't the most accessible format to work with. Even within NZ, I'm planning to expand the data I process to previous years, as well as processing data for local and regional councils (who have the same legal requirement to publish financial interests of council members).

Open sourced at https://github.com/joshmcarthur/open-register-of-pecuniary-i....

Tech stack: Ruby on Rails, SQLite (FTS5), Tailwind/DaisyUI - keeping it lightweight since this is just a side project to make public data more accessible.

Everything I drive by one of these new tech billboards, I always wanted to either fully read it but cannot focus, or want to take a photo of it and share but I cannot because I'm driving. So I want to curate them in a place to enjoy them later, and share with friends about how crazy SF is.

I made an art project about stablecoins. Enjoy!

This was an interesting porting project for a few reasons (IMO):

- The original game is/was awesome and, from a programming perspective, a wonder -- smooth scrolling arcade game on a 128kb Mac in 1984...

- The port was done with a lot of help from AI (mostly Claude Code, but some Gemini CLI as well). I'm a programmer; it wasn't vibe-coded. But I couldn't have done the port of 68k assembly without it. FWIW, Claude seemed better at actually porting the 68k assembly but Gemini was better at finding bugs. YMMV.

- I love Redux and Redux Toolkit for state management. For the port, I put the entire game state in Redux, including all the physics, movement, etc. Every thing that happens in the game is a little redux action. You can watch the whole game get played in the RTK debugger. For some reason that makes me happy.

I've released all my code as MIT. Would love to make a "modern" version some day, but for now I've just tried to be faithful to the original.

There are a few bugs, noted as issues in the github repo. Feel free to add more.

Hi HN! I built a distributed rate limiter using the token bucket algorithm with Redis backing.

Key highlights: • 50,000+ requests/second throughput with <2ms P95 latency • Redis-backed distributed state for multi-instance deployments • 18 REST API endpoints for rate limiting, config, and monitoring • 265+ tests including load tests and integration tests • Docker/Kubernetes ready with comprehensive documentation

Built with Java 21 + Spring Boot. Perfect for protecting APIs, microservices, or SaaS platforms from abuse.

The pain point I solved: existing solutions were either too simple (in-memory only) or too complex (enterprise-only). This fills the gap with a production-ready, easy-to-deploy solution.

Try it: Download the JAR, start Redis, and you're rate limiting in 30 seconds.

Would love feedback on the API design and performance characteristics!

GitHub: https://github.com/uppnrise/distributed-rate-limiter

I live in the South of France (Var region), where wildfires destroy our forests and endanger lives every summer. This project is my attempt to build a concrete, open-source tool to help firefighters.

Neon Shower is a playful tool for creating light burst animations that can be used as backgrounds / overlays in videos. Feedback is very welcome!

Hi HN, I’ve been working on SandBox, a project that lets you explore possible futures using autonomous AI agents. You can build scenarios (environmental, social, governance, etc.), make decisions, and see how things might unfold under different paths.

Some of the things you can do:

Generate speculative news and events under your scenario settings

Visualize how small decisions ripple over time

Run multiple agent-based simulations in parallel

Built with Python, LangGraph + Azure OpenAI, plus a front-end for visualization. Still in active development; feedback, critiques, ideas & contributions are very welcome.

Live demo: https://sandboxes.live/ Github: https://github.com/abozaralizadeh/SandBox

If you like it, a helps me know this is worth pushing further. Thanks!

I’ve been experimenting with ways to reduce boilerplate when wiring up multiple backends for frontend projects. The Backend-for-Frontend (BFF) pattern is a common approach, but most solutions I found were either too heavy or tied to specific platforms.

I wrote a small CLI in Go called bffgen:

scaffolds a BFF service with chi, echo, or fiber

sets up CORS, JWT, Redis, and session management by default

supports route templates for aggregation

now includes a bffgen.yaml config so defaults persist across runs

I built a free and open source tool to make working with the IAB content taxonomies less painful.

Converts IAB Content Taxonomy 2.0 → 3.0 automatically

Runs fully local, no data leaves your machine

Multiple methods supported (BM25, TF-IDF, embeddings, LLM re-ranking)

Simple demo UI + CLI available

pip install iab-taxonomy-mapper

Why? Agencies, adtech, and publishers often need to upgrade taxonomies, but mappings aren’t always 1:1. This tool provides ranked candidates and options, saving hours of manual work.

GitHub: https://github.com/mixpeek/iab-mapper Demo: https://mxp.co/taxonomy

Would love feedback on whether this is useful in your workflow and ideas for what to add next.

dumpall: The smart file aggregator for AI context and code reviews

I've built a new CLI utility called dumpall that solves a pain point I've often had: needing to quickly provide a structured dump of project files to an AI for context, or to a colleague for a code review.

The core idea is to follow the Unix philosophy: do one thing well. dumpall recursively reads files in a directory, respects exclusions (like node_modules or .git), and formats the output into clean Markdown fenced code blocks.

Key Features:

LLM-Optimized: Output is designed for easy consumption by large language models, providing clean and structured context.

Clipboard Integration: Use the --clip flag to send the entire output directly to your clipboard.

Smart Exclusions: Easily ignore unwanted directories and files.

Versatile: Great for providing context to AI, preparing code for a review, or simply archiving a project's state.

I'd love to hear your thoughts and feedback. You can try it out with npx dumpall . -e node_modules -e .git.

Hi HN

I built Illustria – a simple tool to generate custom illustrations on demand

Why I built it: - I was frustrated spending hours browsing stock sites for the right visuals. - Free illustrations often didn’t match the style I needed. - I wanted a faster way to get usable illustrations for landing pages, pitch decks, and side projects.

What it does today: - Generate illustrations instantly based on your input (first generation is free). - Explore different looks/styles without needing design skills. - Download and use them right away. - Browse a free gallery of ready-made illustrations: https://arcanvia.com/illustria/gallery

I’d love feedback on: - Would you actually use this for your side projects? - What features would make it more valuable for you?

I built Splitrail, an open source Rust TUI that turns Codex CLI, Claude Code, and Gemini CLI session logs into token usage and cost so you can measure real productivity (local first; optional free and OSS cloud and leaderboard integrations). I wanted vendor agnostic, fast, and local analytics across agentic tools. I also wanted to be able to easily track usage across multiple devices.

Codex CLI v0.32.0 added token fields to its JSONL “rollout” files (cached/input/output). Splitrail v1.1.0 supports the new event-based format today.

Links: GitHub: https://github.com/Piebald-AI/splitrail Cloud/Leaderboard (optional): https://splitrail.dev/ Release: https://github.com/Piebald-AI/splitrail/releases/tag/v1.1.0

Happy to answer questions and take feature requests.