Show stories

I built a desktop Mars colony survival game called Underhill, in homage to Kim Stanley Robinson's Mars trilogy. Land on Mars, build solar panels and greenhouses, and try not to pass out during dust storms. Eventually your colonists split into factions: Greens who want to terraform and Reds who want to preserve Mars.

There’s Chill Mode for players that just want to build & hang, and Conflict Mode that introduces the Red v. Green factions. Reds sabotage, the terrain slowly turns green as the world gets more terraformed.

Feedback welcome, especially on performance and gameplay!

I built an artificial life simulator that fits in one HTML file (~1400 lines ~50KB) with Claude Opus 4.6, interestingly, I didn't even ask it to build the game itself, I've requested to create the software that didn't exist before and not use any dependencies, third-party libraries or ask questions.

Firstly Opus 4.6 made photoshop clone that barely worked, but had nice and neat UI with all common features for the image editor, then I've called that crap and asked to really build someting that wasn't there, it made Emergent there. Please check it out and tell what you think, of course it's a Game of Life in a nutshell, but look at the rest of the UI, game stats, and other features like genome mutation and species evolvement.

Features: - Continuous diet gene (0–1) drives herbivore/carnivore/omnivore specialization - Spatial hash grid for performant collision detection - Pinch-to-zoom and tap-to-feed on mobile - Real-time population graphs, creature inspector, and event log - Drop food, trigger plagues, cause mutation bursts

Amazes me in some kind of a degree, going to continue dig into the abyss of the vibes :)

The article discusses the author's book titled 'Ma Book', which explores the author's mother's life and their relationship. It provides a personal and insightful perspective on the challenges and complexities of family dynamics.

The article discusses the creation of a Cistercian font, a specialized font based on the handwritten script used by Cistercian monks in the Middle Ages. The font is designed to faithfully recreate the distinctive characters and layout of the original Cistercian manuscripts.

I built a Chrome extension that generates noise traffic to dilute your browsing profile. Instead of trying to hide what you do online (increasingly difficult), it buries your real activity in a flood of decoy searches, page visits, and ad clicks across dozens of site categories.

  The core idea is signal dilution — the same principle behind chaff in radar countermeasures and differential privacy in data science. If you visit 50 pages today and Poisson
  visits 500 more on your behalf, anyone analyzing your traffic (ISP, data broker, ad-tech) sees noise, not signal.

  How it works:

  - Uses a Poisson process for scheduling, so timing looks like natural human browsing rather than mechanical intervals
  - Opens background tabs (never steals focus), injects a content script that scrolls, hovers, and clicks links to look realistic
  - Batches tasks within Chrome's 1-minute alarm minimum, dispatching at calculated Poisson offsets
  - Four intensity levels: ~18/hr to ~300/hr
  - Configurable search engines, task mix (search/browse/ad-click ratio), and site categories

  What it explicitly does NOT do:

  - No data collection, telemetry, or analytics
  - No external server communication
  - No access to your cookies, history, or real tabs
  - No accounts or personal information required

  Every URL it will ever visit is hardcoded in the source. Every action is logged in a live feed you can inspect. The whole thing is ~2,500 lines of commented JS.

  I know this approach has real limitations — it doesn't defeat browser fingerprinting, your ISP can still see the noise domains, and a sufficiently motivated adversary could
  potentially distinguish real traffic from generated traffic through timing analysis or behavioral patterns. This is one layer in a defense-in-depth approach, not a complete
  solution.

  Similar prior art: TrackMeNot (randomized search queries since 2006) and AdNauseam (clicks all ads to pollute profiles). Both from NYU researchers. Google banned AdNauseam from
  the Chrome Web Store, which says something.

  Code: https://github.com/Daring-Designs/poisson-extension

  Not on the Chrome Web Store — you load it unpacked. MIT licensed.

I built LocalGPT over 4 nights as a Rust reimagining of the OpenClaw assistant pattern (markdown-based persistent memory, autonomous heartbeat tasks, skills system).

It compiles to a single ~27MB binary — no Node.js, Docker, or Python required.

Key features:

