Show stories

Polpo is an open-source mobile controller for AI coding agents. It runs a lightweight server on your machine and gives you a phone-friendly dashboard to manage sessions, send prompts, approve tool calls, and review plans.

We just released v1.1.0 with support for 5 agents (Claude Code, Codex, Gemini, OpenCode, Pi), skills management from the phone (browse/install/remove skills from skills.sh), and the ability to start new sessions without touching the terminal.

The idea started because we wanted to kick off coding tasks from the couch and check on them from the phone. It grew from there.

Built with Node.js, no framework on the frontend, WebSocket for real-time updates. Works on LAN or remotely via tunnel (cloudflared, localtunnel, ngrok, SSH).

Built by PugliaTechs, a non-profit association from Puglia, Italy.

Claude Code deleted my research and plan markdown files and informed me: “I accidentally rm -rf'd real directories in my Obsidian vault through a symlink it didn't realize was there: I made a mistake. “

Unfortunately the backup of my documentation accidentally hadn’t run for a month. So I built claude-file-recovery, a CLI-tool and TUI that is able to extract your files from your ~/.claude session history and thankfully I was able to recover my files. It's able to extract any file that Claude Code ever read, edited or wrote. I hope you will never need it, but you can find it on my GitHub and pip. Note: It can recover an earlier version of a file at a certain point in time.

pip install claude-file-recovery

I built unf after I pasted a prompt into the wrong agent terminal and it overwrote hours of hand-edits across a handful of files. Git couldn't help because I hadn't finished/committed my in progress work. I wanted something that recorded every save automatically so I could rewind to any point in time. I wanted to make it difficult for an agent to permanently screw anything up, even with an errant rm -rf

unf is a background daemon that watches directories you choose (via CLI) and snapshots every text file on save. It stores file contents in an object store, tracks metadata in SQLite, and gives you a CLI to query and restore any version. The install includes a UI, as well to explore the history through time.

The tool skips binaries and respects `.gitignore` if one exists. The interface borrows from git so it should feel familiar: unf log, unf diff, unf restore.

I say "UN-EF" vs U.N.F, but that's for y'all to decide: I started by calling the project Unfucked and got unfucked.ai, which if you know me and the messes I get myself into, is a fitting purchase.

The CLI command is `unf` and the Tauri desktop app is titled "Unfudged" (kids safe name).

How it works: https://unfucked.ai/tech (summary below)

The daemon uses FSEvents on macOS and inotify on Linux. When a file changes, `unf` hashes the content with BLAKE3 and checks whether that hash already exists in the object store — if it does, it just records a new metadata entry pointing to the existing blob. If not, it writes the blob and records the entry. Each snapshot is a row in SQLite. Restores read the blob back from the object store and overwrite the file, after taking a safety snapshot of the current state first (so restoring is itself reversible).

There are two processes. The core daemon does the real work of managing FSEvents/inotify subscriptions across multiple watched directories and writing snapshots. A sentinel watchdog supervises it, kept alive and aligned by launchd on macOS and systemd on Linux. If the daemon crashes, the sentinel respawns it and reconciles any drift between what you asked to watch and what's actually being watched. It was hard to build the second daemon because it felt like conceding that the core wasn't solid enough, but I didn't want to ship a tool that demanded perfection to deliver on the product promise, so the sentinel is the safety net.

Fingers crossed, I haven’t seen it crash in over a week of personal usage on my Mac. But, I don't want to trigger "works for me" trauma.

The part I like most: On the UI, I enjoy viewing files through time. You can select a time section and filter your projects on a histogram of activity. That has been invaluable in seeing what the agent was doing.

