Show stories

I wanted to listen to music with friends who live far away. Not "watch a YouTube video together" - actually share what I'm hearing in real-time, like we're in the same room.

Pulse is what came out of that. Anyone can host a live audio stream from their browser tab or system audio. Listeners join, music recognition identifies tracks automatically, and there's chat with 7TV emotes. No account required - you get an anonymous code and you're in.

We're running demo rooms that stream NTS Radio and SomaFM 24/7 (indie project, not affiliated - we backlink to the original stations). There's also a "Money For Nothing 24/7" room if you want to loop that Dire Straits instrumental forever.

Think of it as co-listening infrastructure. Bedroom DJs, listening parties, or just sharing your current vibe.

Netlist.io is a platform that connects businesses with verified digital talent, offering services such as web development, digital marketing, and software engineering. The site aims to streamline the hiring process and help companies find skilled freelancers to meet their digital needs.

Hi! Recently smart-glasses with cameras like the Meta Ray-bans seem to be getting more popular. As does some people's desire to remove/cover up the recording indicator LED. I wanted to see if there's a way to detect when people are recording with these types of glasses, so a little bit ago I started working this project. I've hit a little bit of a wall though so I'm very much open to ideas!

I've written a bunch more on the link (+photos are there), but essentially this uses 2 fingerprinting approaches: - retro-reflectivity of the camera sensor by looking at IR reflections. mixed results here. - wireless traffic (primarily BLE, also looking into BTC and wifi)

For the latter, I'm currently just using an ESP32, and I can consistently detect when the Meta Raybans are 1) pairing, 2) first powered on, 3) (less consistently) when they're taken out of the charging case. When they do detect something, it plays a little jingle next to your ear.

Ideally I want to be able to detect them when they're in use, and not just at boot. I've come across the nRF52840, which seems like it can follow directed BLE traffic beyond the initial broadcast, but from my understanding it would still need to catch the first CONNECT_REQ event regardless. On the bluetooth classic side of things, all the hardware looks really expensive! Any ideas are appreciated. Thanks!

PlayCode is an online code editor that allows users to create and run code directly in their web browser, supporting a variety of programming languages and providing tools for testing and debugging.

Browser Calendar is a web-based tool that allows users to manage their schedules and events directly in their web browsers. It offers features such as calendar views, task management, and integration with popular web services.

Hi all!

I built Spikelog because I kept wanting to track simple numbers over time but every time I looked at proper observability tools, I'd bounce off the setup complexity. I wanted to make something that didn't require a lot of thinking to use.

Spikelog is made to be as simple as possible:

- POST a JSON with chart name + value (you can add some tags as well but I've not tested this part works yet)

- Chart appears automatically

- 1,000 point rolling window per chart (old data expires, no retention config)

- Max 10 charts

That's basically the whole product.

I built it in about a day using Cursor. The API is intentionally minimal so AI assistants can use it too.

I have a prompt that lets your coding agent analyze a codebase and add tracking automatically (after you approve the plan).

I used it to make Spikelog track itself: https://spikelog.com/p/spikelog

There's no alerting yet (that's next), no complex aggregations, no dashboards beyond the auto-generated charts. If you need real observability use something fully featured like Axiom or Datadog. This is for people who just want to see if a number went up or down and don't want to build that themselves. i.e. they want something slightly better than just logging the number.

You can also share the charts publicly and I might add some password protection if there is demand for that.

I haven't battle-tested it under heavy load. The rolling window deletion is naive (deletes oldest points on insert). There are probably edge cases I haven't hit yet.

Would love feedback, especially if you try it and hit something broken.

Hi HN,

Over the past few months I've been building DB Pro with my co-founder. DB Pro is a modern desktop database GUI client designed to make working with Postgres, MySQL, SQLite, libSQL and other engines feel fast, visual, and enjoyable.

Our focus has been on the dev-experience. We wanted to absolutely nail the UX and look and feel as we believe most db clients aren't friendly to work with.

Some features:

Visual change review – See pending inserts/updates/deletes before committing them.

Inline data editing – Edit table rows directly without clunky modal dialogs.

Raw SQL editor – A focused editor for running queries with results in separate tabs.

Full activity logs – Track everything happening in your database for peace of mind.

Visual schema explorer – See tables, columns, keys, and relationships in a diagram.

Tabs & multi-window support – Keep multiple connections and queries open at once.

Custom table tagging – Organise your tables without altering the schema.

Tech stack: Electron, React, tRPC, Drizzle ORM, Postgres/MySQL/libSQL/SQLite support, and native builds for macOS at the moment with Windows, and Linux coming very soon.

