Show stories

Mercury is a lightweight, open-source, and cross-platform web scraping library for JavaScript. It provides a simple and intuitive API for extracting data from web pages, handling common challenges like pagination, authentication, and rate limiting.

The article describes the Spritefusion Pixel Snapper, a tool that allows users to create and export pixel art from a variety of image sources. The tool offers a range of features, including image cropping, pixel scaling, and color palette customization, aimed at simplifying the pixel art creation process.

AIEnhancer is an AI image enhancement tool offering free online features like photo repair, background removal, and watermark removal to improve image quality.

Zint is an open-source barcode generator library that supports a wide range of barcode symbologies, including 1D and 2D barcodes. It is designed to be used as a library in other applications and provides a simple API for generating barcodes.

I built a system that monitors ~200,000 news RSS feeds in near real-time and clusters related articles to show how stories spread across the web.

It uses Snowflake’s Arctic model for embeddings and HNSW for fast similarity search. Each “story cluster” shows who published first, how fast it propagated, and how the narrative evolved as more outlets picked it up.

Would love feedback on the architecture, scaling approach, and any ways to make the clusters more accurate or useful.

Live demo: https://yandori.io/news-flow/

Hi HN,

I just launched Tinyfocus, a small productivity tool designed specifically for solo founders and builders. The goal is simple: help you focus on what matters and get more done in less time.

Here’s what Tinyfocus does:

Lets you track your top tasks and prioritize efficiently.

Provides micro dashboards to keep your daily focus in check.

Lightweight, no distractions, no fluff.

I built it entirely by myself, iterating in public, and I wanted to share it with the community to get feedback.

It’s been crazy seeing how a simple tool can make such a difference in daily focus, especially when you’re juggling multiple projects as a solo founder.

Check it out here: tinyfoc.us

I’d love to hear your thoughts – any feedback, feature ideas, or bugs you notice.

Thanks!

The new Gemini 3 Pro Image model (aka Nano Banana) is incredible at generating slides, so I thought it would be fun to build a CLI tool that lets you edit PDF presentations using plain English. The tool converts the page you want to edit into an image, sends it to the model API together with your prompt to generate an edited image, then converts the updated image back and stitches into the original document.

Examples:

- `nano-pdf edit deck.pdf 5 "Update the revenue chart to show Q3 at $2.5M"`

- `nano-pdf add deck.pdf 15 "Create an executive summary slide with 5 bullet points"`

Features:

- Edit multiple pages in parallel

- Add entirely new slides that match your deck's style

- Google Search enabled by default so the model can look up current data

- Preserves text layer for copy/paste and search

It can work with any kind of PDF but I expect it would be most useful for a quick edit to a deck or something similar.

GitHub: https://github.com/gavrielc/Nano-PDF

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.

hey HN,

I’ve been building this project through a lot of late nights and messy iterations, and it’s finally stable enough to share.

utm.one is a clean, distraction-free URL shortener with built-in UTM discipline. it auto-prevents duplicates, applies consistent naming, and keeps your tracking clean using the Clean-Track framework .

I’m launching a controlled beta, so things are intentionally simple and safe for testing.

would love feedback on:

1. does the flow feel intuitive? 2. anything confusing or missing? 3. would you trust it for real campaigns?

Website - https://utm.one

next up: a partner + affiliate program built into the same tracking architecture.

thanks for taking a look any feedback (good or brutal) really helps.

Built this because AI coding shouldn't cost hundreds per month. It's Cline with free Open Source and Deca models plus cost tracking for when you need GPT-5/Claude. The free tier handles 70% of daily coding.

Try it: https://github.com/GenLabsAI/Agentica/releases/tag/v0.0.1

You can use a demo email and password for testing: (demo: agentica@genlabs.dev / agentica@123)

Looking for feedback on where the free models fall short. Building sustainable AI tools for developers.

Hi HN,

I built Aion, an “AI longevity coach” that integrates three data sources that are usually siloed:

Wearable data (e.g., Whoop, Oura, Apple Health: sleep, HRV, strain)

