Show stories

The article discusses the author's decision to build a custom synthesizer for their young daughter, focusing on the educational and bonding benefits of introducing her to music and electronics at an early age.

Hey HN,

I'm 13, from Nigeria, and I just released PrinceJS — the fastest web framework for Bun right now.

• 19,200 req/s (beats Hono/Elysia/Express) • 2.8 kB gzipped • Tree-shakable (cache, AI, email, cron, SSE, queue, test, static...) • Zero deps. Zero config.

Built in < 1 week. No team. Just me and Bun.

Try it: `bun add princejs` GitHub: https://github.com/MatthewTheCoder1218/princejs Docs: https://princejs.vercel.app

Brutal feedback welcome. What's missing?

– @Lil_Prince_1218

Hi everyone, I'm the author of ESPectre.

This is an open-source (GPLv3) project that uses Wi-Fi signal analysis to detect motion using CSI data, and it has already garnered almost 2,000 stars in two weeks.

Key technical details:

- The system does NOT use Machine Learning, it relies purely on Math. — Runs in real-time on a super affordable chip like the ESP32. - It integrates seamlessly with Home Assistant via MQTT.

Continuous Claude is a CLI wrapper I made that runs Claude Code in an iterative loop with persistent context, automatically driving a PR-based workflow. Each iteration creates a branch, applies a focused code change, generates a commit, opens a PR via GitHub's CLI, waits for required checks and reviews, merges if green, and records state into a shared notes file.

This avoids the typical stateless one-shot pattern of current coding agents and enables multi-step changes without losing intermediate reasoning, test failures, or partial progress.

The tool is useful for tasks that require many small, serial modifications: increasing test coverage, large refactors, dependency upgrades guided by release notes, or framework migrations.

Blog post about this: https://anandchowdhary.com/blog/2025/running-claude-code-in-...

The article discusses the use of IO_URING, a modern Linux kernel feature, to improve the performance of WebSocket communication. It explores how IO_URING can be leveraged to provide efficient and scalable WebSocket handling, addressing the challenges of traditional socket-based approaches.

I built bsub because I was tired of wiring up Docker images, Python environments, GPUs, sandboxing, and resource limits every time I needed to run heavy command-line tools from web apps. I wanted: send files -> run job in the cloud -> get output -> done.

https://www.bsub.io

bsub lets you execute tools like Whisper, Typst, Pandoc, Docling, and FFmpeg as remote batch jobs with no environment setup. You can try them locally via the CLI or integrate via a simple REST API.

Example (PDF extraction):

  bsubio submit -w pdf/extract *.pdf

Technical details: - Each job runs in an isolated container with defined CPU/GPU/RAM limits. - Files are stored ephemerally for the duration of the job and deleted after completion. - REST API returns job status, logs, and results. - Cold start for light processors (Typst, Pandoc) is low; Whisper/FFmpeg take longer due to model load/encoding time. - Backend scales horizontally; more workers can be added during load spikes.

Current processors:

  SST/Whisper -- speech-to-text

  Typography -- Typst, Pandoc

  PDF extraction -- Docling

  Video transcoding -- FFmpeg

Looking for testers! CLI is open source: https://github.com/bsubio/cli. Installers available for Linux/macOS; Windows testing is in progress. Free during early testing; pricing TBD.

If you’re on Windows, feedback is especially helpful: contact@bsub.io

If you try it, I’d appreciate feedback on API design, latency, missing processors, or anything rough around the edges.

Kalendis is an API-first scheduling backend. You keep your UI; we handle the gnarly parts (recurrence, time zones, DST, conflict-safe bookings).

What it does: • MCP tool: generates typed clients and API route handlers (Next.js/Express/Fastify/Nest) so you can scaffold calls straight from your IDE/agent tooling. • Availability engine: recurring rules + one-off exceptions/blackouts, returned in a clean, queryable shape. • Bookings: conflict-safe endpoints for creating/updating/canceling slots.

Why we built it: We kept rebuilding the same "hard parts" of scheduling: time zones/DST edge cases, recurring availability, conflict-aware booking, etc. We wanted a boring, reliable backend so we could ship product features without adopting a hosted scheduling UI.

How it's helped: We stopped re-implementing DST/recurrence math and shipped booking flows faster. One small team (just 2 developers) built a robust booking platform for their business using Kalendis—they kept full control of their UX without spending lots of cycles on scheduling infrastructure. The MCP generator cut the glue code: drop in a typed client or route, call the API, move on.

Some tech details: • REST API with ISO-8601 timestamps and IANA time zones • Recurring availability + one-off exceptions (designed to compose cleanly) • Focused scope: users, availability, exceptions, bookings (not a monolithic suite)