We're super passionate about this project and we're actually documenting our journey through devlogs. The latest one is here: https://www.youtube.com/watch?v=-T4GcJuV1rM

Thanks, Jay and Jack

The article provides an overview of the TaskHub.Shared project, which is a shared library for the TaskHub server-side application. The library includes core functionality, models, and services that are used across the TaskHub server-side components.

This is a little side project I've been working on for the last few months. It's a service hosting Lua scripts behind static HTTP endpoints in a fully sandboxed environment. It's something I've built to scratch my own itch and now I'm launching a free public beta to see if it's something that anyone else also finds useful.

<backstory>

My first professional job was for a company building an industrial IoT platform who's most unique feature was their Lua-based scripting platform. I ended up loving Lua so much that at my next job, at SmartThings, I ended up being the main instigator who made the Lua-based Edge Drivers happen when we were forced to sunset the old Groovy-based DTHs, writing the initial PoC, laying out the architecture, and writing the core of the system.

This is basically my take on an old service that folded in 2017 called webscript.io, another tool that got me loving Lua. I used that service a whole bunch both for personal projects and little tools at work. I was really sad when it went down and I genuinely don't think a single week had gone by where I hadn't wished that it still existed. So, I finally decided that I needed to build my own version of it.

</backstory>

The whole idea behind Bodge is that it should be as simple as possible to hack something together. I've always had a bunch of small side projects that I want to do that aren't worth the overhead required to actually put them together & keep them maintained. So, I built Bodge as a way to make each individual project less work whenever inspiration strikes. So far I've built:

* A current-time API for some hacked-together IoT devices: https://time.bodge.link/

* A script for my wife that checks her commute time and emails her before it's about to get bad.

* An email notification to myself if my Matrix server goes down.

* A 'randomly choose a thing' page. https://rand.bodge.link/choose?head&tails

* A "work" phone number voicemail, where the script converts the webhook into an alert to myself.

* An email notification any time a new version is released for a few semi-public self-hosted services.

* Scrapers for a few companies' job listings that notify me whenever a new job is posted matching some filters.

* A WebPush server that I eventually want to use for custom notifications to myself.

* And just for fun, an SVG hit counter: https://hits.bodge.link/

Scripts can be as simple as:

  return "Hello, world!"

Currently I provide Lua modules for: making HTTP requests, handling json, sending alerts to yourself, simple string/string key/value storage, cross-script mutexes, and a few other basic things.

Accounts are free, but you don't even need to make one to just play around with writing scripts. There's a demo on the homepage that lets you run real scripts for yourself, though with a few extra limitations.

I'd love to hear what anyone thinks!

Hi HN,

I'm Rafael Mauricio, the founder of RF Modern Bakery Design. For the last decade, I've worked with hundreds of talented bakers. The same frustrating pattern kept emerging: they had the culinary skills to build a successful business, but were completely blocked by the monumental task of designing their commercial kitchen.

A brilliant baker shouldn't have to also become a construction manager, HVAC expert, and workflow engineer. The traditional process is a black hole of time and money—taking 3-6 months and $10,000+ in consulting fees just to get a viable floor plan. Most independent operators can't afford this.

We built RF Modern Bakery Design to bridge that gap.

The Product:

It's a dual-sided service.

Custom Bakery Design: The time-tested, professional service for creating full, build-ready bakery concepts.

Online Bakery Design Courses: This is the core of our "Show HN." We've productized our decade of expertise into video courses that teach the principles of efficient layout, equipment selection, and workflow optimization. It's like having a senior designer guide you through the entire process, empowering you to design your own space or intelligently manage a contractor.

The Tech Stack:

We keep it simple and focused on delivery: a static site that lets us pour 100% of our energy into creating high-quality, actionable lessons and resources.

We're launching this to solve the "barrier to entry" problem in the food service industry. It's for aspiring bakery owners, culinary graduates, and even existing owners planning a renovation who need a clear, professional path to a functional and profitable layout without the prohibitive upfront cost.

We'd love for you to check it out and are eager for any feedback:

Landing Page: https://rfmodernbakerydesign.com

Happy to answer any questions about the business model, the design principles we teach, the build process, or the bakery industry in general

I got DOOM running in KiCad by rendering it with PCB traces and footprints instead of pixels.

Walls are rendered as PCB_TRACK traces, and entities (enemies, items, player) are actual component footprints - SOT-23 for small items, SOIC-8 for decorations, QFP-64 for enemies and the player.

