Show stories

Hi, I've been working on something I've been thinking for long time but since I had no experience with macOS screen savers I always posponed. Now thanks to Claude I was able to create a screensaver that scroll ANSI files while your computer is idle.

It allow to use local ANS files or packs directly from 16colo.rs.

Repo: https://github.com/lardissone/ansi-saver

I built µJS because I wanted AJAX navigation without the verbosity of HTMX or the overhead of Turbo.

It intercepts links and form submissions, fetches pages via AJAX, and swaps fragments of the DOM. Single <script> tag, one call to `mu.init()`. No build step, no dependencies.

Key features: patch mode (update multiple fragments in one request), SSE support, DOM morphing via idiomorph, View Transitions, prefetch on hover, polling, and full HTTP verb support on any element.

At ~5KB gzipped, it's smaller than HTMX (16KB) and Turbo (25KB), and works with any backend: PHP, Python, Go, Ruby, whatever.

Playground: https://mujs.org/playground

Comparison with HTMX and Turbo: https://mujs.org/comparison

About the project creation, why and when: https://mujs.org/about

GitHub: https://github.com/Digicreon/muJS

Happy to discuss the project.

Old School Realms is a retro-style gaming platform that offers a collection of classic RPG-inspired titles, allowing players to explore various fantasy worlds and engage in engaging gameplay reminiscent of the golden era of gaming.

I have spent years trying to understand and follow established software architectures - and wound up writing my own at the end: SRA (Specification - Realization - Assembly). Please do check it out and let me know what you think!

Background:

Whenever I would learn a new architecture, the initial ideas seemed interesting but the implementation almost always ended up with my autistic sense of detail screaming loudly about one or more shortcomings and even inconsistencies.

For example, a lot of architectures rely on human discipline, give certain aspects of the software - such as the UI - an unproportional amount of power, or promote coupling despite claiming otherwise.

As a programming generalist, I also found certain architectures hard to transfer between platforms and project types, especially in multiplatform code bases.

In the end I started from the basics; What is good code? What principles are common regardless of language? How can we make good code easier to write than bad code? What makes code adaptable to evolving technology and changing requirements?

The result: SRA. Enjoy!

The article discusses the life and work of the renowned Renaissance artist, Leonardo da Vinci, and his enduring influence on art, science, and innovation.

Hi HN, I’ve tried just about every clipboard manager for macOS, but I've always ran into the same two issues: either they were heavy Electron apps that felt sluggish, or they required me to take my hands off the keyboard to find what I needed. Raycast is what I used most of the time, but it's slow in loading screenshots and is search first, meaning I needed to leave the loved home row to scroll down through items.

I built Paster because I wanted something that felt like an extension of my terminal and had instant load of the content being copied. It's written in Rust to keep the latency as low as possible and uses a local SQLite database for history. It's completely private and does not have any telemetry, your data is your own. It does reach to it's domain to validate the license.

Some specific choices I made: - Navigation: I mapped it to j/k and / for search. If you use Vim or a terminal, it should feel like second nature. - Privacy: I’m not a fan of cloud-syncing my clipboard. Everything stays local on your machine. - Quick look: I've added a nice little bonus feature to view each clipboard item in a larger quick look window. Pretty handy for screenshots and offers syntax highlighting for text.

It’s currently a paid app with a 7-day trial. I’m really curious what the community thinks about the "Vim-for-everything" approach. For transparency sake, it's built with help from AI (Gemini) mostly for UI stuff which requires lots of boiler plate.

It's Macos only for now, I do intend to work on a Linux version but no promises.

Homebrew engine https://github.com/willtobyte/carimbo

I've been building a modern Ultima Online server emulator from scratch. It's not feature-complete (no combat, no skills yet), but the foundation is solid and I wanted to share it early.