On the CLI, the commands are composable. Everything outputs to stdout so you can pipe it into whatever you want. I use these regularly and AI agents are better with the tool than I am:

  # What did my config look like before we broke it?
  unf cat nginx.conf --at 1h | nginx -t -c /dev/stdin

  # Grep through a deleted file
  unf cat old-routes.rs --at 2d | grep "pub fn"

  # Count how many lines changed in the last 10 minutes
  unf diff --at 10m | grep '^[+-]' | wc -l

  # Feed the last hour of changes to an AI for review
  unf diff --at 1h | pbcopy

  # Compare two points in time with your own diff tool
  diff <(unf cat app.tsx --at 1h) <(unf cat app.tsx --at 5m)

  # Restore just the .rs files that changed in the last 5 minutes
  unf diff --at 5m --json | jq -r '.changes[].file' | grep '\.rs$' | xargs -I{} unf restore {} --at 5m

  # Watch for changes in real time
  watch -n5 'unf diff --at 30s'

Install & Usage:

  > brew install cyrusradfar/unf/unfudged

EDIT: Folks are asking for the source, if you're interested watch https://github.com/cyrusradfar/homebrew-unf -- I'll migrate there if you want it.

Hi HN, I'm Narek. I built Manim-Web, a TypeScript/JavaScript port of 3Blue1Brown’s popular Manim math animation engine.

The Problem: Like many here, I love Manim's visual style. But setting it up locally is notoriously painful - it requires Python, FFmpeg, Cairo, and a full LaTeX distribution. It creates a massive barrier to entry, especially for students or people who just want to quickly visualize a concept.

The Solution: I wanted to make it zero-setup, so I ported the engine to TypeScript. Manim-Web runs entirely client-side in the browser. No Python, no servers, no install. It runs animations in real-time at 60fps.

How it works underneath: - Rendering: Uses Canvas API / WebGL (via Three.js for 3D scenes). - LaTeX: Rendered and animated via MathJax/KaTeX (no LaTeX install needed!). - API: I kept the API almost identical to the Python version (e.g., scene.play(new Transform(square, circle))), meaning existing Manim knowledge transfers over directly. - Reactivity: Updaters and ValueTrackers follow the exact same reactive pattern as the Python original.

Because it's web-native, the animations are now inherently interactive (objects can be draggable/clickable) and can be embedded directly into React/Vue apps, interactive textbooks, or blogs. I also included a py2ts converter to help migrate existing scripts.

Live Demo: https://maloyan.github.io/manim-web/examples GitHub: https://github.com/maloyan/manim-web

It's open-source (MIT). I'm still actively building out feature parity with the Python version, but core animations, geometry, plotting, and 3D orbiting are working great. I would love to hear your feedback, and I'll be hanging around to answer any technical questions about rendering math in the browser!

RetroTick parses PE/NE/MZ binaries, emulates an x86 CPU, and stubs enough Win32/Win16/DOS APIs to run classics like FreeCell, Minesweeper, Solitaire and QBasic, entirely in the browser. Built with Preact + Vite + TypeScript.

Demo: https://retrotick.com

GitHub: https://github.com/lqs/retrotick

Clojure.stream is a site dedicated to the Clojure programming language, providing resources, news, and community discussions for Clojure developers. The site covers a range of Clojure-related topics, including libraries, tools, and best practices.

Small codebases were always a good thing. With coding agents, there's now a huge advantage to having a codebase small enough that an agent can hold the full thing in context.

Repo Tokens is a GitHub Action that counts your codebase's size in tokens (using tiktoken) and updates a badge in your README. The badge color reflects what percentage of an LLM's context window the codebase fills: green for under 30%, yellow for 50-70%, red for 70%+. Context window size is configurable and defaults to 200k (size of Claude models).

It's a composite action. Installs tiktoken, runs ~60 lines of inline Python, takes about 10 seconds. The action updates the README but doesn't commit, so your workflow controls the git strategy.

The idea is to make token size a visible metric, like bundle size badges for JS libraries. Hopefully a small nudge to keep codebases lean and agent-friendly.

GitHub: https://github.com/qwibitai/nanoclaw/tree/main/repo-tokens

Former investigative reporter turned developer. I built a simple breaking-news monitor because tracking events across platforms is a mess now that Twitter’s unreliable.

