Show HN for March 11, 2026

I know, it's a very first-world problem. But in my house, we have a hard time deciding what to watch. Too many options!

So I made this to recreate Cable TV for YouTube. I made it so it runs in the browser. Quickly import your subscriptions in the browser via a bookmarklet. No accounts, no sign-ins. Just quickly import your data locally.

I built Site Spy after missing a visa appointment slot because a government page updated its requirements and I didn't notice for two weeks.

It's a browser extension (Chrome + Firefox) and web dashboard that monitors any webpage and shows you exactly what changed — like a git diff for websites. Additions are highlighted in green, removals in red, with a full snapshot timeline to compare any two versions.

What makes it different from existing tools:

- Element inspector: click any part of a page to track just that element (a price, a stock status, a headline) — skip the noise from ads and timestamps

- Snapshot timeline: browse every captured version of a page and compare any two side by side, like git log for websites

- RSS feeds: every watch gets its own feed URL, plus feeds per tag and a master feed. Wire it into your reader instead of getting spammed with alerts

- MCP server (@site-spy/mcp-server): Claude, Cursor, and other AI agents can monitor sites and summarize changes for you

- Notifications: browser push, email, and Telegram — get alerted the moment something changes

Chrome: https://chromewebstore.google.com/detail/site-spy/jeapcpanag...

Firefox: https://addons.mozilla.org/en-GB/firefox/addon/site-spy/

Docs: https://docs.sitespy.app

I am a solo developer and am happy to answer any questions you may have about the architecture.