Blood tests (hormones and basic longevity markers)

Simple phone-based facial scans

The aim is to provide a clearer picture of energy, hormones, sleep and recovery over time and to translate this into straightforward daily recommendations (sleep timing, caffeine window, training intensity, light exposure), rather than just another metrics dashboard.

Link: https://www.aionlongevity.com/ Demo video: https://www.youtube.com/watch?v=BR9AScuVGjA&feature=youtu.be

A 7-day free trial is available.

I would appreciate feedback on:

Whether this addresses a real need or feels redundant with existing tools

What you would require (export options, transparency, controls) to consider using a product like this

Thank you, Neven

Hello HN!

I'm a European traveler, and during my last 6 months of travel I created an app to keep track of my expenses. I made it open-source and started to build a website and a documentation for other people to use it!

It's a fairly simple PWA that you can install on mobile that can help you set a budget, keep track of expenses and analyse what you spend.

Thanks for any feedback and keep traveling guys!

The article discusses the Sovereign Stack, a decentralized web3 stack that aims to empower individuals and communities with self-sovereign control over their digital identities, data, and assets. It highlights the key components of the stack, including decentralized identity, data management, and blockchain-based asset ownership.

A real-time network connection monitoring tool built with Rust and GTK4, displaying active connections with live I/O statistics in a modern graphical interface. https://github.com/grigio/network-monitor

PasswordCat is a password manager that uses advanced encryption to securely store and manage user passwords. The app offers features such as automatic password generation, password sharing, and multi-device synchronization to help users improve their online security.

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!

I built a browser-only tool that disrupts invisible AI watermarks using Canvas, geometry, noise, and JPEG recompression. No backend, no uploads, no tracking.

Pipeline: Shake – Random rotation (±0.5°) + slight zoom Stir – Low-amplitude RGB noise via getImageData Crush – JPEG recompression at ~0.85 quality

Tested with SynthID (Google Gemini AI watermarking), and it remained undetected in all tests.

Pipeline improvements? What would you add/change?

Github: https://github.com/ing-norante/unmarker.it

I’ve started working on Schema Pilot, an open-source idea for a visual database designer that generates Prisma schema + SQL automatically from a drag-and-drop interface.

Right now it’s very early — mostly the landing page + initial planning for the core engine. But the vision is:

visually create tables & relations

auto-generate FK logic

export clean Prisma + SQL

eventually import existing Prisma schemas

I'm building it in the open and would love feedback, contributors, or anyone interested in the problem space.

Repo: https://github.com/punyakrit/schema-pilot

Happy to answer questions!

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

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.

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. :)

The model uses a 1024-dimensional complex Hilbert space with 32 layers of programmable Mach–Zehnder meshes (Reck architecture) and derives token probabilities directly via the Born rule.

Despite using only unitary operations and no attention mechanism, a 1024×32 model achieves coherent TinyStories generation after < 1.8 hours of training on a single consumer GPU.

This is Part 1 - the next step is physical implementation with $50 of optics from AliExpress.

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 built RetroAssembly as a classic games cabinet that lives entirely in the browser. It's open source and free to use, and if you'd like you can even host your own instance with Docker (the Docker image is only ~70 MB).

What it does:

- Browse and play a library of classic systems (Nintendo, Sega, Arcade, etc.) from a single place.

- Works across devices, so you can start on one machine, save your progress, and continue on another.

- Automatically fetch game boxarts to enhance the library's visual appeal.

- Smooth keyboard and gamepad navigation.

- Rewind gameplay using a simple shortcut so you can correct mistakes.

Happy to answer questions and hear ideas on how to make it better!

The article describes a speculative decoding engine, a novel approach to decoding text that leverages machine learning and natural language processing techniques to enhance the accuracy and speed of text decoding, particularly for ambiguous or noisy inputs.

Hi everyone, for last 7 months, I have been learning all the attempts made to eliminate codebase environment setups.

Here's my product which is a leap in the same direction and will help you run any codebase on relevant machine.

Check it out on gitarsenal.dev/ and we got ranked 6th on Product Hunt as well.

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!