How I did it:

Started by patching DOOM's source code to extract vector data directly from the engine. Instead of trying to render 64,000 pixels (which would be impossibly slow), I grab the geometry DOOM already calculates internally - the drawsegs[] array for walls and vissprites[] for entities.

Added a field to the vissprite_t structure to capture entity types (MT_SHOTGUY, MT_PLAYER, etc.) during R_ProjectSprite(). This lets me map 150+ entity types to appropriate footprint categories.

The DOOM engine sends this vector data over a Unix socket to a Python plugin running in KiCad. The plugin pre-allocates pools of traces and footprints at startup, then just updates their positions each frame instead of creating/destroying objects. Calls pcbnew.Refresh() to update the display.

Runs at 10-25 FPS depending on hardware. The bottleneck is KiCad's refresh, not DOOM or the data transfer.

Also renders to an SDL window (for actual gameplay) and a Python wireframe window (for debugging), so you get three views running simultaneously.

Follow-up: ScopeDoom

After getting the wireframe renderer working, I wanted to push it somewhere more physical. Oscilloscopes in X-Y mode are vector displays - feed X coordinates to one channel, Y to the other. I didn't have a function generator, so I used my MacBook's headphone jack instead.

The sound card is just a dual-channel DAC at 44.1kHz. Wired 3.5mm jack → 1kΩ resistors → scope CH1 (X) and CH2 (Y). Reused the same vector extraction from KiDoom, but the Python script converts coordinates to ±1V range and streams them as audio samples.

Each wall becomes a wireframe box, the scope traces along each line. With ~7,000 points per frame at 44.1kHz, refresh rate is about 6 Hz - slow enough to be a slideshow, but level geometry is clearly recognizable. A 96kHz audio interface or analog scope would improve it significantly (digital scopes do sample-and-hold instead of continuous beam tracing).

Links:

KiDoom GitHub: https://github.com/MichaelAyles/KiDoom, writeup: https://www.mikeayles.com/#kidoom

ScopeDoom GitHub: https://github.com/MichaelAyles/ScopeDoom, writeup: https://www.mikeayles.com/#scopedoom

I work on embedded firmware for my day job, and I've found LLMs to be useful for answering questions about technical errata. But, they tend to be bad at answering highly specific questions without using some kind of search tool (if they decide to use one at all), and some user manuals are far too large to fit into a context window.

I built askdocs-mcp as a way to give agents a more direct route to searching through a project's source-of-truth documents. My design constraints were that it run 100% locally, as some manuals are under NDA. It should start up fast, and let me experiment with different embedding & language models. It was built with ollama in mind, but if you can't run models locally, it will work with any OpenAI compatible endpoint.

Features:

  - Incrementally builds and caches the set of docs. Initial start up can take a while as PDFs are chunked and ran through an embedding model, but after that, startup is near instant.

  - Uses the filesystem as the database - you only need `ollama` running somewhere so the tool can access an embedding and natural language model.

  - Provides a tool `ask_docs` for getting natural-language answers back about what the documentation says, which are annotated with page numbers the information came from. Those can be used with tool `get_doc_page` to retrieve the full page if the agent needs additional context.

I'm sure there are improvements that can be made e.g. document chunking or the "system prompt" the tool gives to the language model - I'd love to hear your feedback, especially if you find this useful. Thanks!

Hey HN! I just launched Dialed – a calendar app where your day is visualized as a clock instead of a grid. I've always found traditional calendar UIs frustrating. Lists feel like todo apps. Grids feel like spreadsheets. But we experience time circularly, like a clock face.

A few months ago I saw a radial planning concept and couldn't stop thinking about it. Started building that week.

Key features:

Day visualized as 24-hour clock Tasks/events as colored arcs Apple Calendar sync Time analytics (planned vs actual) Custom themes

Built in Swift/SwiftUI. The radial layout was harder than expected – lots of edge cases around midnight wrapping and overlapping events.

This is my first iOS launch. Would love feedback on whether the radial metaphor works for you guys!

Fed up of 'restrictive' AI training plan creators, history analysers and lifestyle loggers. Try this - bit nerdy, lots of rough edges!

I built a single-file Python script that lets you run LLM prompts from the command line with templating, structured outputs, and the ability to chain prompts together.

When I discovered Google's Dotprompt format (frontmatter + Handlebars templates), I realized it was perfect for something I'd been wanting: treating prompts as first-class programs you can pipe together Unix-style. Google uses Dotprompt in Firebase Genkit and I wanted something simpler - just run a .prompt file directly on the command line.