Bluesky is the backbone (a fraction of twitter, but still lots of journalists and OSINT folks), plus RSS, Telegram, Reddit, YouTube and Mastodon. Everything is one chronological feed with no algorithm, clear source labels, and lightweight activity detection when a region spikes above baseline (frequency math, not LLMs).

But we do have a (hopefully non-obtrusive) AI-generated recent/post summary.

Been building for a while, figured I'd post in light of today's events. Can't promise it will survive or is good, any feedback appreciated.

Built with Next.js 15 + TypeScript + Tailwind on Vercel. Real coded + supervised vibe coded. Free, no login, signups, ect

https://pulse-osint.vercel.app/

Hi HN. I had faced an issue where I wanted to know how a place I was travelling to looked like. Like everyone else I looked at google maps and snap chat too. But Google streetview images were usually old and snapchat snaps lacked control. So I built GeoQuests for anyone who wants to know what’s going on on Earth.

You drop a quest at a real location. People see it on the map, go there, and complete it by taking a photo when they’re close enough. The app checks the image's GPS coordinatee, time of the image and if the image fits the request's description. I am using Gemini to verify the image.

Basically you, pin a place -> others discover it on the map -> they go there and complete the quest with a verified photo.

You can browse the map, see public quests and create quests. Wanted some feedback on the project.

The article discusses the concept of the 'silent filter', where people often self-censor their thoughts and opinions due to social pressures and the fear of being judged or criticized. It explores the impact of this phenomenon on open discourse and the importance of creating an environment that encourages authentic expression.

Hacker Smacker adds friend/foe functionality to Hacker News. Three little orbs appear next to every commenter's name. Click to friend or foe a commenter and you'll more easily spot them on future threads. Makes it easy to scroll and spot the commenters you love to read (and hate to read).

Main website: https://hackersmacker.org

Chrome/Edge extension: https://chromewebstore.google.com/detail/hacker-smacker/lmcg... Safari extension: https://apps.apple.com/us/app/hacker-smacker/id1480749725 Firefox extension: https://addons.mozilla.org/en-US/firefox/addon/hacker-smacke...

The interesting part is friend-of-a-friend: if you friend someone who also uses Hacker Smacker, you'll see their friends and foes highlighted too. This lets you quickly scan long comment threads and find the good stuff based on people you trust.

I built this to learn how FoaF relationships work with Redis sets, then brought the same technique to NewsBlur's social layer. The backend is CoffeeScript/Node.js/Redis, and the extension works on Chrome, Edge, Firefox, and Safari.

Technically I wrote this back in 2011, but never built a proper auth system until now. So I've been using it for 15 years and it's been great. PG once saw it on my laptop (back when he was still moderating HN, in 2012) and remarked that it was neat.

Thanks to Mihai Parparita for help with the Chrome extension sandboxing and Greg Brockman for helping design the authentication system.

Source is on GitHub: https://github.com/samuelclay/hackersmacker

Directly inspired by Slashdot's friend/foe system, which I always wished HN had. Happy to answer questions!

Hi HN,

I wanted to share a web game I’ve been building in HTML, JavaScript, MySQL, and PHP called LINEX.

It is primarily designed and optimized to be played in the mobile browser.

The idea is simple: you have an 8x8 board where you must place pieces (Tetris-style and some custom shapes) to clear horizontal and vertical lines.

Yes, someone might think this has already been done, but let me explain.

You choose where to place the piece and how to rotate it. The core interaction consists of "drawing" the piece tap-by-tap on the grid, which provides a very satisfying tactile sense of control and requires a much more thoughtful strategy.

To avoid the flat difficulty curve typical of games in this genre, I’ve implemented a couple of twists:

1. Progressive difficulty (The board fights back): As you progress and clear lines, permanently blocked cells randomly appear on the board. This forces you to constantly adapt your spatial vision.

2. Tools to defend yourself: To counter frustration, you have a very limited number of aids (skip the piece, choose another one, or use a special 1x1 piece). These resources increase slightly as the board fills up with blocked cells, forcing you to decide the exact right moment to use them.