- Persistent memory via markdown files (MEMORY, HEARTBEAT, SOUL markdown files) — compatible with OpenClaw's format - Full-text search (SQLite FTS5) + semantic search (local embeddings, no API key needed) - Autonomous heartbeat runner that checks tasks on a configurable interval - CLI + web interface + desktop GUI - Multi-provider: Anthropic, OpenAI, Ollama etc - Apache 2.0

Install: `cargo install localgpt`

I use it daily as a knowledge accumulator, research assistant, and autonomous task runner for my side projects. The memory compounds — every session makes the next one better.

GitHub: https://github.com/localgpt-app/localgpt Website: https://localgpt.app

Would love feedback on the architecture or feature ideas.

Hi HN

I built WrapClaw, a SaaS wrapper around Open Claw.

Open Claw is a developer-first tool that gives you a dedicated terminal to run tasks and AI workflows (including WhatsApp integrations). It’s powerful, but running it as a hosted, multi-user product requires a lot of infra work.

WrapClaw focuses on that missing layer.

What WrapClaw adds:

A dedicated terminal workspace per user

Isolated Docker containers for each workspace

Ability to scale CPU and RAM per user (e.g. 2GB → 4GB)

A no-code UI on top of Open Claw

Managed infra so users don’t deal with Docker or servers

The goal is to make Open Claw usable as a proper SaaS while keeping the developer flexibility.

This is early, and I’d love feedback on:

What infra controls are actually useful

Whether no-code on top of terminal tools makes sense

Pricing expectations for managed compute

Link: https://wrapclaw.com

Happy to answer questions.

Filtron is a powerful and flexible filtering system that allows developers to easily integrate advanced filtering capabilities into their web applications. It provides a simple API for creating, configuring, and managing complex filters, making it a valuable tool for building feature-rich and user-friendly applications.

Hi HN, I'm a computer systems engineering student in Mexico who switched from film school. I built CineGraphs because my filmmaker friends and I kept hitting the same wall—we'd have a vague idea for a film but no structured way to explore where it could go. Every AI writing tool we tried output generic, formulaic slop. I didn't want to build another ChatGPT wrapper, so I went a different route.

The idea is simple: you input a rough concept, and the tool generates branching narrative paths visualized as a graph. You can sculpt those branches into a structured screenplay format and export to Fountain for use in professional screenwriting software.

Most AI writing tools are trained on generic internet text, which is why they output generic results. I wanted something that understood actual cinematic storytelling—not plot summaries or Wikipedia synopses, but the actual structural DNA of films. So I spent a month curating 100 films I consider high-quality cinema. Not just popular films, but works with distinctive narrative structures: Godard's jump cuts and essay-film digressions, Kurosawa's parallel character arcs, Brakhage's non-linear visual poetry, Tarkovsky's slow-burn temporal structures. The selection was deliberately eclectic because I wanted the model to learn that "story" can mean many things.

Getting useful training data from films is harder than it sounds. I built a 1000+ line Python pipeline using Qwen3-VL to analyze each film with subtitles enabled. The pipeline extracts scene-level narrative beats, character relationships and how they evolve, thematic threads, and dialogue patterns. The tricky part was getting Qwen3-VL to understand cinematic structure rather than just summarizing plot. I had to iterate on the prompts extensively to get it to identify things like "this scene functions as a mirror to the opening" or "this character's arc inverts the protagonist's." That took weeks and I'm still not fully satisfied with it, but it's good enough to produce useful training data.

From those extractions I generated a 10K example dataset of prompt-to-branching-narrative pairs, then fine-tuned Qwen2.5-7B-Instruct with a LoRA optimized for probabilistic story branching. The LoRA handles the graph generation—exploring possible narrative directions—while the full 7B model generates the actual technical screenplay format when you export. I chose the 7B model because I wanted something that could run affordably at scale while still being capable enough for nuanced generation. The whole thing is served on a single 4090 GPU using vLLM. The frontend uses React Flow for the graph visualization. The key insight was that screenwriting is fundamentally about making choices—what if the character goes left instead of right?—but most writing tools force you into a linear document too early. The graph structure lets you explore multiple paths before committing, which matches how writers actually think in early development.

The biggest surprise was how much the film selection mattered. Early versions trained on more mainstream films produced much more formulaic outputs. Adding experimental and international cinema dramatically improved the variety and interestingness of the generations. The model seemed to learn that narrative structure is a design space, not a formula.