Here's what it looks like:

--- model: anthropic/claude-sonnet-4-20250514 output: format: json schema: sentiment: string, positive/negative/neutral confidence: number, 0-1 score --- Analyze the sentiment of: {{STDIN}}

Running it:

cat reviews.txt | ./runprompt sentiment.prompt | jq '.sentiment'

The things I think are interesting:

* Structured output schemas: Define JSON schemas in the frontmatter using a simple `field: type, description` syntax. The LLM reliably returns valid JSON you can pipe to other tools.

* Prompt chaining: Pipe JSON output from one prompt as template variables into the next. This makes it easy to build multi-step agentic workflows as simple shell pipelines.

* Zero dependencies: It's a single Python file that uses only stdlib. Just curl it down and run it.

* Provider agnostic: Works with Anthropic, OpenAI, Google AI, and OpenRouter (which gives you access to dozens of models through one API key).

You can use it to automate things like extracting structured data from unstructured text, generating reports from logs, and building small agentic workflows without spinning up a whole framework.

Would love your feedback, and PRs are most welcome!

As a teacher, we keep our slides as markdown files in git repos and want to build these automatically so they can be viewed online (or offline if needed). To achieve this, I have created MkSlides. This tool converts all markdown in a folder to slides generated with Reveal.js. The workflow is very similar to MkDocs.

Install: `pip install mkslides`

Building slides: `mkslides build`

Live preview during editing: `mkslides serve`

Comparison with other tools like marp, slidev, ...:

- This tool is a single command and easy to integrate in CI/CD pipelines.

- It only needs Python.

- The workflow is also very similar to MkDocs, which makes it easy to combine the two in a single GitHub/GitLab repo.

- Generates an index landing page for multiple slideshows in a folder which is really convenient if you have e.g. a slideshow per chapter.

- It is lightweight.

- Everything is IaC.

This article presents a welcome note generator that allows users to create customized welcome notes for new team members. The generator uses a template system to generate the notes, which can be personalized with the new member's name and other relevant information.

SyncKit is an open-source software development kit (SDK) that simplifies the process of building real-time, collaborative applications. It provides a set of tools and APIs for developers to easily integrate synchronization and collaboration features into their web and mobile applications.