The game features a daily challenge driven by a date-based random seed (PRNG). Everyone gets exactly the same sequence of pieces and blockers. Furthermore, the base difficulty scales throughout the week: on Mondays you start with a clean board (0 initial blocked cells, although several will appear as the game progresses), and the difficulty ramps up until Sunday, where you start the game with 3 obstacles already in place.

In addition to the global medal leaderboard, you can add other users to your profile to create a private leaderboard and compete head-to-head just with your friends.

Time is also an important factor, as in the event of a tie in cleared lines, the player who completed them faster will rank higher on the leaderboard.

I would love for you to check it out. I'm especially looking for honest feedback on the difficulty curve, the piece-placement interaction (UI/UX), or the balancing of obstacles/tools, although any other ideas, critiques, or suggestions are welcome.

https://www.playlinex.com/

Thanks!

Open-source tutorial series teaching real-time graphics programming with SDL's GPU API. Covers everything from Hello Window to SSAO, with math lessons, engine lessons, and a UI track building font rendering from scratch. Every lesson is a standalone C program with commented code explaining why, not just what. The whole project was built with Claude Code. Each lesson also distills into a reusable Claude Code skill — copy them into your own project and build games with AI that actually understands the GPU patterns.

deff is an interactive Rust TUI for reviewing git diffs side-by-side with syntax highlighting and added/deleted line tinting. It supports keyboard/mouse navigation, vim-style motions, in-diff search (/, n, N), per-file reviewed toggles, and both upstream-based and explicit --base/--head comparisons. It can also include uncommitted + untracked files (--include-uncommitted) so you can review your working tree before committing.

Would love to get some feedback

My partner, Nick Hodges, and I, David Millington, have been on the Internet for a very long time -- since the Usenet days. We’ve seen it all, and have long been frustrated by bad comments, horrible people, and discouraging discussions. We've also been around places where the discussion is wonderful and productive. How to get more of the latter and less of the former?

Current moderation tools just seem to focus on deletion and banning. Wouldn’t it be helpful to encourage productive discussion and teach people how to discuss and argue (in the debate sense) better?

A year ago we started building Respectify to help foster healthy communication. Instead of just deleting bad-faith comments, we suggest better, good-faith ways to say what folks are trying to say. We help people avoid: * Logical fallacies (false dichotomy, strawmen, etc.) * Tone issues (how others will read the comment) * Relevance to the actual page/post topic * Low-effort posts * Dog whistles and coded language

The commenter gets an explanation of what's wrong and a chance to edit and resubmit. It's moderation + education in one step. We want, too, to automate the entire process so the site owner can focus on content and not worry about moderation at all. And over time, comment by comment, quietly coach better thinking.

Our main website has an interactive demo: https://respectify.ai. As the demo shows, the system is completely tunable and adjustable, from "most anything goes" to "You need to be college debate level to get by me".

We hope the result is better discussions and a better Internet. Not too much to ask, eh?

We love the kind of feedback this group is famous for and hope you will supply some!

TerminalPhone is a single, self-contained Bash script that provides anonymous, end-to-end encrypted voice and text communication between two parties over the Tor network. It operates as a walkie-talkie: you record a voice message, and it is compressed, encrypted, and transmitted to the remote party as a single unit. You can also send encrypted text messages during a call. No server infrastructure, no accounts, no phone numbers. Your Tor hidden service .onion address is your identity.

I've liked all the projects that put LLMs into game environments. It's been a weird juxtaposition, though: frontier LLMs can one-shot full coding projects, and those same models struggle to get out of Pokémon Red's Mt. Moon.

Because of this, I wanted to create a game environment that put this generation of frontier LLMs' top skill, coding, on full display.

Ten years ago, a team released a game called Screeps. It was described as an "MMO RTS sandbox for programmers." The Screeps paradigm of writing code and having it executed in a real-time game environment is well suited to LLMs. Drawing on a version of the Screeps open source API, LLM Skirmish pits LLMs head-to-head in a series of 1v1 real-time strategy games.