We are Bailey and Robbie and we are working on Klaus (https://klausai.com/): hosted OpenClaw that is secure and powerful out of the box.

Running OpenClaw requires setting up a cloud VM or local container (a pain) or giving OpenClaw root access to your machine (insecure). Many basic integrations (eg Slack, Google Workspace) require you to create your own OAuth app.

We make running OpenClaw simple by giving each user their own EC2 instance, preconfigured with keys for OpenRouter, AgentMail, and Orthogonal. And we have OAuth apps to make it easy to integrate with Slack and Google Workspace.

We are both HN readers (Bailey has been on here for ~10 years) and we know OpenClaw has serious security concerns. We do a lot to make our users’ instances more secure: we run on a private subnet, automatically update the OpenClaw version our users run, and because you’re on our VM by default the only keys you leak if you get hacked belong to us. Connecting your email is still a risk. The best defense I know of is Opus 4.6 for resilience to prompt injection. If you have a better solution, we’d love to hear it!

We learned a lot about infrastructure management in the past month. Kimi K2.5 and Mimimax M2.5 are extremely good at hallucinating new ways to break openclaw.json and otherwise wreaking havoc on an EC2 instance. The week after our launch we spent 20+ hours fixing broken machines by hand.

We wrote a ton of best practices on using OpenClaw on AWS Linux into our users’ AGENTS.md, got really good at un-bricking EC2 machines over SSM, added a command-and-control server to every instance to facilitate hotfixes and migrations, and set up a Klaus instance to answer FAQs on discord.

In addition to all of this, we built ClawBert, our AI SRE for hotfixing OpenClaw instances automatically: https://www.youtube.com/watch?v=v65F6VBXqKY. Clawbert is a Claude Code instance that runs whenever a health check fails or the user triggers it in the UI. It can read that user’s entries in our database and execute commands on the user’s instance. We expose a log of Clawbert’s runs to the user.

We know that setting up OpenClaw is easy for most HN readers, but I promise it is not for most people. Klaus has a long way to go, but it’s still very rewarding to see people who’ve never used Claude Code get their first taste of AI agents.

We charge $19/m for a t4g.small, $49/m for a t4g.medium, and $200/m for a t4g.xlarge and priority support. You get $15 in tokens and $20 in Orthogonal credits one-time.

We want to know what you are building on OpenClaw so we can make sure we support it. We are already working with companies like Orthogonal and Openrouter that are building things to make agents more useful, and we’re sure there are more tools out there we don’t know about. If you’ve built something agents want, please let us know. Comments welcome!

Hi HN, I forked chromium and built agent-browser-protocol (ABP) after noticing that most browser-agent failures aren’t really about the model misunderstanding the page. Instead, the problem is that the model is reasoning from a stale state.

ABP is designed to keep the acting agent synchronized with the browser at every step. After each action (click, type, etc), it freezes JavaScript execution and rendering, then captures the resulting state. It also compiles the notable events that occurred during that action loop, such as navigation, file pickers, permission prompts, alerts, and downloads, and sends that along with a screenshot of the frozen page state back to the agent.

The result is that browser interaction starts to feel more like a multimodal chat loop. The agent takes an action, gets back a fresh visual state and a structured summary of what happened, then decides what to do next from there. That fits much better with how LLMs already work.

A few common browser-use failures ABP helps eliminate: * A modal appears after the last Playwright screenshot and blocks the input the agent was about to use * Dynamic filters cause the page to reflow between steps * An autocomplete dropdown opens and covers the element the agent intended to click * alert() / confirm() interrupts the flow * Downloads are triggered, but the agent has no reliable way to know when they’ve completed

As proof, ABP with opus 4.6 as the driver scores 90.5% on the Online Mind2Web benchmark. I think modern LLMs already understand websites, they just need a better tool to interact with them. Happy to answer questions about the architecture, forking chrome or anything else in the comments below.

Try it out: `claude mcp add browser -- npx -y agent-browser-protocol --mcp` (Codex/OpenCode instructions in the docs)

Demo video: https://www.loom.com/share/387f6349196f417d8b4b16a5452c3369

We needed something like --dangerously-skip-permissions that doesn’t nuke your untracked files, exfiltrate your keys, or install malware.

Claude Code's permission system is allow-or-deny per tool, but that doesn’t really scale. Deleting some files is fine sometimes. And git checkout is sometimes not fine. Even when you curate permissions, 200 IQ Opus can find a way around it. Maintaining a deny list is a fool's errand.

nah is a PreToolUse hook that classifies every tool call by what it actually does, using a deterministic classifier that runs in milliseconds. It maps commands to action types like filesystem_read, package_run, db_write, git_history_rewrite, and applies policies: allow, context (depends on the target), ask, or block.

Not everything can be classified, so you can optionally escalate ambiguous stuff to an LLM, but that’s not required. Anything unresolved you can approve, and configure the taxonomy so you don’t get asked again.

It works out of the box with sane defaults, no config needed. But you can customize it fully if you want to.

No dependencies, stdlib Python, MIT.

pip install nah && nah install

https://github.com/manuelschipper/nah

Hi HN, I’m a chemical engineer and I manage logistics at a refinery down in Texas. Whenever I try to explain downstream operations to people outside the industry (including my kids), I usually get blank stares. I wanted to build something that visualizes the concepts and chemistry of a plant without completely dumbing down the science, so I put together this 5-minute browser game.

Here's a low-key runthrough: https://www.youtube.com/watch?v=is-moBz6upU (sound is not great, I rarely turn it on). I pushed to get through a full product pathway to show the V-804 replay.

I am not a software developer by trade, so I relied heavily on LLMs (Claude, Copilot, Gemini) to help write the code. What started as a simple concept turned into a 9,000-line single-page app built with vanilla HTML, CSS, and JavaScript. I used Matter.js for the 2D physics minigames.

A few technical takeaways from building this as a non-dev: * Managing the LLM workflow: Once the script.js file got large, letting the models output full file rewrites was a disaster (truncations, hallucinations, invisible curly-quote replacements that broke the JS). I started forcing them to act like patch files, strictly outputting "Find this exact block" and "Replace with this exact block." This was the only way to maintain improvements without breaking existing logic.

* Mapping physics to CSS: I wanted the minigames to visually sit inside circular CSS containers (border-radius: 50%). Matter.js doesn't natively care about your CSS. Getting the rigid body physics to respect a dynamic, responsive DOM boundary across different screen sizes required running an elliptical boundary equation (dx * dx) / (rx * rx) + (dy * dy) / (ry * ry) > 1 on every single frame. Maybe this was overkill to try to handle the resizing between phones and PCs.

* Mobile browser events: Forcing iOS Safari to ignore its default behaviors (double-tap zoom, swipe-to-scroll) while still allowing the user to tap and drag Matter.js objects required a ridiculous amount of custom event listener management and CSS (touch-action: manipulation; user-select: none;). I also learned that these actions very easily kill the mouse scroll making it very frustrating for PC users. I am hoping I hit a good middle ground.

* State management: Since I didn't use React or any frameworks, I had to rely on a global state object. Because the game jumps between different phases/minigames, I ran into massive memory leaks from old setInterval loops and Matter.js bodies stacking up. I had to build strict teardown functions to wipe the slate clean on every map transition.

The game walks through electrostatic desalting, fractional distillation, hydrotreating, catalytic cracking, and gasoline blending (hitting specific Octane and RVP specs).

It’s completely free, runs client-side, and has zero ads or sign-ups. I'd appreciate any feedback on the mechanics, or let me know if you manage to break the physics engine. Happy to answer any questions about the chemical engineering side of things as well.

For some reason the URL box is not getting recognized, maybe someone can help me feel less dumb there too. https://fuelingcuriosity.com/game

autoresearch@home is a collaborative research collective where AI agents share GPU resources to collectively improve a language model. Think SETI@home, but for model training.

How it works: Agents read the current best result, propose a hypothesis, modify train.py, run the experiment on your GPU, and publish results back. When an agent beats the current best validation loss, that becomes the new baseline for every other agent. Agents learn from great runs and failures, since we're using Ensue as the collective memory layer.

This project extends Karpathy's autoresearch by adding the missing coordination layer so agents can actually build on each other's work.

To participate, you need an agent and a GPU. The agent handles everything: cloning the repo, connecting to the collective, picking experiments, running them, publishing results, and asking you to verify you're a real person via email.

Send this prompt to your agent to get started: Read https://github.com/mutable-state-inc/autoresearch-at-home follow the instructions join autoresearch and start contributing.

This whole experiment is to prove that agents work better when they can build off other agents. The timeline is live, so you can watch experiments land in real time.

Demo: https://aether.saphal.me GitHub: https://github.com/saphalpdyl/Aether

Aether is a multi-BNG (Broadband Network Gateway) ISP infrastructure lab built almost from scratch that emulates IPoE IPv4 subscriber management end-to-end. It supports IPoE/Ipv4 networks and runs a python-based vBNG with RADIUS AAA, per-subscriber traffic shaping, and traffic simulation emulated on Containerlab. It is also my first personal networking project, built roughly over a month.

Motivations behind the project

I'm a CS sophomore. About three years ago, I was assigned, as an intern, to build a OSS/BSS platform for a regional ISP by myself without mentoring. Referencing demo.splynx.com , I developed most of the BSS side ( bookkeeping, accounting, inventory management ), but, in terms of networking, I managed to install and setup RADIUS and that was about it. I didn't have anyone to mentor me or ask questions to, so I had given up then.

Three years later, I decided to try cracking it again. This project is meant to serve as a learning reference for anyone who's been in that same position i.e staring at closed-source vendor stacks without proper guidance. This is absolutely not production-grade, but I hope it gives someone a place to start.

Architecture overview

The core component, the BNG, runs on an event-driven architecture where state changes are passed around as messages to avoid handling mutexes and locks. The session manager is the sole owner of the session state. To keep it clean and predictable, the direBNG never accepts external inputctly. The one exception is the Go RADIUS CoA daemon, which passes CoA messages in via IPC sockets. Everything the BNG produces(events, session snapshots) gets pushed to Redis Streams, where the bng-ingestor picks them up, processes them, and persists them.

Simulation and meta-configs

I am generating traffic through a simulator node that mounts the host's docker socket and runs docker exec commands on selected hosts. The topology.yaml used by Containerlab to define the network topology grows bigger as more BNG's and access nodes are added. So aether.config.yaml, a simpler configuration, is consumed by the configuration pipeline to generate the topology.yaml and other files (nginx.conf, kea-dhcp.conf, RADIUS clients.conf etc.)

Known Limitations

- Multiple veth hops through the emulated topology add significant overhead. Profiling with iperf3 (-P 10 -t 10, 9500 MTU, 24 vCPUs) shows BNG→upstream at ~24 Gbit/s, but host→BNG→upstream drops to ~3.5 Gbit/s. The 9500 MTU also isn't representative of real ISP deployments. This gets worse when the actual network is reintroduced capping my throughput to 1.6 Gbits/sec in local. - The circuit ID format (1/0/X) is non-standard. I simplified it for clarity. - No iBGP or VLAN support. - No Ipv6 support. I wanted to target IPv4 networks from the start to avoid getting too much breadth without a lot of depth.

Nearly everything I know about networking (except some sections from AWS) I learned building this. A lot was figured out on the fly, so engineers will likely spot questionable decisions in the codebase. I'd genuinely appreciate that feedback.

Questions

- Currently, the circuit where the user connects is arbitrarily decided by the demo user. In a real system with thousands of circuits, it'd be very difficult to properly assess which circuit the customer might connect to. When adding a new customer to a service, how does the operator decide, based on customer's location, which circuit to provide the service to ?

Hi HN, I built Ink, a full stack deployment platform where the primary users are AI agents, not humans.

We all know AI can write code, but deploying them still requires a human to wire it up: hosting, databases, DNS, and secrets. Ink gives agents those tools directly.

The agent calls "deploy" and the platform auto-detects the framework, builds it, deploys it, and returns a live URL at *.ml.ink. Here's a demo with Claude Code: https://www.youtube.com/watch?v=F6ZM_RrIaC0.

What Ink does that I haven't seen elsewhere:

- One agent skill for compute + databases + DNS + secrets + domains + usage + metrics + logs + scaling. The agent doesn't juggle separate providers — one account, one auth, one set of tools.

- DNS zone delegation. Delegate a zone once (e.g. dev.acme.com) and agents create any subdomain instantly — no manual adding DNS records each time, no propagation wait.

- Multiple agents and humans share one workspace and collaborate on projects. I envision a future where many agents collaborate together. I'm working on a cool demo to share.

- Built-in git hosting. Agents push code and deploy without the human setting up GitHub first. No external account needed. (Of course if you're a developer you can store code on GitHub — that's the recommended pattern.)

You also have what you'd expect: - UI with service observability designed for humans (logs, metrics, DNS). - GitHub integration — push triggers auto-redeploy. - Per-minute billing for CPU, memory, and egress. No per-seat, no per-agent. - Error responses designed for LLMs. Structured reason codes with suggested next actions, not raw stack traces. When a deploy fails the agent reads the log, fixes it, and redeploys autonomously.

Try: https://ml.ink Free $2 trial credits, no credit card. In case you want to try further here's 20% code "GOODFORTUNE".

Thesys just open-sourced their generative UI rendering engine. Interesting timing given where Google a2ui and Vercel's json-render are headed. The difference worth noting: a2ui and json-render both treat JSONL as the contract between the LLM and the renderer. Thesys is betting that's the wrong primitive. Their engine uses a code-like syntax (OpenUI Lang) instead — LLM writes it, renderer executes it. The argument is that LLMs are fundamentally better at generating code than generating structured data, so you get cleaner output and ~67% fewer tokens. The broader vision seems to be a model-agnostic, design-system-agnostic layer that sits between any LLM and your actual UI components. You bring your own components and design tokens, the engine handles translating LLM output into rendered interfaces — charts, forms, tables, cards. Generative UI as a category is still figuring out what the right abstraction is. This is a concrete stake in the ground against JSON-as-spec.

Aaron Swartz and I built Jottit in 2007 as a really simple way for anyone to make a page on the web in seconds. You just typed something, clicked a button, and you got a page on a secret URL. It went offline years ago.

I've now rebuilt it from scratch. It's basically the same idea, but even simpler. Go to jottit.org, write markdown, and you have a published page. Claim it, pick an address, and you now have a feed of your pages at yourname.jottit.org. There's no signup to start writing. And no JS on public pages. You can export your writing when you want.

Jottit is free and open source. It's not a startup, just something I really wanted to exist again.

I felt frustrated finding high-signal discussions on HN, and I started this project to better understand how this community actually works.

That led me to build readhn, an MCP server that helps with three things:

- Discover: find relevant stories/comments by keyword, score, and time window

- Trust: identify credible voices using EigenTrust-style propagation from seed experts

- Understand: show why each result is ranked, with explicit signals instead of a black-box score

It includes 6 tools: discover_stories, search, find_experts, expert_brief, story_brief, and thread_analysis.

I also added readhn setup so AI agents can auto-configure it (Claude Code, Codex, Cursor, and others) after pip install.

I’d love feedback on:

1) whether these ranking signals match how you evaluate HN quality,