Just watched this video by ThePrimeagen (https://www.youtube.com/watch?v=efwDZw7l2Nk) about attackers jailbreaking Claude to run cyber attacks. The core issue: AI agents need isolation.

We built ERA to fix this – local microVM-based sandboxing for AI-generated code with hardware-level security. Think containers, but safer. Such attacks wouldn't touch your host if running in ERA.

GitHub: https://github.com/BinSquare/ERA

Quick start: https://github.com/BinSquare/ERA/tree/main/era-agent/tutoria...

Would love your thoughts and feedback!

Hey HN! Just for fun, I built an interactive Hacker News Simulator.

You can submit text posts and links, just like the real HN. But on HN Simulator, all of the comments are generated by LLMs + generate instantly.

The best way to use it (IMHO) is to submit a text post or a curl-able URL here: https://news.ysimulator.run/submit. You don't need an account to post.

When you do that, various prompts will be built from a library of commenter archetypes, moods, and shapes. The AI commenters will actually respond to your text post and/or submitted link.

I really wanted it to feel real, and I think the project mostly delivers on that. When I was developing it, I kept getting confused between which tab was the "real" HN and which was the simulator, and accidentally submitted some junk to HN. (Sorry dang and team – I did clean up after myself).

The app itself is built with Node + Express + Postgres, and all of the inference runs on Replicate.

Speaking of Replicate, they generously loaded me up with some free credits for the inference – so shoutout to the team there.

The most technically interesting part of the app is how the comments work. You can read more about it here, as well as explore all of the available archetypes, moods, and shapes that get combined into prompts: https://news.ysimulator.run/comments.html

I hope you all have as much fun playing with it as I did making it!

I built this because finding old Claude Code / Codex sessions to resume was tedious.

It indexes ~/.claude/projects/ and ~/.codex/sessions/, ranks by relevance + recency.

Press Enter to resume the selected conversation.

Supports searching everywhere or scoped to current folder.

Written in Rust with Tantivy (~2.5k LOC).

Hope this is useful for someone!

Hi HN - My name is Andrew, and I'm a high school student.

This is a write-up on StratoSpore, a payload I designed and launched to the stratosphere. The goal was to test if we could estimate physical altitude based on algae fluorescence (using a lightweight ML model trained on the sensor data).

The blog post covers the full engineering mess/process, including:

- The Hardware: Designing PCBs for the AS7263 spectral sensor and Pi Zero 2 W.

-The biological altimeter: How I tried to correlate biological stress (fluorescence) with altitude.

- The Communications: A custom lossy compression algorithm I wrote to smash 1080p images down to 18x10 pixels so I could transmit them over LoRA (915 Mhz) in semi-real-time.

The payload is currently lost in a forest, but the telemetry data survived. The code and hardware designs are open source on GitHub: https://github.com/radeeyate/stratospore

I'm happy to answer technical questions about the payload, software, or anything else you are curious about! Critique also appreciated!

The article discusses the technical features and capabilities of the NEAR protocol, a scalable and user-friendly blockchain platform designed to enable the development of decentralized applications (dApps) with a focus on usability and accessibility.

A fast, cross-platform CLI tool that extracts dominant colors from images using k-means clustering.

This past quarter has been awash with sophisticated npm supply chain attacks like [Shai-Hulud](https://www.cisa.gov/news-events/alerts/2025/09/23/widesprea...() and the [Chalk/debug Compromise](https://www.wiz.io/blog/widespread-npm-supply-chain-attack-b...). This CLI helps protect users from recently compromised packages by only downloading packages that have been public for a while (default is 90 days or older).

Install: npm install -g @dendronhq/safe-npm Usage: safe-npm install react@^18 lodash

How it works: - Queries npm registry for all versions matching your semver range - Filters out anything published in the last 90 days - Installs the newest "aged" version

Limitations: - Won't protect against packages malicious from day one - Doesn't control transitive dependencies (yet - looking into overrides) - Delays access to legitimate new features

This is meant as a 80/20 measure against recently compromised NPM packages and is not a silver bullet. Please give it a try and let me know if you have feedback.

The 360CSS project provides a comprehensive CSS framework for creating immersive 360-degree experiences on the web, with features like panoramic views, virtual tours, and interactive environments.

high-reciprocity copyleft license.

Hi HN! For the past bit we’ve been building Flowglad (https://flowglad.com) and can now feel it’s just gotten good enough to share with you all:

Repo: https://github.com/flowglad/flowglad

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

Flowglad is a payment processor that you integrate without writing any glue code. Along with processing your payments, it tells you in real time the features and usage credit balances that your customers have available to you based on their billing state. The DX feels like React, because we wanted to bring the reactive programming paradigm to payments.

We make it easy to spin up full-fledged pricing models (including usage meters, feature gates and usage credit grants) in a few clicks. We schematize these pricing models into a pricing.yaml file that’s kinda like Terraform but for your pricing.

The result is a payments layer that AI coding agents have a substantially easier time one-shotting (for now the happiest path is a fullstack Typescript + React app).

Why we built this:

- After a decade of building on Stripe, we found it powerful but underopinionated. It left us doing a lot of rote work to set up fairly standard use cases - That meant more code to maintain, much of which is brittle because it crosses so many server-client boundaries - Not to mention choreographing the lifecycle of our business domain with the Stripe checkout flow and webhook event types, of which there are 250+ - Payments online has gotten complex - not just new pricing models for AI products, but also cross border sales tax, etc. You either need to handle significant chunks of it yourself, or sign up for and compose multiple services

This all feels unduly clunky, esp when compared to how easy other layers like hosting and databases have gotten in recent years.

These patterns haven’t changed much in a decade. And while coding agents can nail every other rote part of an app (auth, db, analytics), payments is the scariest to tab-tab-tab your way through. Because the the existing integration patterns are difficult to reason about, difficult to verify correctness, and absolutely mission critical.

Our beta version lets you:

- Spin up common pricing models in just a few clicks, and customize them as needed - Clone pricing models between testmode and live mode, and import / export via pricing.yaml - Check customer usage credits and feature access in real time on your backend and React frontend - Integrate without any DB schema changes - you reference your customers via your ids, and reference prices, products, features and usage meters via slugs that you define

We’re still early in our journey so would love your feedback and opinions. Billing has a lot of use cases, so if you see anything that you wish we supported, please let us know!

Hi everyone,

I've made an early version of ZigFormer, a small LLM implemented in Zig with no dependencies on external ML frameworks like PyTorch or JAX. ZigFormer is modelled after a textbook LLM (like GPT-2 from OpenAI) and can be used as a Zig library as well as a standalone application to train a model and chat with it.

This was mainly an educational project. I'm sharing it here in case others find it interesting or useful.

Link to the project: https://github.com/CogitatorTech/zigformer