The MCP server exposes tools like generate-frontend-client, generate-backend-client, generate-api-routes, and list-endpoints. Add to your MCP settings:

  {
   "mcpServers": {
    "kalendis": {
     "command": "npx",
     "args": ["-y", "@kalendis/mcp"]
    }
   }
  }

  curl -H "x-api-key: $KALENDIS_API_KEY" \
 "https://api.kalendis.dev/v1/availability/getAvailability?userId=<user-id>&start=2025-10-07T00:00:00Z&end=2025-10-14T00:00:00Z&includeExceptions=true"

Hey HN

This project took almost two years and is probably one the best alternatives for tools like Miro and MindMeister

Let me know what you think

it won't let me put url for some reason, here it is: https://github.com/octopii-rs/octopii

Hey everyone, I'm Sean, and I've built UpBeat.

Why did I build this?

Well, the world is more complex than ever, and every stream, device and social feed screams for our attention whilst telling us that everything is awful.

While it's important to know what's going on in the world - do we really need to be bombarded with negativity 24/7?

Absolutely not! It's bad for our mental health, it's bad for our attention spans, and it's bad for society as a whole.

So that's why I built UpBeat - My friends, loved ones, and I needed a break from the doom cycle. So, here it is :)

Some technical details, it's a macOS app built with Go using the Wails.io framework and it (currently) uses the Distilbert model which runs on the Apple Neural engine, so inference takes ~40ms.

ToolHop is your all-in-one browser toolbox with 200+ fast-loading calculators, converters, generators, color labs, and dev helpers. Use global search or curated categories to jump straight into the right utility, run it client-side for instant feedback, and deep-link results to your team. Whether you’re formatting copy, validating data, checking DNS, or exploring palettes, ToolHop keeps your core workflows a single tab away, and it’s entirely free, no account required.

---

I built ToolHop because I was sick of the usual “free tool” bait-and-switch. Every time I needed to convert an image, compress a file, check some text, or run a quick calculation, I’d end up hitting some arbitrary limit like “10 uses per week” or a forced signup wall. It’s ridiculous how something as basic as converting a JPG to a PNG can turn into a subscription pitch.

So ToolHop started as a personal frustration project: I wanted a single place with a ton of genuinely useful tools that didn’t nag, lock you out, or throttle you. Over time that grew into 200+ handcrafted tools, all fast, simple, and actually free. No trickery, no timers, no limits.

As I built it, the process became about consistency and quality. I wanted the tools to feel seamless, not slapped together. That meant focusing on speed, clean UI, accurate results, and making sure each tool works instantly without friction.

The goal was always the same: a site that respects people’s time. Something you can rely on whenever you just need a tool to work. If ToolHop saves someone even a few minutes of hassle, then the project did its job.

Frustrated by the complexity and resource drain of multi service monitoring stacks, I built Simon. I wanted a single, lightweight dashboard to replace the heavy stack and the constant need for an SSH client for routine tasks. The result is a resource efficient dashboard in a single Rust binary, just a couple of megabytes in size. Its support for various architectures on Linux also makes it ideal for embedded systems and lightweight SBCs.

It integrates: Comprehensive Monitoring: Realtime and historical metrics for the host system and Docker containers (CPU, memory, disk usage, and network activity). Integrated File & Log Management: A web UI for file operations and for viewing container logs, right where you need them. Flexible Alerting: A system to set rules on any metric, with templates for sending notifications to Telegram, ntfy, and webhooks. My goal was to create a cohesive, lightweight tool for self hosters and resource constrained environments. I'd love to get your feedback.

https://github.com/alibahmanyar/simon

Inspired by rustlings for the concept and the name. A little project to learn or refine the basics of docker / compose commands. I am planning to add more advanced themes later on. Hoping to have discussions on how it could become more useful for others.

UnFlip is a unique puzzle game where players must flip and rotate tiles to uncover hidden images. The game features a minimalist design, challenging levels, and an addictive gameplay loop that encourages players to keep playing and solving increasingly complex puzzles.

TL;DR: Internet Object (IO) is a lean, schema-first, JSON-compatible format that cuts structural noise, improves clarity for modern systems, and reduces tokens by ~40–50%.

Playground: https://play.internetobject.org

---

I started exploring this idea in 2017 after repeatedly running into the same pain points with JSON while building distributed systems and structured data pipelines. Rather than extending JSON or adding more layers on top of it, I wanted a format that was clean, schema-first, human-friendly, and still compatible, where that compatibility matters.