We've been using it ourselves to break through second-act problems—when you know where you want to end up but can't figure out how to get there. The branching format forces you to think in possibilities rather than committing too early.

You can try it at https://cinegraphs.ai/ — no signup required to test it out. You get a full project with up to 50 branches without registering, though you'll need to create an account to save it. Registered users get 3 free projects. I'd love feedback on whether the generation quality feels meaningfully different from generic AI tools, and whether the graph interface adds value or just friction.

Hivewire is a news app that lets you define what you want to read about, rather than inferring it from your behavior. We process thousands of articles daily from hundreds of sources and rank them based on explicit preferences you set.

How it works:

• Instead of collaborative filtering or engagement-driven ranking, you assign weights across four levels (Focus, More, Less, Avoid) and the engine prioritizes the intersection of your high-weight topics while aggressively down-weighting what you don't care about.

• Articles are clustered by story so you get one entry per development, not 15 versions of the same headline.

• Every morning, it pulls your top clusters and uses an LLM to generate a narrative briefing that summarizes what matters to you, delivered to your email.

Currently web-only and English-language. We'd love feedback from the community on the relevance of feed results, the UI, and the quality of the clustering.

Bhagavan is a calm, modern app for exploring Hinduism. It brings together philosophy, stories, scriptures, prayers and daily practices in one simple, accessible place. It’s designed for people who feel Hinduism can be overwhelming or hard to connect to and want a gentler, more modern way to explore it at their own pace.

What’s inside (all free):

• Guided exploration of Hinduism through structured learning paths

• Clear, accessible explanations of scriptures (Vedas, Upanishads, Smritis, Puranas)

• Complete Bhagavad Gita with translations and key takeaways

• Deity profiles with stories, symbolism and context

• Epic stories including the Ramayana and Panchatantra

• Prayers with translations, audio, and japa using a virtual mala

• Festival calendar with key dates, reminders and lunar phases

• Daily practices for reflection and focus

• Daily quizzes, crosswords and challenges

• Philosophy and spirituality concepts (e.g. dharma, karma, moksha)

• Daily horoscope

• 'Ask Bhagavan' for thoughtful, philosophy-rooted guidance

No ads. Just a calm space to learn and explore. Free to use, with all content accessible.

iOS: https://apps.apple.com/app/6741321101 Android: https://play.google.com/store/apps/details?id=bhagavan.id

Let me know what you guys think! Please do share with family and friends

Wrote a thing about what makes Elysia stand out in a performance benchmark game

Basically, there's a JIT "compiler" embedded into a framework

This approach has been used by ajv and TypeBox before for input validation, making it faster than other competitors

Elysia basically does the same, but scales that into a full backend framework

This gave Elysia an unfair advantage in the performance game, making Elysia the fastest framework on Bun runtime, but also faster than most on Node, Deno, and Cloudflare Worker as well, when using the same underlying HTTP adapter

There is an escape hatch if necessary, but for the past 3 years, there have been no critical reports about the JIT "compiler"

What do you think?

This article presents a novel image compression algorithm that adapts the block size and luma-dependent chroma compression based on the spatial domain, leading to improved compression efficiency while maintaining image quality.