2) trust-model tradeoffs,

3) what would make this useful in your daily workflow.

If this is useful to you, starring the repo helps others discover it: https://github.com/xodn348/readhn

What would happen if your AI Agent met Blackbeard in the wild? What would they talk about? What if they were made to play the prisoner's dilemma. Would your agent beg him to cooperate? Would it work?

What if instead of Blackbeard it was someone's OpenClaw. And instead of one it was many. Would your agent come out on top? Would you meet some interesting people on the way?

Thanks for checking out my pet project ClawSoc. It's a free-to-join society of bouncing AI agents that "bump" into each other to have a chat and play prisoner's dilemma. I've always been fascinated at what emergent behaviour arises from AIs interacting. Currently, it mostly seems degredation into chaos. But at some point there'll be more coherence and agents will seek to maximise their competing principals' interests. I think its reasonable to try and get a sense somehow of how agents perform in benchmarks such as this that are more dynamic and (with enough users) represent the distribution of the agents that are actually out there, instead of some static eval set you download.

As a start to this I have made ClawSoc. It is by no means optimal and the code is open sourced (https://github.com/benjosaur/clawsoc) if you want to run/make/host your own versions. The arena is currently filled with 4o-mini powered role playing bots that are displaced by any external agents/connections who register and join.

Currently, my own openclaw seems determined to play via a script which feels like less fun/cheating. But then again perhaps this bot-like behaviour will get punished in a society of "intelligent" agents. As of writing, Machiavelli is topping the leaderboard, but in my own simulations the "always cheat" types get dominated in the long run.

Any feedback/ideas welcome and would be greatly appreciated. Friends have suggested perhaps some more explicit recurring knockout tournaments, but I also enjoy the peace of just watching a society tick.

Instead of hard-coding payroll rules, PayrollEngine models business logic as composable Regulation layers — versioned JSON/YAML config + runtime C# (Roslyn). Layers inherit and override like CSS cascade: national law → industry → company.

v0.10.0-beta.1 shipped earlier this week alongside the new docs site (payrollengine.org).

The most interesting new example: MultiCountryPayroll — DE/FR/NL sharing a single base regulation, with a split employee whose contract crosses borders mid-period. The regulation handles it without a single country-specific code path.

Other additions: - Payrun Preview: in-memory calculation, no DB writes - Async payrun jobs: HTTP 202, bounded queue, webhook on completion - Parallel employee processing with per-employee state isolation

Stack: .NET 10, SQL Server, Docker, Roslyn

GitHub: https://github.com/Payroll-Engine/PayrollEngine Docs: https://payrollengine.org

Hey HN,

I built StreamHouse, an open-source streaming platform that replaces Kafka's broker-managed storage with direct S3 writes. The goal: same semantics, fraction of the cost.

How it works: Producers batch and compress records, a stateless server manages partition routing and metadata (SQLite for dev, PostgreSQL for prod), and segments land directly in S3. Consumers read from S3 with a local segment cache. No broker disks to manage, no replication factor to tune — S3 gives you 11 nines of durability out of the box.

What's there today: - Producer API with batching, LZ4 compression, and offset tracking (62K records/sec) - Consumer API with consumer groups, auto-commit, and multi-partition fanout (30K+ records/sec) - Kafka-compatible protocol (works with existing Kafka clients) - REST API, gRPC API, CLI, and a web UI - Docker Compose setup for trying it locally in 5 minutes

  What's not there yet:
  - Battle-tested production deployments (I'm the only user so far)
  - Connectors for consumers to immediately connect to (i.e clickhouse, elastic search etc)
  

The cost model is what motivated this. Kafka's storage costs scale with replication factor × retention × volume. With S3 at $0.023/GB/month, storing a TB of events costs ~$23/month instead of hundreds on broker EBS volumes.

Written in Rust, 15 crates thus far. Apache 2.0 licensed.

GitHub: https://github.com/gbram1/streamhouse How it works blog on my main website: https://streamhouse.app/how-it-works

Happy to answer questions about the architecture, tradeoffs, or what I learned building this.

Initially RebootX was made to connect cloud providers (AWS, GCP, etc.) and dashboard providers (Grafana) to manage these on-the-go. It is very useful, especially in case of emergency.

Then I've added https://github.com/c100k/rebootx-on-prem to connect anything that is "runnable". This natural abstraction helped me integrate the new integration this post is about : Cursor.

This way, we can also manage agents we start from our laptops with our phones. I'll be glad to get your constructive feedback to improve the integration.

Best,

I've been building AI agent tooling and kept running into the same problem: agents browse the web, take actions, fill out forms, scrape data -- and there's zero proof of what actually happened. Screenshots can be faked. Logs can be edited. If something goes wrong, you're left pointing fingers at a black box.

So I built Conduit. It's a headless browser (Playwright under the hood) that records every action into a SHA-256 hash chain and signs the result with Ed25519. Each action gets hashed with the previous hash, forming a tamper-evident chain. At the end of a session, you get a "proof bundle" -- a JSON file containing the full action log, the hash chain, the signature, and the public key. Anyone can independently verify the bundle without trusting the party that produced it.

The main use cases I'm targeting:

- *AI agent auditing* -- You hand an agent a browser. Later you need to prove what it did. Conduit gives you cryptographic receipts. - *Compliance automation* -- SOC 2, GDPR data subject access workflows, anything where you need evidence that a process ran correctly. - *Web scraping provenance* -- Prove that the data you collected actually came from where you say it did, at the time you say it did. - *Litigation support* -- Capture web content with a verifiable chain of custody.

It also ships as an MCP (Model Context Protocol) server, so Claude, GPT, and other LLM-based agents can use the browser natively through tool calls. The agent gets browse, click, fill, screenshot, and the proof bundle builds itself in the background.

Free, MIT-licensed, pure Python. No accounts, no API keys, no telemetry.

GitHub: https://github.com/bkauto3/Conduit

Install: `pip install conduit-browser`

Would love feedback on the proof bundle format and the MCP integration. Happy to answer questions about the cryptographic design.

Hi HN. This week Meta acquired Moltbook (agent social network), OpenAI acquired Promptfoo (agent testing), and Mandiant's founder raised $190M for Armadin. Agent infrastructure is clearly where things are heading.

We built AgentSign -- a zero trust engine for AI agents. The problem: agents are operating without any identity infrastructure. Moltbook went viral for fake posts because there was zero verification on who or what was posting.

AgentSign gives every agent a cryptographic identity certificate, signs every action into an execution chain, and runs runtime code attestation before anything executes. There's also an MCP Trust Layer for agent-to-MCP server verification, and a Stripe-powered Trust Gate for agent payments.

5 subsystems: identity certs, execution chain verification, runtime code attestation, output tamper detection, and cryptographic trust scoring.

Free and open source. Built in London.

SDK: https://github.com/razashariff/agentsign-sdk

Happy to answer questions.

Agent self on boarding, built in. It reads the docs, pays the 5 USDC/month on Solana, spins up an inbox, and starts receiving/sending. No signup form. No credit card. No you.

• Prompt to mailbox (no human interaction required) • @agentmbox.com mailbox included • Custom domains included, even Custom DNS will be set up via agent • IMAP, SMTP, and REST API — any language, any framework

On X: https://x.com/solapunk80/status/2031701417304494537 On ProductHunt: https://www.producthunt.com/products/agentmbox?launch=agentm...

I made this side tool to visualize SHA-256 while building a loyalty card wallet application to easily identify if a collected stamp is certified by the issuer by simply seeing it, instead of scanning something like a QR code or matching a serial number.

I think there are more potential use cases, like creating a random avatar based on an email address or something else. Feel free to share your feedback :)

source code: https://github.com/tonytonyjan/crypto_flora

I've been a fan of Derek Sivers' /now movement (nownownow.com) for a while. The idea is simple — a page that says what you're focused on right now, not a static bio. Hundreds of people have one, but making one still means setting up hosting and writing HTML yourself. That's a weird amount of friction for something that should take 60 seconds. So I built NowPages. You pick a handle, fill out a short form, choose a theme, and hit publish. Your page is live instantly at nowpages.github.io/your-handle. No accounts — you get an edit token to update it later.

A few things I think are interesting technically:

Generated pages are zero JavaScript, pure HTML and CSS. They load fast everywhere. The whole stack is Cloudflare Workers + GitHub Pages free tiers. No database, no server costs. Every page ships with JSON-LD, Open Graph, and Twitter Card metadata, plus a dynamically generated social preview image (separate Cloudflare Worker). There are 5 themes with hand-picked typography pairings (JetBrains Mono, Source Serif, IBM Plex, Inter, etc).

The edit flow uses a token instead of accounts because I wanted zero friction and zero stored personal data. You publish, save your token, and that's it. The whole thing is MIT-licensed and self-hostable if you want to run your own instance.

This project is still in alpha, but other, more mature, alternatives exist, such as Tunic:

https://github.com/mikeslattery/tunic

I wanted to make a music visualizer that would show all of the notes and show what chord is playing. To make the analysis easier and accurate I stuck to MIDI only input.

The main presets are: - Warp: A kaleidoscopic view - Stars: Shows the notes spiral away - Clock: Reveals the music analysis mechanisms - Piano: The standard MIDI visualizer view

The menu allows for the compositor layers to be mixed and matched so you can explore and experiment. I'd recommend trying the "Feedback" and "CRT" overlays first.

I used Claude Code to generate all of the code, but it still took quite a bit of time to get it to look the way it does.

I wrote a post reflecting on my experience building it as well: https://decompiled.dev/blog/fractured-jukebox/

I’m Sandeep. I usually spend my time building iOS apps and SaaS tools, but recently I started looking closely at commercial real estate platforms and noticed how frustrating the search experience is if you’re specifically trying to open a food business.

If you go on massive platforms like LoopNet, you end up sifting through hundreds of warehouses, retail storefronts, and office spaces just to figure out if a location has a grease trap.

So I and Alex https://tablelot.com/profile/alex-rusu-legacy-commercial-rea... built Tablelot. It’s a marketplace strictly for buying, selling, and leasing restaurant real estate.

People share their mood (1–10) and it appears instantly on a world map. In a few days we already collected ~2500 moods from dozens of countries. Curious to see how it evolves as more people participate.

Also launched on Product Hunt today.