Show stories

This is a little game implemented over a week of tinkering and targeting Emacs.

The point is both to have fun with this kind of simulations, and also explore the "functional core / imperative shell" approach to architecture. I also developed a tile and tile effect definition DSL, which makes this even easier to extend. From this point of view it's a success: easy testing, easy extension,

Gameplay-wise the simulation is too simplistic, and needs input from people interested in this kind of toys. The original Micropolis/SimSity is the last time I built a virtual city.

I'm Guy, the founder behind Snyk — now building Tessl, a package manager for agent skills.

We’ve recently witnessed that most teams still treat skills as static artifacts: markdown files, created or copied from repo to repo.

This approach offers a strong initial boost, but quickly creates debt:

- Skills are duplicated, and updates never roll out. - Poor quality skills go unseen, misguiding agents instead of helping. - Skill knowledge grows stale, and don’t keep up with the systems and practices they describe.

Without a way to evaluate skills, teams have no clear way to understand how good a skill actually is, or if it degraded over time.

Our belief is that evaluations are the foundation for having quality skills.

With that in mind, I’m glad to announce that Tessl Registry contains review evals for over 2,000 skills, and you can request an evaluation for any public skill.

Super excited to be launching this — keen to get your feedback, and looking forward to the many more enhancements in the queue!

The article presents a new enterprise-level version of the classic FizzBuzz programming challenge, featuring advanced features such as cloud integration, blockchain-based scoring, and a microservices architecture.

Boris Cherny (Claude Code creator) recently dropped a threads on how his team at Anthropic uses Claude Code.

The key insight: they don't treat it as a static config. After every correction, they tell Claude "Update your CLAUDE.md so you don't make that mistake again." Claude writes a rule for itself. They review it, commit it to git. The mistake never happens again.

I cross-referenced his tweets with Anthropic's official docs and other best practices for CLAUDE.md and then packaged it into a starter kit:

  - Fill-in-the-blank templates for Next.js/TypeScript, Python/FastAPI, and a generic
  catch-all
  - The workflow patterns his team actually uses (plan mode, verification loops, subagent
  strategy)
  - Every claim cited back to the source tweet or doc

What's in your CLAUDE.md that's made a measurable difference?

The article discusses the launch of a new app that allows users to clone and customize their own mobile applications. The app provides a user-friendly platform for building and publishing custom apps without advanced coding knowledge.

Hi HN

I built ÆTHRA, a programming language for writing music as code.

I made AETHRA some weeks ago but it was in version 0.8. Now I updated it to version 1.0 with better examples, commands and cross platform support.

Instead of timelines, DAWs, or heavy music theory, ÆTHRA lets you describe music using simple commands like notes, chords, tempo, instruments, vibrato, and emotion-driven structure.

Example:

@Tempo(128) @Volume(0.9) @Instrument("Saw") @ADSR(0.01, 0.05, 0.7, 0.1)

@Loop(4){ @Chord(C4 E4 G4, 1) @Chord(F4 A4 C5, 1) @Chord(G4 B4 D5, 1) @Drum("Kick", 0.5) @Drum("HiHat", 0.25) }

The goal is not to replace humans, but to make music programmable, readable, and expressive — especially for developers.

Why ÆTHRA? • Text-based music creation • Cross-platform (Windows / Linux / macOS) • Deterministic output (same code → same music) • Designed for emotion-driven composition (sad, happy, rock, ambient) • Beginner-friendly syntax

It’s inspired by ideas from live coding and music DSLs, but focused on simplicity and clarity rather than performance art.

GitHub: https://github.com/TanmayCzax/AETHRA

I’d love feedback on: • Language design • Ideas for v2

Thanks for checking it out

At work I need to use Teams. It supports a few Markdown features, but the editing experience for long message isn't smooth. So, I often write in nvim, preview it in the browser and then copy paste to Teams. This tool help me get rid of the review and copy step.

Build with Rust + Claude Code. Tested on Windows and Mac, should works on Ubuntu as well.

Caveats: it's still up to the pasted app to handle the HTML clipboard content.