What it does today: - Full packet layer for the classic UO client (login, movement, items, mobiles) - Lua scripting for item behaviors (double-click a potion, open a door — all defined in Lua, no C# recompile) - Spatial world partitioned into sectors with delta sync (only sends packets for new sectors when crossing boundaries) - Snapshot-based persistence with MessagePack - Source generators for automatic DI wiring, packet handler registration, and Lua module exposure - NativeAOT support — the server compiles to a single native binary - Embedded HTTP admin API + React management UI - Auto-generated doors from map statics (same algorithm as ModernUO/RunUO)

Tech stack: .NET 10, NativeAOT, NLua, MessagePack, DryIoc, Kestrel

What's missing: Combat, skills, weather integration, NPC AI. This is still early — the focus so far has been on getting the architecture right so adding those systems doesn't require rewiring everything.

Why not just use ModernUO/RunUO? Those are mature and battle-tested. I started this because I wanted to rethink the architecture from scratch: strict network/domain separation, event-driven game loop, no inheritance-heavy item hierarchies, and Lua for rapid iteration on game logic without recompiling.

GitHub: https://github.com/moongate-community/moongatev2

I got tired of sharing AI demos with terminal screenshots or screen recordings.

Claude Code already stores full session transcripts locally as JSONL files. Those logs contain everything: prompts, tool calls, thinking blocks, and timestamps.

I built a small CLI tool that converts those logs into an interactive HTML replay.

You can step through the session, jump through the timeline, expand tool calls, and inspect the full conversation.

The output is a single self-contained HTML file — no dependencies. You can email it, host it anywhere, embed it in a blog post, and it works on mobile.

Repo: https://github.com/es617/claude-replay

Example replay: https://es617.github.io/assets/demos/peripheral-uart-demo.ht...

Zero dependencies. No external databases. Single binary. Just deploy and go. I needed something that would allow for real-time monitoring, and installation is as simple as dropping a single file and running it. That's exactly what Kula is. Kula is the Polish word for "ball," as in "crystal ball." The project is in constant development, but I'm already using it on multiple servers in production. It still has some rough edges and needs to mature, but I wanted to share it with the world now—perhaps someone else will find it useful and be willing to help me develop it by testing or providing feedback. Cheers! Github: https://github.com/c0m4r/kula

Hi HN,

I built OpenGraviton, an open-source AI inference engine designed to push the limits of running extremely large models on consumer hardware.

The system combines several techniques to drastically reduce memory and compute requirements:

• 1.58-bit ternary quantization ({-1, 0, +1}) for ~10x compression • dynamic sparsity with Top-K pruning and MoE routing • mmap-based layer streaming to load weights directly from NVMe SSDs • speculative decoding to improve generation throughput

These allow models far larger than system RAM to run locally.

In early benchmarks, OpenGraviton reduced TinyLlama-1.1B from ~2.05GB (FP16) to ~0.24GB using ternary quantization. Synthetic stress tests at the 140B scale show that models which would normally require ~280GB FP16 can fit within ~35GB when packed with the ternary format.

The project is optimized for Apple Silicon and currently uses custom Metal + C++ tensor unpacking.

Benchmarks, architecture, and details: https://opengraviton.github.io

GitHub: https://github.com/opengraviton

Single Rust binary (~3 MB) that reads the OS accessibility tree and gives every UI element a REST endpoint. Click buttons, type text, toggle checkboxes — all via JSON. Works as an MCP server too, so Claude/Cursor/Windsurf can control any desktop app out of the box.

Windows + Linux + macOS. MIT licensed.

The article describes Diamond, an open-source project that provides a command-line interface (CLI) for managing and interacting with various cloud services, including AWS, GCP, and Azure. It aims to simplify cloud management tasks and offer a consistent experience across different cloud platforms.

This is a game I wish I had as a kid learning programming. The concept of it is fairly similar to other coding games like Screeps, but instead of a complex world with intricate mechanics, Yare is a lot more minimal and approachable with quick 1v1 <3 min matches.

It's purely a passion project with no monetization aspirations. And it's open source: https://github.com/riesvile/yare

The first version 'launched' several years ago and I got some good feedback here: https://news.ycombinator.com/item?id=27365961 that I iterated on.

The latest overhaul is a result of simplifying everything while still keeping the skill ceiling high. And at least the LLMs seem to struggle with this challenge for now (I run a small tournament between major models - results and details here: https://yare.io/ai-arena

I'd love to hear your thoughts

I built a browser-based port of fogleman/primitive — a Go CLI tool that approximates images using primitive shapes (triangles, ellipses, beziers, etc.) via a hill-climbing algorithm. The original tool requires building from source and running from the terminal, which isn't exactly accessible. I compiled the core logic to WebAssembly so anyone can drop an image and watch it get reconstructed shape by shape, entirely client-side with no server involved.

Demo: https://primitive-playground.taiseiue.jp/ Source: https://github.com/taiseiue/primitive-playground

Curious if anyone has ideas for shapes or features worth adding.

pkgsmith.app is a web application that helps developers manage their package dependencies efficiently. It offers features like dependency visualization, conflict resolution, and license compliance checking to streamline the package management process.

Hi HN,

I built JotSpot as a super lightweight tool for quickly writing and sharing markdown notes.

The idea was to remove friction. You open the page, start typing, and the note autosaves in the background. Each note becomes a clean shareable page.

Features: - Markdown support - Live preview - Autosave - Shareable links

Tech stack: Flask, HTMX, and PostgreSQL running on a self-hosted server.

Built with Flask and HTMX to keep things simple and avoid heavy JS frameworks.

I'd love feedback from developers here — especially about features you'd expect from something like this.

Thanks!

I kept waking up from vivid dreams and losing them before I could write anything down.

The neuroscience is clear — during REM sleep, norepinephrine (the neurotransmitter that consolidates memories) is almost completely suppressed. Dreams exist only in working memory when you wake up. The moment your brain starts processing new inputs the memory gets displaced. The window is roughly 2 minutes.

So I built around that window instead of ignoring it.

How it works: - Set your alarm inside Somnia - When it fires, a server-side entry window opens - Capture screen launches directly from notification - Type the first word and the timer stops - Miss the 2 minutes and that day locks forever - No override, no extension, no exceptions

The window enforcement is server-side only — entry_windows table in Postgres with window_expires_at set when the alarm fires, validated on every API call. The client timer is purely visual. You can't cheat it by killing the app or going offline.

Stack: Next.js 14 App Router, Supabase, Tiptap, web-push + VAPID, GitHub Actions cron (Vercel Hobby blocks minute-level crons so GitHub Actions calls /api/cron/fire-alarms every minute), Vercel.

Free tier available. Happy to answer questions about the implementation or the product.

Hello HN,

I built Bulk Image Generator because I was frustrated with how slow it is to iterate on visual assets. Tools like Midjourney are great for single images, but when you need 50+ variations of a product shot or a game asset based on a specific reference, the manual process is a pain.

What it does:

Upload one reference image and generate 100+ AI variations while maintaining style/structure.

Batch background removal (because once you generate 100 images, you usually need to clean them up).

Fast bulk download.

Why I’m sharing it here: I’m looking for feedback on the consistency of the output. I also want to know if there are specific "batch" workflows in your design or dev process that are still too manual.

I’ll be around to answer any questions about the implementation or future roadmap!

About 10 months ago I posted OSle here [1], an OS in x86 assembly that fits in the 510 bytes of a bootloader. It got great discussion and I kept working on it. All userland programs were 16-bit assembly until last week. I started playing around with giving it a C runtime and here we are: you can now write programs for OSle in C. The SDK ships a small C runtime that provides the same API the assembly SDK has — file I/O, process management, screen output. Guest programs compile with a standard toolchain and run on the same 510-byte kernel.

Try it in the browser: https://shikaan.github.io/osle/ [1]: https://news.ycombinator.com/item?id=43866585

I built a CLI tool in Go that extracts structured data (JSON, CSV, Parquet) from messy PDFs and HTML pages.

The core idea: LLMs are great at understanding structure but wasteful for bulk data extraction. So smelt uses a two-pass architecture:

1. A fast Go capture layer parses the document and detects table-like regions 2. Those regions (not the whole document) get sent to Claude for schema inference — column names, types, nesting 3. The Go layer then does deterministic extraction using the inferred schema

This means the LLM is never in the hot path of actual data processing. It figures out "what is this data?" once, and then Go handles the "extract 10,000 rows" part efficiently.

Usage is simple:

  smelt invoice.pdf --format json
  smelt https://example.com/pricing --format csv
  smelt report.pdf --schema   # just show the inferred structure

Still early (no OCR yet, HTML is limited to <table> elements), but it handles the common cases well. Would love feedback on the architecture — especially from anyone who's dealt with PDF table extraction at scale.

When developers apply for jobs they usually send a portfolio link, GitHub, or resume.

But the process is a complete black box.

You never know:

• if the recruiter opened your resume • which repositories they checked • what projects caught their attention

So I built recruiter analytics for developer portfolios.

It tracks:

• profile views • repository clicks • resume open rate • viewer location insights • company type viewing the profile

The goal is to give developers a feedback loop similar to product analytics.

Instead of guessing what recruiters value, you can see which projects or skills actually get attention.

I wrote a technical breakdown of how the tracking works and the reasoning behind the design here:

Curious to hear what the HN community thinks about adding analytics to developer portfolios.

Hi HN,

I’m part of the team building Sniphi.

Sniphi is a modular digital nose that uses gas sensors and machine-learning models to convert volatile organic compound (VOC) data into a machine-readable signal that can be integrated into existing QA, monitoring, or automation systems. The system is currently in an R&D phase, but already exists as working hardware and software and is being tested in real environments.

The project grew out of earlier collaborations with university researchers on gas sensors and odor classification. What we kept running into was a gap between promising lab results and systems that could actually be deployed, integrated, and maintained in real production environments.

One of our core goals was to avoid building a single-purpose device. The same hardware and software stack can be trained for different use cases by changing the training data and models, rather than the physical setup. In that sense, we think of it as a “universal” electronic nose: one platform, multiple smell-based tasks.

Some design principles we optimized for:

- Composable architecture: sensor ingestion, ML inference, and analytics are decoupled and exposed via APIs/events

- Deployment-first thinking: designed for rollout in factories and warehouses, not just controlled lab setups

- Cloud-backed operations: model management, monitoring, updates run on Azure, which makes it easier to integrate with existing industrial IT setups

- Trainable across use cases: the same platform can be retrained for different classification or monitoring tasks without redesigning the hardware

One public demo we show is classifying different coffee aromas, but that’s just a convenient example. In practice, we’re exploring use cases such as:

- Quality control and process monitoring

- Early detection of contamination or spoilage

- Continuous monitoring in large storage environments (e.g. detecting parasite-related grain contamination in warehouses)

Because this is a hardware system, there’s no simple way to try it over the internet. To make it concrete, we’ve shared:

- A short end-to-end demo video showing the system in action (YouTube)

- A technical overview of the architecture and deployment model: https://sniphi.com/

At this stage, we’re especially interested in feedback and conversations with people who:

- Have deployed physical sensors at scale

- Have run into problems that smell data might help with

- Are curious about piloting or testing something like this in practice

We’re not fundraising here. We’re mainly trying to learn where this kind of sensing is genuinely useful and where it isn’t.

Happy to answer technical questions.

We built an ant colony simulation as an internal hiring challenge at Moment and decided to open it up publicly.

You write a program in a custom assembly-like (we call it ant-ssembly) instruction set that controls 200 ants. Each ant can sense nearby cells (food, pheromones, home, other ants) but has no global view. The only coordination mechanism is pheromone trails, which ants can emit and sense them, but that's it. Your program runs identically on every ant.

The goal is to collect the highest percentage of food across a set of maps. Different map layouts (clustered food, scattered, obstacles) reward very different strategies. The leaderboard is live.

Grand prize is a trip to Maui for two paid for by Moment. Challenge closes March 12.

Curious what strategies people discover. We've seen some surprisingly clever emergent behavior internally.

Most CLI players have very rudimentary visualizations, so I focused on creating a "Quantum Spectrum Analyzer"—a high-frame-rate, physics-driven rainbow visualizer that uses gravity-based peak falling and mirrored symmetry.

Under the hood, it manages a pool of ffplay instances and uses OS-level process suspension (via ctypes on Windows and signal on POSIX) to provide an "instant-off" pause experience without cutting the audio buffer mid-stream.

Check it out here: https://github.com/iamekabir-web/Nirvana

LLMs are better at being the "mouth" than the "brain" and I can prove it mathematically. I built a deterministic graph engine that offloads reasoning from the LLM. It reduces token usage by 89% and makes a tiny 0.8B model trace enterprise execution paths flawlessly. Here is the white paper and the reproducible benchmark.

Hi HN!

I'm the author of an Elixir Agent Framework called Jido. We reached our 2.0 release this week, shipping a production-hardened framework to build, manage and run Agents on the BEAM.

Jido now supports a host of Agentic features, including:

- Tool Calling and Agent Skills - Comprehensive multi-agent support across distributed BEAM processes with Supervision - Multiple reasoning strategies including ReAct, Chain of Thought, Tree of Thought, and more - Advanced workflow capabilities - Durability through a robust Storage and Persistence layer - Agentic Memory - MCP and Sensors to interface with external services - Deep observability and debugging capabilities, including full stack OTel

I know Agent Frameworks can be considered a bit stale, but there hasn't been a major release of a framework on the BEAM. With a growing realization that the architecture of the BEAM is a good match for Agentic workloads, the time was right to make the announcement.

My background is enterprise engineering, distributed systems and Open Source. We've got a strong and growing community of builders committed to the Jido ecosystem. We're looking forward to what gets built on top of Jido!

Come build agents with us!

Title: Show HN: PageAgent, A GUI agent that lives inside your web app

Hi HN,

I'm building PageAgent, an open-source (MIT) library that embeds an AI agent directly into your frontend.

I built this because I believe there's a massive design space for deploying general agents natively inside the web apps we already use, rather than treating the web merely as a dumb target for isolated bots.

Currently, most AI agents operate from external clients or server-side programs, effectively leaving web development out of the AI ecosystem. I'm experimenting with an "inside-out" paradigm instead. By dropping the library into a page, you get a client-side agent that interacts natively with the live DOM tree and inherits the user's active session out of the box, which works perfectly for SPAs.

To handle cross-page tasks, I built an optional browser extension that acts as a "bridge". This allows the web-page agent to control the entire browser with explicit user authorization. Instead of a desktop app controlling your browser, your web app is empowered to act as a general agent that can navigate the broader web.

I'd love to start a conversation about the viability of this architecture, and what you all think about the future of in-app general agents. Happy to answer any questions!