Show stories

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.

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/

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!

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

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.

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.

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.

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!

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

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

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.

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

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.

Hey HackerNews! Just wanted to share something slapped together recently, looking for feedback.

Context: I worked in both research and enterprise and have built a lot of services in Python and Java, and they converge to using similar patterns, regardless of how different the architectures and domains are (web apps, ML research, distributed systems, etc.)

After writing a lot of Python, I was missing a framework that strongly supported some of these patterns formally, and find that this structure lets you make assumptions that can really boost dev experience on long term projects.

Microframeworks are great. They let you get started with a single file of a few lines, but (in my opinion) lack the structure you want on long term projects, working with teams, so you end up making that structure yourself anyway. In doing so, you get a small initial boost in productivity, but at the cost of your productivity in the future.

Mitsuki tries to both allow you to start quick and easy with a single file in a few lines, but also be more friendly to you and your team through time, by giving structure to your development process.

Thus, I made an early version of a framework heavily inspired by Spring Boot. The core idea is that you can do enterprise apps without the enterprise pain, in Python, with high performance.

- Want a simple REST API? app.py with a few lines.

- Want a decent starter with auto-implemented CRUD? mitsuki init to get a starter project with domain classes, services, controllers and repositories.

- Performance? Similar to Express and Spring Boot (in Docker, on an M1 MacBook Pro, 8GB of RAM), out of the box, no configuration needed.

Lightweight

Despite the "fancy sounding" terminology, Mitsuki itself is very lightweight, and only adds a very small overhead (10%) over the components that power it (namely, Starlette and Granian). I don't want to commit to ASGI only, and a future version will likely rewrite this core logic to leverage granian further.

There is a lot of ground left to cover, lots of docs to write, examples to explore, features to expand. I'm also planning to write a few tools that leverage the structure of the framework to increase DX within enterprise teams.

But before any of that, I'm looking for feedback. Yay or nay? :)

Benchmarks

P.S. On the topic of performance and benchmarks, there are a few remarks in the repo's /benchmarks directory. (Or here: https://github.com/DavidLandup0/mitsuki/tree/main/benchmarks)

Yes, most benchmarks are arbitrary, heavily gameable, and your bottleneck is likely going to be your business logic, not the framework, anyways.

Yes, Spring Boot and Elysia will likely have higher ceilings, so running on a stronger CPU will likely change the order of the benchmark.

Yes, there's a million variables that affect these.

Yes, granian is written in Rust, not Python.

The point of the benchmark is threefold:

- This is the sort of experience you get out of the box, on your device and where you'll deploy it (Dockerized on small instance such as through K8s)

- Python web apps can stand shoulder to shoulder with JS/Java performance-wise

- Despite the seeming complexity around dependency injection, state tracking, etc., Mitsuki is pretty lightweight.

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

Hi HN! I've been building ReadyKit, an open-source SaaS boilerplate that handles all the hard parts: multi-tenant workspaces, Stripe billing, OAuth + MFA authentication, and a production-ready stack.

Built with Python/Flask, PostgreSQL, Redis, and Vue 3, it's designed for indie makers and teams who want to ship SaaS products fast. Clone, configure your OAuth and Stripe keys, and you're running in 5 minutes.

Features include automatic query scoping for workspace isolation, audit logs, role-based access, and a modern UX kit. MIT licensed and free forever.

GitHub: https://github.com/level09/readykit

It’s obviously easier to start a venture when you already have a clear idea in mind. But in reality, a lot of people that want to be founders are the opposite: they’re eager to start something new, and only then go looking for a real problem to solve. I’ve been asked many times by friends: “I want to build a startup, but I don’t know what problem to solve.”

Yes, there are ideas and complaints scattered across Reddit, Twitter, forums, etc., but there doesn’t seem to be one focused place where pain points and solutions directly meet.

So I built a small MVP: https://www.solvemypainpoint.com/

SolveMyPainPoint lets you: • Submit a pain point in a structured way (what’s the problem, how painful, which category). • See if others share the same issue and how they experience it. • Add or discover existing solutions/products when they exist. • Spot unsolved problems that might be worth building for.

It’s a scrappy side project (white-coat MVP, far from perfect), but I’d love feedback from both people with real frustrations and builders looking for something useful to work on.

If you have a pain point you keep ranting about, please try submitting it. And if you’re a builder, I’d really appreciate thoughts on what would make this genuinely valuable for you (better discovery, tags, subscriptions to topics, etc.).

Happy to answer any questions and very open to criticism and feature suggestions.

Many thanks!