I review PRs all day and I've basically stopped reading them. Someone opens a 2000-line PR, I scroll, see it's mostly AI-generated React components, leave a comment, merge. I felt bad about it until I realized everyone on my team does the same thing.

The problem is diffs are the wrong format. A PR might change how three buttons behave. Staring at green and red lines to understand that is crazy.

The core reason we built this is that we feel that products today are built with assumptions from the past. 100x code with the same review systems means 100x human attention. Human attention cannot scale to fit that need, so we built something different. Humans are provably more engaged with video content than text.

So we RL trained and built an agent that watches your preview deployment when you open a PR, clicks around the stuff that changed, and posts a video in the PR itself.

Hardest part was figuring out where changed code actually lives in the running app. A diff could say Button.tsx line 47 changed, but that doesn't tell you how to find that button. We walk React's Fiber tree where each node maps back to source files, so we can trace changes to bounding boxes for the DOM elements. We then reward the model for showing and interacting within it.

This obviously only works with React so we have to get more clever when generalizing to all languages.

We trained an RL agent to interact with those components. Simple reward: points for getting modified stuff into viewport, double for clicking/typing. About 30% of what it does is weird, partial form submits, hitting escape mid-modal, because real users do that stuff and polite AI models won't test it on their own.

This catches things unit tests miss completely: z-index bugs where something renders but you can't click it, scroll containers that trap you, handlers that fail silently.

What's janky right now: feature flags, storing different user states, and anything that requires context not provided.

Free to try: https://morphllm.com/dashboard/integrations/github

Demo: https://www.youtube.com/watch?v=Tc66RMA0nCY

My wife was planning to open a micro-bakery. We looked at production management software and it was all either expensive or way too generic. The actual workflows for a small-batch manufacturer aren't that complex, so I built one and open-sourced it.

Craftplan handles recipes (versioned BOMs with cost rollups), inventory (lot traceability, demand forecasting, allergen tracking), orders, production batch planning, and purchasing. Built with Elixir, Ash Framework, Phoenix LiveView, and PostgreSQL.

Live demo: https://craftplan.fly.dev (test@test.com / Aa123123123123)

GitHub: https://github.com/puemos/craftplan

GUI-first, multi-service gRPC scaffold for an Android Development Kit style workflow on an AArch64 system.

The article describes the development of a plugin for the Ghidra software reverse engineering framework that adds support for the Minecraft Protocol (MCP), allowing for the analysis and understanding of Minecraft server software and communication protocols.

I was building a Rust-based agentic coding TUI and needed to render Mermaid diagrams. Noticed the official mermaid-cli spawns a full browser instance (Puppeteer/Chrome) just to render diagrams. Decided to fix this.

mmdr is a native Rust renderer. No browser, no Node.js.

  mermaid-cli:  ~3000ms per diagram
  mmdr:         ~3ms per diagram

FIPSPad is an open-source software project that aims to provide a secure and privacy-focused notepad application, incorporating FIPS-validated cryptographic algorithms to protect user data. The project focuses on developing a cross-platform solution that is easy to use and offers advanced security features for sensitive information.

buquet (bucket queue) is a queue and workflow orchestration tool using only S3-compatible* object storage. S3 is the control plane making it much simpler than alternatives. This does come with tradeoffs (see docs), but I do believe there is a niche it can serve well.

https://horv.co/buquet.html https://github.com/h0rv/buquet

* see https://github.com/h0rv/buquet/blob/main/docs/guides/s3-comp...

Hey HN,

I’m a physicist turned quant. Some friends and I 'built' SymDerive because we wanted a symbolic math library that was "Agent-Native" by design, but still a practical tool for humans.

It boils down to two main goals:

1. Agent Reliability: I’ve found that AI agents write much more reliable code when they stick to stateless, functional pipelines (Lisp-style). It keeps them from hallucinating state changes or getting lost in long procedural scripts. I wanted a library that enforces that "Input -> Transform -> Output" flow by default.