Hi HN! Smooth CLI (https://www.smooth.sh) is a browser that agents like Claude Code can use to navigate the web reliably, quickly, and affordably. It lets agents specify tasks using natural language, hiding UI complexity, and allowing them to focus on higher-level intents to carry out complex web tasks. It can also use your IP address while running browsers in the cloud, which helps a lot with roadblocks like captchas (https://docs.smooth.sh/features/use-my-ip).

Here’s a demo: https://www.youtube.com/watch?v=62jthcU705k Docs start at https://docs.smooth.sh.

Agents like Claude Code, etc are amazing but mostly restrained to the CLI, while a ton of valuable work needs a browser. This is a fundamental limitation to what these agents can do.

So far, attempts to add browsers to these agents (Claude’s built-in --chrome, Playwright MCP, agent-browser, etc.) all have interfaces that are unnatural for browsing. They expose hundreds of tools - e.g. click, type, select, etc - and the action space is too complex. (For an example, see the low-level details listed at https://github.com/vercel-labs/agent-browser). Also, they don’t handle the billion edge cases of the internet like iframes nested in iframes nested in shadow-doms and so on. The internet is super messy! Tools that rely on the accessibility tree, in particular, unfortunately do not work for a lot of websites.

We believe that these tools are at the wrong level of abstraction: they make the agent focus on UI details instead of the task to be accomplished.

Using a giant general-purpose model like Opus to click on buttons and fill out forms ends up being slow and expensive. The context window gets bogged down with details like clicks and keystrokes, and the model has to figure out how to do browser navigation each time. A smaller model in a system specifically designed for browsing can actually do this much better and at a fraction of the cost and latency.

Security matters too - probably more than people realize. When you run an agent on the web, you should treat it like an untrusted actor. It should access the web using a sandboxed machine and have minimal permissions by default. Virtual browsers are the perfect environment for that. There’s a good write up by Paul Kinlan that explains this very well (see https://aifoc.us/the-browser-is-the-sandbox and https://news.ycombinator.com/item?id=46762150). Browsers were built to interact with untrusted software safely. They’re an isolation boundary that already works.

Smooth CLI is a browser designed for agents based on what they’re good at. We expose a higher-level interface to let the agent think in terms of goals and tasks, not low-level details.

For example, instead of this:

  click(x=342, y=128)
  type("search query")
  click(x=401, y=130)
  scroll(down=500)
  click(x=220, y=340)
  ...50 more steps

  Search for flights from NYC to LA and find the cheapest option

Smooth enables agents to launch as many browsers and tasks as they want, autonomously, and on-demand. If the agent is carrying out work on someone’s behalf, the agent’s browser presents itself to the web as a device on the user’s network. The need for this feature may diminish over time, but for now it’s a necessary primitive. To support this, Smooth offers a “self” proxy that creates a secure tunnel and routes all browser traffic through your machine’s IP address (https://docs.smooth.sh/features/use-my-ip). This is one of our favorite features because it makes the agent look like it’s running on your machine, while keeping all the benefits of running in the cloud.

We also take away as much security responsibility from the agent as possible. The agent should not be aware of authentication details or be responsible for handling malicious behavior such as prompt injections. While some security responsibility will always remain with the agent, the browser should minimize this burden as much as possible.

We’re biased of course, but in our tests, running Claude with Smooth CLI has been 20x faster and 5x cheaper than Claude Code with the --chrome flag (https://www.smooth.sh/images/comparison.gif). Happy to explain further how we’ve tested this and to answer any questions about it!

Instructions to install: https://docs.smooth.sh/cli. Plans and pricing: https://docs.smooth.sh/pricing.

It’s free to try, and we'd love to get feedback/ideas if you give it a go :)

We’d love to hear what you think, especially if you’ve tried using browsers with AI agents. Happy to answer questions, dig into tradeoffs, or explain any part of the design and implementation!

Example repo: https://github.com/valdanylchuk/breezydemo

The underlying ESP-IDF component: https://github.com/valdanylchuk/breezybox

It is something like Raspberry Pi, but without the overhead of a full server-grade OS.

It captures a lot of the old school DOS era coding experience. I created a custom fast text mode driver, plan to add VGA-like graphics next. ANSI text demos run smooth, as you can see in the demo video featured in the Readme.

App installs also work smoothly. The first time it installed 6 apps from my git repo with one command, felt like, "OMG, I got homebrew to run on a toaster!" And best of all, it can install from any repo, no approvals or waiting, you just publish a compatible ELF file in your release.

Coverage:

Hackaday: https://hackaday.com/2026/02/06/breezybox-a-busybox-like-she...

Hackster.io: https://www.hackster.io/news/valentyn-danylchuk-s-breezybox-...

Reddit: https://www.reddit.com/r/esp32/comments/1qq503c/i_made_an_in...

r3 is a high-performance, open-source programming language and environment that focuses on simplicity, efficiency, and creativity. It provides a powerful set of tools for developing a wide range of applications, from games and graphics to data visualization and automation.

Due to bike-induced concussions, I've been worried for a while about losing my memory and not being able to log back in.

I combined shamir secret sharing (hashicorp vault's implementation) with age-encryption, and packaged it using WASM for a neat in-browser offline UX.

The idea is that if something happens to me, my friends and family would help me get back access to the data that matters most to me. 5 out of 7 friends need to agree for the vault to unlock.

Try out the demo in the website, it runs entirely in your browser!

Kappal is an open-source software project that provides a platform for building and deploying containerized applications. It offers a simplified workflow for managing infrastructure, orchestrating services, and automating deployments across multiple environments.

Two clip-paths, over the navigation:

- The first clip-path is a circle (top-left corner) - The second clip-path is a polygon, that acts like a ray (hardcoded, can be improved)

The original work by Iventions Events https://iventions.com/ uses JavaScript, but I found CSS-only approach more fun

Here's a demo and the codebase: https://github.com/Momciloo/fun-with-clip-path

The article discusses the launch of Unrender, a new website that aims to provide a platform for artists and creators to showcase their work and explore the intersection of art and technology. The platform offers features like interactive visualizations, generative art, and tools for collaborative creation.

Hello everyone!

I'm a solo developer who's been doing UI/UX work since 2007. Over the years, I watched design tools evolve from lightweight products into bloated feature-heavy platforms. I kept finding myself using a small amount of the features while the rest just mostly got in the way.

So a few years ago I set out to build a design tool just like I wanted. So I built Vecti with what I actually need: pixel-perfect grid snapping, a performant canvas renderer, shared asset libraries, and export/presentation features. No collaborative whiteboarding. No plugin ecosystem. No enterprise features. Just the design loop.

Four years later, I can proudly show it off. Built and hosted in the EU with European privacy regulations. Free tier available (no credit card, one editor forever).

On privacy: I use some basic analytics (page views, referrers) but zero tracking inside the app itself. No session recordings, no behavior analytics, no third-party scripts beyond the essentials.

If you're a solo designer or small team who wants a tool that stays out of your way, I'd genuinely appreciate your feedback: https://vecti.com

Happy to answer questions about the tech stack, architecture decisions, why certain features didn't make the cut, or what's next.

Codex runs as an MCP server, Claude orchestrates a five-perspective review (security, correctness, compliance, performance, maintainability). Drop the SKILL.md into your repo's .claude/skills/ folder. MIT licensed.

I'm a software engineer who keeps getting pulled into DevOps no matter how hard I try to escape it. I recently moved into a Lead DevOps Engineer role writing tooling to automate a lot of the pain away. On my own time outside of work, I built Artifact Keeper — a self-hosted artifact registry that supports 45+ package formats. Security scanning, SSO, replication, WASM plugins — it's all in the MIT-licensed release. No enterprise tier. No feature gates. No surprise invoices.

Your package managers — pip, npm, docker, cargo, helm, go, all of them — talk directly to it using their native protocols. Security scanning with Trivy, Grype, and OpenSCAP is built in, with a policy engine that can quarantine bad artifacts before they hit your builds. And if you need a format it doesn't support yet, there's a WASM plugin system so you can add your own without forking the backend.

Why I built it:

Part of what pulled me into computers in the first place was open source. I grew up poor in New Orleans, and the only hardware I had access to in the early 2000s were some Compaq Pentium IIs my dad brought home after his work was tossing them out. I put Linux on them, and it ran circles around Windows 2000 and Millennium on that low-end hardware. That experience taught me that the best software is software that's open for everyone to see, use, and that actually runs well on whatever you've got.

Fast forward to today, and I see the same pattern everywhere: GitLab, JFrog, Harbor, and others ship a limited "community" edition and then hide the features teams actually need behind some paywall. I get it — paychecks have to come from somewhere. But I wanted to prove that a fully-featured artifact registry could exist as genuinely open-source software. Every feature. No exceptions.

The specific features came from real pain points. Artifactory's search is painfully slow — that's why I integrated Meilisearch. Security scanning that doesn't require a separate enterprise license was another big one. And I wanted replication that didn't need a central coordinator — so I built a peer mesh where any node can replicate to any other node. I haven't deployed this at work yet — right now I'm running it at home for my personal projects — but I'd love to see it tested at scale, and that's a big part of why I'm sharing it here.

The AI story (I'm going to be honest about this):

I built this in about three weeks using Claude Code. I know a lot of you will say this is probably vibe coding garbage — but if that's the case, it's an impressive pile of vibe coding garbage. Go look at the codebase. The backend is ~80% Rust with 429 unit tests, 33 PostgreSQL migrations, a layered architecture, and a full CI/CD pipeline with E2E tests, stress testing, and failure injection.

AI didn't make the design decisions for me. I still had to design the WASM plugin system, figure out how the scanning engines complement each other, and architect the mesh replication. Years of domain knowledge drove the design — AI just let me build it way faster. I'm floored at what these tools make possible for a tinkerer and security nerd like me.

Tech stack: Rust on Axum, PostgreSQL 16, Meilisearch, Trivy + Grype + OpenSCAP, Wasmtime WASM plugins (hot-reloadable), mesh replication with chunked transfers. Frontend is Next.js 15 plus native Swift (iOS/macOS) and Kotlin (Android) apps. OpenAPI 3.1 spec with auto-generated TypeScript and Rust SDKs.

Try it:

  git clone https://github.com/artifact-keeper/artifact-keeper.git
  cd artifact-keeper
  docker compose up -d

Live demo: https://demo.artifactkeeper.com Docs: https://artifactkeeper.com/docs/

I'd love any feedback — what you think of the approach, what you'd want to see, what you hate about Artifactory or Nexus that you wish someone would just fix. It doesn't have to be a PR. Open an issue, start a discussion, or just tell me here.

https://github.com/artifact-keeper

A secure, embeddable, WASM-based sandbox for AI agents. 40+ built-in CLI tools, a JavaScript runtime, safe HTTP networking, <13ms startup, no Docker/VMs required.

Hi HN,

My friend and I have been experimenting with using LLMs to reason about biotech stocks. Unlike many other sectors, Biotech trading is largely event-driven: FDA decisions, clinical trial readouts, safety updates, or changes in trial design can cause a stock to 3x in a single day (https://www.biotradingarena.com/cases/MDGL_2023-12-14_Resmet...).

Interpreting these ‘catalysts,’ which comes in the form of a press release, usually requires analysts with previous expertise in biology or medicine. A catalyst that sounds “positive” can still lead to a selloff if, for example: the effect size is weaker than expected

- results apply only to a narrow subgroup

- endpoints don’t meaningfully de-risk later phases,

- the readout doesn’t materially change approval odds.

To explore this, we built BioTradingArena, a benchmark for evaluating how well LLMs can interpret biotech catalysts and predict stock reactions. Given only the catalyst and the information available before the date of the press release (trial design, prior data, PubMed articles, and market expectations), the benchmark tests to see how accurate the model is at predicting the stock movement for when the catalyst is released.

The benchmark currently includes 317 historical catalysts. We also created subsets for specific indications (with the largest in Oncology) as different indications often have different patterns. We plan to add more catalysts to the public dataset over the next few weeks. The dataset spans companies of different sizes and creates an adjusted score, since large-cap biotech tends to exhibit much lower volatility than small and mid-cap names.

Each row of data includes:

- Real historical biotech catalysts (Phase 1–3 readouts, FDA actions, etc.) and pricing data from the day before, and the day of the catalyst

- Linked Clinical Trial data, and PubMed pdfs

Note, there are may exist some fairly obvious problems with our approach. First, many clinical trial press releases are likely already included in the LLMs’ pretraining data. While we try to reduce this by ‘de-identifying each press release’, and providing only the data available to the LLM up to the date of the catalyst, there are obviously some uncertainties about whether this is sufficient.

We’ve been using this benchmark to test prompting strategies and model families. Results so far are mixed but interesting as the most reliable approach we found was to use LLMs to quantify qualitative features and then a linear regression of these features, rather than direct price prediction.

Just wanted to share this with HN. I built a playground link for those of you who would like to play around with it in a sandbox. Would love to hear some ideas and hope people can play around with this!

PortView is an open-source web application that provides a comprehensive overview of the performance and status of network ports and interfaces. It offers real-time monitoring, historical data analysis, and customizable dashboards to help network administrators efficiently manage and troubleshoot their infrastructure.

Hi HN, I built Repomap, a tool that generates interactive architecture diagrams from any GitHub repository. It uses a Rust + tree-sitter engine to analyze the codebase and produces a D3-based graph UI with clustering, zoom/pan, and live progress updates