The concept evolved slowly over the years, with several redesigns, dead ends, and restarts - until it eventually converged into what I now call Internet Object (IO). The story behind this evolution is here:

https://internetobject.org/the-story/

Although IO was not created with LLMs in mind, its structure ends up being significantly more token-efficient (around 40-50% fewer tokens compared to JSON), which has become a practical advantage in today’s workloads.

I've written a practical guide showing how JSON developers can transition to IO, with syntax explanations: https://blog.maniartech.com/from-json-to-internet-object-a-l...

For side-by-side comparisons with JSON, see the following link:

https://www.internetobject.org/io-vs-json/

There is also an interactive playground if you'd like to try the format directly:

https://play.internetobject.org

https://play.internetobject.org/simple-collection

This is a soft launch to gather early feedback - I would appreciate any thoughts from the community.

Small tool that converts epub books into folders with each chapter as a markdown file. Makes it easy for CLI agents and LLMs to reference books on demand.

The CSL is an attempt to rethink software licensing in a way that balances freedom, sustainability, and fairness. It’s inspired by the idea that our digital infrastructure increasingly mirrors feudal systems: concentrated power, obligations flowing upward, and everyday users left vulnerable. The license is designed to give creators a practical alternative to proprietary or exploitative models, while encouraging transparency, collaboration, and equitable distribution. I’d love to hear thoughts from developers, legal experts, and anyone experimenting with bootstrapped projects.

Hey HN!

I'm very proud of sharing this project with you all, after ~2 years of starts and stops, and about 5 different attempts at making it.

Context/history: In 1961, the Minivac 601 [0], an educational electronics kit - somewhat similar to those "300 circuits in one" you may have had growing up as I did - was created by none other than Claude Shannon.

The Minivac is disarmingly simple: it consists roughly speaking of 6 relays, 12 lights, 6 buttons, and a motorized wheel. You'd think that it couldn't really do much.

Well, amazingly, it can do a lot. You can wire up the components in a way that will make the Minivac play tic-tac-toe, or OCR-detect 10 digits... The sample "demo" circuit I chose for the homepage shows a binary counter that counts up to 7.

Another amazing thing about the Minivac is definitely its manuals [1]. Their spirit is what I hope to capture in the coming (years?) as I keep improving this project. The manuals are generous and well-written and are not only an amazing gradual introduction to relay-based logic - they touch on computing at large. With amazing 1960s graphics/cartoons, of course.

That's probably what got me to work on the Minivac. I learned about the device a bit before going to the Recurse Center, fell in love with the manuals, and was frustrated that I couldn't try out the circuits or play around with the device! I thought that creating a JavaScript-based emulator would be an "easy" way to get there. Turns out that correctly simulating electricity isn't "easy". :-) But I'm very proud that it now seems to be doing the right thing for most circuits that I've tested from the book. Yes, this Minivac Simulator has a TypeScript testing suite!

Looking forward to hearing from you all. Cheers

[0] https://en.wikipedia.org/wiki/Minivac_601

[1] https://minivac.greg.technology/manuals/1961-minivac601-book...

Repo: https://github.com/gregsadetsky/minivac/

Hi guys, I stitched a few APIs together into a fun gig finder app and thought some of you might enjoy it. Warning - autoplay!

Hi HN - I’m Peter, here with Harry (devhawk), and we’re building DBOS Java, an open-source Java library for durable workflows, backed by Postgres.

https://github.com/dbos-inc/dbos-transact-java

Essentially, DBOS helps you write long-lived, reliable code that can survive failures, restarts, and crashes without losing state or duplicating work. As your workflows run, it checkpoints each step they take in a Postgres database. When a process stops (fails, restarts, or crashes), your program can recover from those checkpoints to restore its exact state and continue from where it left off, as if nothing happened.

In practice, this makes it easier to build reliable systems for use cases like AI agents, payments, data synchronization, or anything that takes hours, days, or weeks to complete. Rather than bolting on ad-hoc retry logic and database checkpoints, durable workflows give you one consistent model for ensuring your programs can recover from any failure from exactly where they left off.

This library contains all you need to add durable workflows to your program: there's no separate service or orchestrator or any external dependencies except Postgres. Because it's just a library, you can incrementally add it to your projects, and it works out of the box with frameworks like Spring. And because it's built on Postgres, it natively supports all the tooling you're familiar with (backups, GUIs, CLI tools) and works with any Postgres provider.

If you want to try it out, check out the quickstart:

https://docs.dbos.dev/quickstart?language=java

We'd love to hear what you think! We’ll be in the comments for the rest of the day to answer any questions.