2. Easing the transition to Python: For many physicists, Mathematica is the native tongue. I wanted a way to ease that transition—providing a bridge that keeps the familiar syntax (CamelCase, Sin, Integrate) while strictly using the Python scientific stack under the hood.

What I built: It’s a functional wrapper around the standard stack (SymPy, PySR, CVXPY) that works as a standalone engine for anyone—human or agent—who prefers a pipe-based workflow.

  # The "Pipe" approach (Cleaner for agents, readable for humans)
  result = (
      Pipe((x + 1)**3)
      .then(Expand)
      .then(Simplify) 
      .value
  )

Wolfram Syntax: Integrate, Det, Solve. If you know the math, you know the API.

Modular: The heavy stuff (Symbolic Regression, Convex Optimization) are optional installs ([regression], [optimize]). It won’t bloat your venv unless you ask it to.

Physics stuff: I added tools I actually use—abstract index notation for GR, Kramers-Kronig for causal models, etc.

It’s definitely opinionated, but if you’re building agents to do rigorous math, or just want a familiar functional interface for your own research, this might help.

I have found that orchestrators (Claude Code, etc) are fairly good at learning the tools and sending tasks to the right persona, we have been surprised by how well it has worked.

Repo here: https://github.com/closedform/deriver

I will cry if roasted too hard

A simulator to be a president of Duckerican, made by AI, with random events generated by AI. Currently the simulator is rather simple, but this reveals a possibility to make more interesting applications with AI involved, beyond directly talking to the agents.

The article discusses a new feature in GitHub that allows users to see which AI model was used to contribute to a pull request, providing transparency and accountability around the use of AI in software development.

The article explores the story of the last surviving worm on Earth, as it navigates a changing environment and faces the challenges of a world where its species has vanished. It provides a poignant and reflective look at the impact of environmental changes and the loneliness of being the last of one's kind.

