Show stories

I built a tool that reveals the data your browser exposes automatically every time you visit a website.

GitHub: https://github.com/neberej/exposedbydefault

Demo: https://neberej.github.io/exposedbydefault/

Note: No data is sent anywhere. Everything runs in your browser.

Auth-Agent is an open-source authentication agent that provides a secure and centralized way to manage authentication and authorization for web applications. It supports various authentication methods, including username/password, social logins, and passwordless options, and can be integrated with other services through its flexible API.

Hi HN

I’ve been working on a tool I personally needed as someone who edits a lot of video content.

The problem is simple:

Modern video editing requires 8+ different tools, all slow, all noisy, all repetitive.

Subtitles here. Audio cleanup there. Silence removal elsewhere. Upscaling in another tool. AI voice in a different one. A clip extractor somewhere else…

So I built Magiclip.io — a single interface that automates the most boring parts of editing.

What it does today

Auto-subtitles (fast & accurate)

Silence removal

AI voice-over

Audio enhancement

Image upscaling

Clip extraction from long videos

Thumbnail generation

Quick TikTok/Reels format conversion

And more coming

The idea isn’t to replace full editors. It’s to remove the friction of things we repeat 100 times.

Upload → Magic → Download. No timeline, no project files, no complexity.

Why I built it

I edit content frequently, and the workflow felt unnecessarily painful. Magiclip is my attempt to reduce editing from hours to seconds by batching the most common tasks behind simple endpoints.

What I’d love feedback on

What other tasks should be automated?

Anything in the UX that feels off or slow?

Any feature you’d want exposed through an API?

Live link

https://magiclip.io

Happy to answer anything about the architecture, the pipelines, or the reasoning behind the features.

It was quite interesting to vibe code this artifact. I learned some basic ideas about commitment scheme and hash cryptography in the half and hour spent on this. One of the few times vibe coding left me feeling enriched rather than drained. What do you think?

I built MacGlow - A MacOS app to sync brightness across your Mac and all connected Monitors.

Supports every Macbook Air, Pro, iMac and Mac Mini models ever released running MacOS 12.4 and above.

Demo: https://youtu.be/_lOyThemhPA Website: https://lovi.sh/macglow

Hello good folks!

So... TL;DR: I find presentations boring. I find Choose your own adventure style books not boring. I married the two. Now, you can have presentations where the people you present two have the ability to choose how your presentation proceeds! And you can construct your presentation using plain markdown, start a server, your audience opens the `/voter` link you open the `/presenter` link and start your presentation. Whenever there is a question, they will choose and the presentation proceeds according to the choice.

Longer version:

In the years I partook on presentations I always liked the ones that are more interactive. Not in a I ask questions and then wait uncomfortably for people to shout out something, no. In a way where I, as a viewer, got something to do! Makes me more interested in the presentation as well, and I'll be learning and remembering things more as well.

I also like choose your own adventure type of books. So I wondered, how could I make these two come together? So I wrote this little tool called adventure-voter. Not a very good name, but meh... The point is that you'll have a backend and a frontend to deal with votes and deal with following forks in your presentation. Going back from a fork if the fork ended up in death or a failed route. ( you procastinated, your backend didn't start, you server didn't come up, etc whatever makes sense as an end in your presentation ). And then you can explore a different route. Imagine, you are presenting something about Kubernetes. And one of the questions is, okay you are now bringing up etcd. How do you configure it? Do you... and the vote begins.

This makes the presentation a little bit more enjoyable I think. Also, the framework is super easy. You have your presentation in Markdown and the frontend is a lightweight parser with tailwind that does things and makes it look relatively nice. ( I'm not a frontend dev, sorry ). And you can link together steps and stories with `next: slide-1b` or whatever.

Granted, you'd have to work a bit more to get a presentation that makes sense, but honestly, I think it will make for a very interesting talk. Something I'm aiming to do on the next KubeCon in Atlanta. I'm going to be using this framework to present something. ( If I get in. :)) )

Lastely, I want the presentation to be enjoyable and not boring. :) And that's my main goal. On KubeCon you sit through presentation after presentation after presentation and hopefully this one will be ( if I get accepted ) something that you enjoy and don't fall asleep on. :)

I hope this is useful. Enjoy folks. :)

Mu is a lightweight, open-source microservices framework that provides a simple, yet powerful, approach to building and managing distributed systems. The framework offers features such as service discovery, load balancing, and distributed tracing, helping developers create and deploy microservices efficiently.

A chess variant where the top and bottom ranks are adjacent. An additional row of pawns protects your King in the other side of the play area.

This game is built using Compose Multiplatform and it runs on Android, iOS, Web, Desktop (JVM).

Source code is at https://github.com/deanalvero/horizontal-cylinder-chess.

i always loved looking up the On-Line Encyclopedia of Integer Sequences (OEIS) when researching a sequence of numbers.

so I decided to make a TUI and CLI for it so that I can browse sequences in the terminal.

it supports almost all the features on the site (including the OEIS Webcam) and supports graphs, a preview pane, exporting and bookmarks.

more features here: https://github.com/hako/oeis-tui?tab=readme-ov-file#features

repo: https://github.com/hako/oeis-tui

gitHub releases: https://github.com/hako/oeis-tui/releases

cargo: cargo install oeis-tui

A production-ready, Docker-powered RAG system that understands the difference between code and prose. Ingest your codebase and documentation, then query them with full privacy and zero configuration.

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!

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.

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.

Hey HN,

  I've been lifting for years and got frustrated with fitness apps that either (a) generate a static plan and forget about you, or (b) require manual logging with no intelligence.
 
  So I built Arvo—an AI personal trainer that adapts after every single set, not just at the start of your workout.
 
  Why 19 agents instead of one? Each handles a specific job:
  - Exercise Architect (selects movements based on equipment/goals)
  - Load Navigator (calculates weight adjustments based on RIR)
  - Volume Manager (tracks MEV/MAV/MRV per muscle group)
  - Pattern Scout (extracts insights from natural language notes)
  - Movement Adapter (biomechanical weight conversion when swapping exercises)
 
  They coordinate to make decisions in <500ms.
 
  Example: You finish set 1 of bench press, felt easy (RIR 4). Arvo bumps weight +2.5kg for set 2. Set 2 was a grind (RIR 1). Arvo keeps the weight but suggests longer rest.

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've been building TimeTracker over the past few years, and it's grown into a comprehensive self-hosted platform for time tracking, project management, and invoicing.*What it does:*- Time tracking with persistent server-side timers- Professional PDF invoice generation- Project & task management- Client CRM- Expense tracking- Advanced reporting & analytics- Role-based permissions- REST API*Why self-hosted:*I was tired of paying $15-20/month for time tracking tools and having my data locked in SaaS platforms. This gives complete control.*Tech:*- Python/Flask backend- PostgreSQL + Redis- Docker deployment- 120+ features documented*Deployment:*One docker-compose command. Works on any server, including Raspberry Pi.Would love feedback from the HN community! What features would be most valuable for you?

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

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!

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.

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!

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!

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.

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!

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.

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!

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!

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.

Convert documents to meaningful things.

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.