In my testing I found that Claude Opus 4.5 was the most dominant model, but it showed weakness in round 1 as it was overly focused on its in-game economy. Meanwhile, I probably spent a third of all code on sandbox hardening because GPT 5.2 kept trying to cheat by pre-reading its opponent's strategies.

If there's interest, I'm planning on doing a round of testing with the latest generation of LLMs (Claude 4.6 Opus, GPT 5.3 Codex, etc.).

You can run local matches via CLI. I'm running a hosted match runner with Google Cloud Run that uses isolated-vm. The match playback visualizer is statically served from Cloudflare.

I've created a community ladder that you can submit strategies to via CLI, no auth required. I've found that the CLI plus the skill.md that's available has been enough for AI agents to immediately get started.

Website: https://llmskirmish.com

API docs: https://llmskirmish.com/docs

GitHub: https://github.com/llmskirmish/skirmish

A video of a match: https://www.youtube.com/watch?v=lnBPaZ1qamM

Link is to driver. The networking stack used is https://github.com/soypat/lneto

Demo up at http://gsan.whittileaks.com

My 10-year-old son has been deep in low-level rabbit holes lately and ended up vibe-coding his own operating system. Since he’s still a kid and not on HN himself, I’m posting this on his behalf with his permission.

This started as curiosity about how computers actually boot, and somehow escalated into writing a kernel, building a GUI, and setting up CI that produces a bootable OS image on every commit.

BananaOS is a small experimental operating system built mainly for learning and exploration of low-level systems programming. It currently targets i386 BIOS systems and is designed to run on extremely constrained hardware. Fun fact: Wallpaper logic, one of the most important OS functionalities, is directly implemented in the kernel. That cracked my son up!

Some highlights:

Multiboot-compliant kernel loaded via GRUB

VESA framebuffer graphics with double buffering

Custom window manager with movable and resizable windows

Dock-style application launcher

PS/2 keyboard and mouse input handling

PCI enumeration and AHCI SATA support

Basic applications (terminal, notepad, calculator, file explorer, settings)

Memory detection and allocation based on available RAM

Boots in QEMU with about 11.2 MB RAM

Includes an ISR workaround to emulate CMOV so it can boot on Intel 486 CPUs

One thing I found particularly fun: he also added GitHub Actions workflows that automatically build the OS image for every commit, so the repo continuously produces fresh bootable artifacts.

The project is very much experimental and should only be run inside an Virtual Machine.

Repo (with build instructions and screenshots):

https://github.com/Banaxi-Tech/BananaOS

Quick start (only on Linux, check dependencies, and see README):

git clone https://github.com/Banaxi-Tech/BananaOS cd BananaOS make qemu-system-i386 -cdrom bananaos.img -m 128M

Retro mode:

qemu-system-i386 -cpu 486 -cdrom bananaos.img -m 11.2M

He’s mainly building this to understand kernels, memory management, drivers, and how operating systems actually work below user space.

Feedback from people who have built hobby operating systems or worked close to hardware would be especially appreciated.

Hey HN, tracking limits across 20 Gemini/Opus accounts was getting tedious, but I refused to build a heavy Electron app just to run a countdown clock. I built Antigravity-Model-Reset-Timer using a 'Target Timestamp' approach: the Django backend calculates the absolute future UTC time and saves it to a local MongoDB. You can kill the app, and the JS engine just compares the DB time to the OS clock on next load. Zero zombie processes. It’s under 10 files. Looking for feedback on the PyWebView implementation and contributors to help add Anthropic/Google API webhooks.

Become a contributor to this open source project! https://github.com/PeterJFrancoIII/Antigravity-Model-Reset-T...

A few days ago I shared accept.md, a small utility that lets a Next.js page return Markdown when the client sends:

Accept: text/markdown

Instead of HTML.

No one asked for SvelteKit support, still I shipped it.

It now works with:

* Next.js (App Router and Pages Router) * SSG / SSR / ISR * SvelteKit routes * Vercel (no custom server required)

What it does:

If a client sends:

Accept: text/markdown

The exact same page returns clean Markdown.