After reading "During Helene, I Just Wanted a Plain Text Website" on Sparkbox (https://news.ycombinator.com/item?id=46494734) , I built safe-now.live – a text-first emergency info site for USA and Canada. No JavaScript, no images, under 10KB. Pulls live FEMA disasters, NWS alerts, weather, and local resources. This is my first live website ever so looking for critical feedback on the website. Please feel free to look around.

https://safe-now.live

Inklings.social is a new social media platform that aims to provide a more positive and inclusive online experience by focusing on community-building, thoughtful discussion, and user agency over content moderation.

Hi HN,

I built "Dengen Shrine," a web-based experience of a traditional Japanese Shinto ritual.

Key Features:

Privacy by Design: Your "Kotodama" (messages/prayers) are never stored in any database. They exist only in the animation and vanish upon completion.

No Login Required: You can experience the ritual instantly without an account.

Digital Offering: For those who wish to support the project, I’ve integrated a "digital offering" (Osaisen) via Stripe. This is completely optional—you can experience the core ritual for free without any payment. It’s not a donation, but a paid digital experience that unlocks a unique "Completion Message" for supporters.

Why I built this: I wanted to explore how ancient traditions like Shinto can be reinterpreted in a digital, ephemeral way. In Shinto, words have spirits (Kotodama), and I felt that the "ephemeral" nature of the web was a perfect fit for this.

I’d love to hear your thoughts on the UI/UX and the concept of "ephemeral digital rituals."

Hey HN! I went to an ATProto meetup last week, and as a burnt-out semi-academic who hates academic publishing, I thought there might be a cool opportunity to build on Octopus (https://www.octopus.ac/), so I got a bit excited over the weekend and built Octosphere.

Hopefully some of you find it interesting! Blog post here: https://andreasthinks.me/posts/octosphere/octosphere.html

I built SwiftFiles because I was tired of uploading sensitive documents to random servers just to merge a PDF or convert an image. The idea was simple - unify all these utility tools that process different types of files into one web-based solution.

Everything here runs 100% client-side in your browser using WebAssembly (FFmpeg.wasm, PDF-lib, etc.). No files are ever uploaded to a server. It's fast, free, and private by design.

I’m looking for technical feedback on the performance and any tools you’d like to see added next!

Hi everyone,

I built a runtime to isolate untrusted code using wasm sandboxes.

Basically, it protects your host system from problems that untrusted code can cause. We’ve had a great discussion about sandboxing in Python lately that elaborates a bit more on the problem [1]. In TypeScript, wasm integration is even more natural thanks to the close proximity between both ecosystems.

The core is built in Rust. On top of that, I use WASI 0.2 via wasmtime and the component model, along with custom SDKs that keep things as idiomatic as possible.

For example, in Python we have a simple decorator:

  from capsule import task

  @task(
      name="analyze_data", 
      compute="MEDIUM",
      ram="512mb",
      allowed_files=["./authorized-folder/"],
      timeout="30s", 
      max_retries=1
  )
  def analyze_data(dataset: list) -> dict:
      """Process data in an isolated, resource-controlled environment."""
      # Your code runs safely in a Wasm sandbox
      return {"processed": len(dataset), "status": "complete"}

  import { task } from "@capsule-run/sdk"

  export const analyze = task({
      name: "analyzeData", 
      compute: "MEDIUM", 
      ram: "512mb",
      allowedFiles: ["./authorized-folder/"],
      timeout: 30000, 
      maxRetries: 1
  }, (dataset: number[]) => {
      return {processed: dataset.length, status: "complete"}
  });

It's still quite early, but I'd love feedback. I’ll be around to answer questions.

GitHub: https://github.com/mavdol/capsule

[1] https://news.ycombinator.com/item?id=46500510

Hi all,

I have built Cimba, a multithreaded discrete event simulation library in C.

Cimba uses POSIX pthread multithreading for parallel execution of multiple simulation trials, while coroutines provide concurrency inside each simulated trial universe. The simulated processes are based on asymmetric stackful coroutines with the context switching hand-coded in assembly.

The stackful coroutines make it natural to express agentic behavior by conceptually placing oneself "inside" that process and describing what it does. A process can run in an infinite loop or just act as a one-shot customer passing through the system, yielding and resuming execution from any level of its call stack, acting both as an active agent and a passive object as needed. This is inspired by my own experience programming in Simula67, many moons ago, where I found the coroutines more important than the deservedly famous object-orientation.

Cimba turned out to run really fast. In a simple benchmark, 100 trials of an M/M/1 queue run for one million time units each, it ran 45 times faster than an equivalent model built in SimPy + Python multiprocessing. The running time was reduced by 97.8 % vs the SimPy model. Cimba even processed more simulated events per second on a single CPU core than SimPy could do on all 64 cores.

The speed is not only due to the efficient coroutines. Other parts are also designed for speed, such as a hash-heap event queue (binary heap plus Fibonacci hash map), fast random number generators and distributions, memory pools for frequently used object types, and so on.

The initial implementation supports the AMD64/x86-64 architecture for Linux and Windows. I plan to target Apple Silicon next, then probably ARM.

I believe this may interest the HN community. I would appreciate your views on both the API and the code. Any thoughts on future target architectures to consider?

Docs: https://cimba.readthedocs.io/en/latest/

Repo: https://github.com/ambonvik/cimba

bunqueue is a BUN-based queue service that provides a simple and efficient way to manage asynchronous tasks. It offers features like job scheduling, fault tolerance, and automatic retries, making it a useful tool for building scalable and reliable distributed systems.

There's been a lot of discussion around the california budget and some proposed tax policies, so I asked claude code to research the budget and turn it into an interactive dashboard.

Using async subagents claude was able to research ~a dozen budget line items at once across multiple years, adding lots of helpful context and graphs to someone like me who was starting with little familiarity.

It still struggles with frontend changes, but for research this probably 20-40x's my throughput.

Let me know any additional data or visualizations that would be interesting to add!

The article introduces behavior-driven testing, a software development approach that focuses on defining and verifying the expected behavior of an application. It discusses the benefits of this methodology, such as improved collaboration and better-aligned requirements, and provides an overview of the key concepts and practices involved.