I've written Atlas, a GPU scripting language that eliminates the boilerplate of managing textures and uniforms. Here are some demos including 4D fractal exploration with gamepad controls. Press 7 to see the Julia set, and try reloading if you see rectangles/it glitches. Documentation: https://banditcat.github.io/Atlas/index.html *requires approximately an RTX 3080.

Hi HN,

We’re a small team working on 13Radar.com, which we launched about two weeks ago after 4 months of development. I’m the founder, and together with the team we’re building a platform that tracks hedge fund portfolios in real-time based on SEC Form 13F filings.

AI has been a major helper in our workflow. For a single webpage, we often consult multiple AI systems in parallel, generating different versions and comparing them side by side before deciding on the final design or implementation. More than 60% of the research, design, and coding involved AI assistance. For UI design we used Readdy, which gave us a smooth design experience. We experimented with Google Gemini and ChatGPT for research and prototyping, while most of the coding was done with Claude Code (Trae). On the front-end, we started with Bootstrap but later switched to TailwindCSS for a lighter, more responsive framework.

Features so far:

Real-time tracking of hedge fund holdings from SEC 13F filings

Portfolio changes per quarter (new positions, increases, reductions, exits)

Sector-level insights and trend analysis

Historical tracking and backtesting tools

Next steps:

Implementing pricing and subscription features

Adding email notifications and report export

Expanding analytics with insider transaction data

Continuing to refine usability and performance

We’d love feedback from the community:

Does this solve a real pain point for investors/researchers

Any thoughts on improving positioning or usability

Suggestions for features that would make this more useful

Thanks for reading — and if you’re curious, feel free to check out the site and let us know what you think.

Here's my embarrassing story:

I thought "gaming highlights" would work. Made 20 videos. Got 47

subscribers. Realized the CPM is like $2-4. Would need 500K views

just to make $1K/month. Not happening.

Then I tried "motivational quotes". Saturated. Couldn't get any

traction.

Then "meditation music". Also saturated. Plus copyright issues.

I was so frustrated. I knew faceless channels could work (I saw

some making money), but I had no idea HOW to find profitable ones.

Manually searching YouTube was a nightmare:

- Most channels show face sometimes (not truly faceless)

- Can't tell if they're actually monetized

- No way to know their revenue

- Takes forever to find good examples

I wasted 3 months guessing. Made 50+ videos across different niches.

Got nowhere.

Then I realized the problem:

I was trying to find profitable faceless channels manually. It's

impossible. There are millions of channels. How do you know which

ones are actually making money?

So I built a scraper to track faceless channels making $5K+/month.

Started analyzing what actually works.

What I found:

- Personal finance reviews (budget products) - Channels making

$15K-35K/mo

- Tech comparisons (budget tech angle) - Channels making $12K-28K/mo

- "How it works" explained content - Channels making $8K-20K/mo

- Ranking videos ("Top 10 X under $Y") - Channels making $6K-18K/mo

- Historical deep dives - Channels making $10K-22K/mo

The pattern: All successful faceless channels pick a micro-niche.

Not "tech reviews" but "budget gaming laptops under $800".

I turned my research into a tool called *ApexVix* so other people

don't waste months like I did. It tracks profitable faceless channels

across all niches and shows you:

- Real channels making $5K-30K/month

- What niches they're in

- Growth patterns

- Upload frequency that works

It's free to use: apexvix

No signup needed. I just wish I had this when I started. Would've

saved me 3 months of guessing.

If you're struggling to find profitable faceless niches, this might

help. Happy to answer questions!

Alphafold3 used to be fodder for HPC clusters; now I've got a port running smoothly on Apple Silicon. If you have an M-series Mac (~2023-present), you can generate protein structures from sequences in minutes. Give it a try!

GitHub repo: https://github.com/latent-spacecraft/openfold-3-mlx

I built Hirelens (https://hirelens.co) after seeing many ESL and international job seekers struggle with resumes that don’t match job descriptions or parse cleanly in ATS systems, even when they have strong experience.

What it does:

Extracts skills/experience from a resume

Compares it to a target job description

Flags unclear or “non-native” phrasing

Suggests clearer rewrites

Identifies ATS parsing issues

Deletes files after processing (no storage)

Tech: Next.js + FastAPI, lightweight CV parsing → embeddings → scoring logic, LLM-based suggestions, no data retention.

I’d love feedback on:

parsing edge cases

rewriting clarity

what features matter most for job seekers or hiring managers

Try it here: https://hirelens.co

Many years ago I posted here about Scale Heaven, a website that had nice UI showing every scale and chord that exist, and it exploded. Melodic Mind is that, but x100.