If not, it behaves normally and renders HTML.

No duplicate routes. No separate .md files. No API layer. No SEO changes.

Just proper HTTP content negotiation.

Why I built this:

LLMs prefer Markdown. Internal tools prefer Markdown. Scrapers prefer Markdown. CLI workflows prefer Markdown.

But most sites only return HTML.

The usual solutions are:

* Maintain a parallel Markdown version * Build a custom export route * Create a docs API * Spin up a custom server

That felt unnecessary.

Browsers already send Accept: text/html. Agents can send Accept: text/markdown.

HTTP already solves this. Accept.md just makes it easy to use content negotiation inside modern frameworks without breaking static generation or edge deployments.

Design goals:

* Zero UI changes * Zero runtime cost for normal visitors * Works with static builds * Cache-friendly * Framework-native

It’s intentionally small. No heavy abstraction. Just a clean way to expose Markdown representations of existing pages.

Would love feedback — especially from people building AI-native apps, documentation systems, or content-heavy SaaS.

Curious whether Markdown negotiation becomes more common as agents become first-class web clients.

I want to preface this by saying I'm extremely new to webdev, and this is my first finished product. Any feedback is greatly appreciated!

Every digital math tool, at least for me, has been significantly worse than just pen and paper. LaTeX is far too slow, and most WYSIWYG editors are lacking features.

Scratchpad is my solution to this. You type shortcuts, and they render in real time inline using MathQuill. Stuff that I've added:

- Greek letters, lower and uppercase - Matrices (super clunky in every other editor I've tried!) - Accents like vector arrows and derivative dots - Tons of other useful symbols (set notation, gradients, plusminus, partial derivatives)

In my experience using it while in development, it's been substantially faster than pen and paper. There's a bit of a learning curve with the shortcuts, but I tried to make it as intuitive as possible.

The whole thing is on one index.html file, just open it and start writing. I would really appreciate any notes, especially from anyone who has experience with digital math notes. Thanks!

The open-timeline-engine is an open-source project that aims to provide a flexible and scalable timeline engine for building interactive timelines on the web. It offers features like nested events, customizable styling, and integration with various data sources.

Hello all! Build clean, minimalistic analog clock webpage to Cloudflare Pages.

This is for (maybe): - kids to learn - for second monitor - old tabled on shelf - ..

Themes and screen wake lock buttons with auto-hide. Goal is to keep it as clean as possible.

This possible makes no sense, but for a domain of $10/y this is cheap site for me to keep and see how it lives on.

Notemac++ is an open-source note-taking application that offers a range of features including rich formatting, code snippets, and the ability to create and manage checklists. The application is designed to provide a user-friendly and efficient platform for organizing and managing notes.

I built an MCP server that gives AI agents access to compliance documentation — starting with the Colorado AI Act (SB 24-205), effective June 30, 2026.

The problem: organizations deploying AI in hiring, lending, insurance, or healthcare decisions need specific documentation — risk management policies, impact assessments, consumer notifications, bias testing docs, and appeal mechanisms. Most teams either pay $50K+ for a GRC platform, hire a law firm at $500/hr, or wing it.

What I built: compliance protocols that are both human-readable (PDF) and agent-readable (structured JSON via MCP/CLI/API). Your AI assistant can check if you're a deployer, pull protocol schemas, and help you implement them.

Tools available via MCP: - colorado_ai_act_check — are you a deployer? - list_protocols — browse by vertical - get_protocol_schema — structured format for agent implementation - assess_compliance — gap analysis

Install: npx -y aop-mcp-server

The Colorado AI Act is the first state-level AI governance law with teeth ($20K/violation, AG enforcement). More states are coming.

Site: https://appliedoperationsprotocols.com

The article discusses reverse dependency tracking, a technique used to identify the impact of changes in a software project. It explains how reverse dependency tracking can help developers understand the dependencies between components and make informed decisions during software maintenance and refactoring.

I plan on bulding in docs later.

Hosted over Tor, or optionally share a single sheet temporarily with a free cloudflared tunnel.