2025年9月11日 の Show HN

This weekend I created stacklib.h - a single-header library that brings Forth-style stack operations to C. It implements a basic interpreter with:

- Stack operations (push/pop/dup/swap/over/drop) - Arithmetic (+, -, *, /) - Output (., emit, cr) - Stack inspection (.s, depth)

Example usage: Stack s; stack_init(&s); dict_init(); exec(&s, "10 20 + ."); // Prints "30" exec(&s, "1 2 3 4 .s"); // Shows stack contents

The library is self-contained, requires no dependencies, and handles basic error checking. It was inspired by wanting to understand how Forth works at a fundamental level while keeping the simplicity of C.

I'm curious what other stack-based or concatenative programming enthusiasts think about this approach. Has anyone else built something similar? What features would you add to make it more useful?

GitHub: https://github.com/Ferki-git-creator/stacklib

I built a little script that gives me a fake phone call to escape boring and awkward situations. I bought a virtual number from twilio and saved it as one of my relatives.

Whenever I feel stuck, I just tap a button called “ESCAPE” on my phone. It sends a request to my remote server. The server runs a small Python script which schedules an actual call. After a minute, my phone rings and plays a pre-recorded audio.

I simply say “sorry, I’m getting a call” and walk away. A tiny project, but it has saved me so many times.

Script - https://x.com/the2ndfloorguy/status/1965624429146165251

I built pbar.io because I was tired of SSH'ing into servers to check if my data processing scripts were still running, or worse, having them finish/crash without knowing.

It's a simple REST API that lets you create and update progress bars from anywhere. The same progress bar can be viewed as terminal output (with ANSI colors), in a browser, or consumed as JSON.

I'm actually tracking this HN discussion with pbar. The progress bar increases with each comment - watch it live as we discuss!

Web: https://pbar.io/Y8yg3BG Terminal: curl https://pbar.io/api/bars/Y8yg3BG

More features that emerged from my own use cases: - Hierarchical progress bars (parent bars auto-aggregate children) - Python package (pip install pbar-io) that wraps tqdm - just swap the import - QR codes to monitor progress on your phone while away from desk - No auth required for quick prototypes

Curious what use cases you might have for this!

Now that AI is capable of writing large volumes of production-quality code, our role as developers is changing. Our primary job is no longer writing code. It’s planning and communicating software design and architecture. We have to do this collaboratively with agents and then review and iterate on their implementations.

IDEs were not built for this workflow. So about three months ago I decided to try to build what I thought this new interface should look like.

Runner is a coding agent purpose-built for this new “plan and review” workflow. It’s not for vibe coding. It’s for professional software developers who are responsible for the code they ship.

It encourages and supports a more structured and controlled workflow than other coding agents. It’s built around the concept of tasks. A task is a small, clearly scoped change. The planning agent creates and edits task specs, and then you can assign them to coding agents once you’re happy with the plan. When the coding agent finishes, you can review the changes via the built-in diff viewer. If you’re happy with them you can approve the changes, which will trigger a git commit.

Runner is available as a free BYOK beta for MacOS right now. You can learn more and download it here: https://runnercode.com/. You will need at least a Gemini API key, and for best performance also an OpenAI API key.

Hello,

I've built the tool to generate vanity Tor Onion Service addresses:

    $ onion-vanity-address allium
    Found allium... in 12s after 558986486 attempts (48529996 attempts/s)
    ---
    hostname: alliumdye3it7ko4cuftoni4rlrupuobvio24ypz55qpzjzpvuetzhyd.onion
    hs_ed25519_public_key: PT0gZWQyNTUxOXYxLXB1YmxpYzogdHlwZTAgPT0AAAAC1ooweCbRP6ncFQs3NRyK40fRwaodrmH572D8py+tCQ==
    hs_ed25519_secret_key: PT0gZWQyNTUxOXYxLXNlY3JldDogdHlwZTAgPT0AAAAQEW4Rhot7oroPaETlAEG3GPAntvJ1agF2c7A2AXmBW3WqAH0oUZ1hySvvZl3hc9dSAIc49h1UuCPZacOWp4vQ

The tool checks ~45'000'000 keys per second on a laptop which is ~2x faster than widely-used mkp224o https://github.com/cathugger/mkp224o

I've explained key performance difference here https://github.com/AlexanderYastrebov/onion-vanity-address?t...

Would love your feedback, thanks!

looking for some feedbacks and areas for improvements

TLDR: Check out my Mac music player app, download the beta, and I’d love any feedback! Comment here or email [email protected]

--

Lately I’ve been unsatisfied with available options for music players on the Mac. Everyone focuses on mobile (I know, that’s where the money is) and it feels like there’s not as much good stuff for Mac as there used to be. Well, I’ve been using the Mac for a long time and I still like it, and I wanted a good music player, so I made my own.

I started with SwiftUI, since that’s what I’ve used most recently at my iOS jobs, and I like it well enough. I soon found that SwiftUI is quite a bit rougher on macOS, so I ended up rewriting a few components in AppKit, although it remains mostly SwiftUI.

I know it’s risky to build on someone else’s service, so my first and main priority was to support local files on a disk, the simplest possible way of playing music. I layered on top of that an optional SQLite db (which I call “Librarian”) for indexing and search. I used AVPlayer (part of AVFoundation) which meant I didn’t have to worry about any audio playback details, I just let the system play whatever it can play (MP3, AAC, FLAC, etc. - but not Ogg Vorbis, sorry).

But I also still use Apple Music for discovering new music, so I integrated that too. That API (MusicKit) was a bit of a mixed bag. The upside was easy onboarding (no need to sign in, just a single permission prompt) and few restrictions on what I could do with it. The downsides are a lot of missing functionality (compared to what the first-party app can do), functionality that is present often tends to be under-documented and/or broken, and the API provider has shown little interest in fixes or improvements lately, especially on the macOS platform. The most absurd point was when I realized there is (apparently?) no way to make a volume control (!).

I briefly looked into Spotify, but they don’t have a macOS SDK, and their terms prohibit commercial and multi-source use. So it seems like that possibility is going to remain closed to me.

Finally, I added Plex and Jellyfin integrations, because once I had a system that could support multiple sources, I figured why not add some more that people might be interested in.

Since I got laid off last year, I’ve been working on this full time, just by myself. I think it’s in pretty good shape for release, but I really need some more eyes on it, since we all know that devs aren’t good at testing their own code (as much as I try).

I’d also love to get some more general feedback from others; I made this all to my own taste, but people’s music listening habits vary widely. I’m sure I’ll never be able to make everyone happy, but I’m open to considering just about anything. So, let me know! And thanks for taking a look.

-dmd

I’ve been working on something called Davia — a platform for creating interactive documents.

These are “living documents”: each page is self-contained, combining editable content, interactive components, and data. You can read them, edit them, and actually interact with them — more like mini-apps than static docs.

Here’s what makes it interesting: The interactive components are pieces of code generated on the fly, so you’re not limited to a fixed set of blocks like in Notion. You can create infinitely flexible functionality right inside a doc. Technically, an interactive page is an ensemble of components (MDX file), data (JSON file), and a main HTML file — all bundled and compiled on the fly. This gives each document its own portable architecture. Once built, you can publish your doc either as a live site (with a custom URL and persistent interactions) or as an open-source template that others can import, remix, and build upon.

We’re building an open-source community around this. If people import your templates, you’ll be credited (and in beta, you can even earn from them). It’s free to use while we’re in beta, and I’d love to build it with you.

If you enjoy tinkering with small tools, pushing the limits of interactive docs, or want to explore new ways of sharing knowledge, this could be fun. Feedback, ideas, and contributions are more than welcome — join us in r/davia_ai!

Hi everyone,

I've made a new experimental Lisp dialect (named "Element 0"). It comes with an interpreter written in Zig and a small standard library.

The project is open source, and feedback is welcome.

Project's GitHub repo: https://github.com/habedi/element-0

Hey HN, for those of you tired of running kafka-consumer-groups.sh and similar tools, here's a small real-time monitoring CLI tool for Apache Kafka, that displays consumer lag and event rates in a clean, top-like interface. You can quickly assess which consumers are lagging and when they will catch up.

I've made this to quickly assess the health of remote on-premises clusters which most of the time lack proper monitoring.

The tool can be found here: https://github.com/sivann/kafkatop

I'd be very interested to hear your feedback or any features you think would add value to this tool!

I’ve been hacking on a fun side project: Story to Manga

The idea is simple:

Paste a short story.

Choose a style (manga or comic).

Get back panels with consistent characters, settings, and mood.

It analyzes your text, builds character references, storyboards the panels (dialogue, camera angle, mood), and then generates full manga pages. The hard part—and what makes it actually usable—is keeping characters consistent across panels.

We’ve used it to turn micro-stories, hackathon recaps, and silly inside jokes into legit manga chapters. It’s still early, but fun enough that we thought HN might enjoy playing with it.

Star our github here: https://github.com/victorhuangwq/story-to-manga

Hi HN, I've built this for use in a language learning app, but you can use it without an app, since it's based around Youtube videos.

The main idea is to give you a structured learning plan with content that you care about, to keep you engaged. I know it's hard to stay on track when learning a language, so I'm hoping this will help people stay consistent and build a habit.

I was surprised yesterday when one user entered "rugby and food" as their interest (learning French), and the first video is actually a video about rugby AND food in French. There's no limit to the breadth of content on Youtube! (Although I have to admit, it is a bit lucky that this exact video exists) https://lingolingo.app/challenge/shared/curriculum-e63c42f6

Hope you find it interesting!

Hey HN! We forked styled-components after it entered maintenance mode because our production apps (and many others) can't migrate overnight.

Backstory: We submitted [PR #4332](https://github.com/styled-components/styled-components/pull/...) to styled-components in July 2024 with React 18 optimizations. When maintenance mode was announced, we turned that PR into this fork.

What we fixed: - Added React 18's useInsertionEffect - Rewrote streaming SSR for React 19 - Replaced ES5 output with modern JS - Optimized array operations with native flatMap - Fixed Next.js App Router to work without 50+ lines of boilerplate

Linear tested it and saw 40% faster initial renders with zero code changes.

How to try it: npm install @sanity/styled-components@npm:styled-components

Or for React 19: npm install @sanity/css-in-js@npm:styled-components

Benchmark tool to test yourself: https://css-in-js-benchmarks.sanity.dev/

We named it "last-resort" because that's what it is. We're not trying to maintain styled-components long-term - we're actually migrating to vanilla-extract ourselves. This is just a performance bridge while teams migrate properly.

The React team recommends moving away from runtime CSS injection. We agree. But migrations take time, and production apps need to ship today.

I got tired of manually copying numbers from Form 16 PDFs into India’s tax filing portal every year. So I built *Form16x*, a Python CLI + library that turns these semi-structured PDFs into structured JSON.

Beyond extraction, it can: - Consolidate multiple Form 16s (useful if you switched jobs in a year) - Calculate taxes under both regimes and recommend the better option - Show detailed salary and deduction breakdowns in the terminal (tree view, colored output) - Suggest tax optimizations (80C, 80D, NPS, etc.) with potential savings - Expose a Python API (`TaxCalculationAPI`) with multi-year tax rules (AY 2020–2025)

*Repo:* https://github.com/ri-sh/Form16x

### Why I built it Form 16 is similar to a W-2 in the US or a T4 in Canada: a PDF tax certificate with inconsistent layouts across employers. Filing returns often means manually re-entering data, which is error-prone and time-consuming.

Form16x tries to solve this with: - PDF parsing using camelot/pdfplumber with fallback logic - Structured output aligned with the form fields - Local-only processing (no data leaves your machine) - CLI polish (progress bars, colored display, breakdown trees)

Would love feedback from HN on both the technical side (PDF parsing + structured extraction) and whether this approach could extend to other countries’ tax forms.

Hi HN,

I built newlang.app because I wanted a simple way to improve my spoken English. Most tools I found were either focused on grammar, full of distractions, or not free. So I created something minimal that I could use daily:

Listen → Repeat → Read → Speak

It started as a personal project, but since it worked for me, I decided to share it. Right now it supports English, Spanish, Portuguese, French, Italian, and German.

A few notes: • It’s completely free. • I don’t collect user data. • The only thing required is a valid email to create an account.

I’d really appreciate feedback from this community — especially on usability, language content, and how it could be improved for learners.

Try it here: https://newlang.app/

With the latest three.js update (r180) the use of the Spark GPU codecs is now straightforward and integration into existing gltf loaders requires just one line of code.

This blog post outlining the few steps involved, goes over some of the surprises I encountered, and takes a close look at performance.

The spark.js GitHub repository now includes three.js examples that are trivial to run, just:

``` npm install npm run dev ```

Hey HN! I built Para-speak to fit my workflow - I wanted something simple: press shortcut → talk → press shortcut → text appears at cursor.

Existing tooling wasn't sufficient, and at the same time NVIDIA's Parakeet model was showing excellent results online, so I wanted specifically to try that.

Para-speak is a Rust CLI that uses NVIDIA's Parakeet TDT model running locally via MLX on Apple Silicon.

Demo & details: https://elvin.engineering/blog/2025/09-10-para-speak-cli/

GitHub: https://github.com/elv1n/para-speak

Key features:

  - Configurable global shortcuts (double-tap, combinations, sequences)

  - Audio feedback

  - Text insertion at cursor position (emulating cmd+v)

  - Extensible controller system (e.g., manipulate Spotify volume during recording)

  - Idle uses minimal resources - about 10-15 MB of RAM on my MacBook Pro M1 on average load.

Current limitations:

  - macOS only for now

  - Shortcuts pass through to other apps (not consumed)

I've been using it daily for AI-assisted coding. The accuracy is surprisingly good for a small model.

Still very early stage. Would be nice to have daemon mode, proper installation (Homebrew, etc.), and add some UI feedback.

Would love your thoughts!

Hi HN,

I built https://fontofweb.com because design inspiration platforms don't give enough real material to work with.

Most sites fall into extremes: Dribbble leans toward polished mockups that never shipped, while Awwwards and Mobbin go heavy on curation. The problem isn't just what they pick — it's that you only ever see a narrow slice. High curation means low volume, slow updates, and a bias toward showcase projects instead of the everyday, functional interfaces most of us actually design.

Font of Web takes a different approach. It's closer to Pinterest, but purely for web design. Every "pin" comes with metadata: fonts, colors, and the exact domain it came from, so you can search, filter, and sort in ways you can't elsewhere. The text search is powered by multimodal embeddings, so you can use search queries like "minimalist pricing page with illustrations at the side" and get live matches from real websites.

A few things you can do:

* natural language search (e.g. "elegant serif blog with sage green")

* font search (single fonts, pairings, or 2+ combos, e.g https://fontofweb.com/search/pins?family_id=109 , https://fontofweb.com/search/pins?family_id=135 )

* color search/sorting (done in perceptual CIELAB space not RGB, e.g https://fontofweb.com/search/pins?color=%23f52f3d)

* domain search (filter by site, e.g. https://fontofweb.com/search/pins?domain=apple.com, https://fontofweb.com/search/pins?domain=blender.org )

* live website analysis (via extension — snip any part of a page and see fonts/colors instantly, works offline)

* one-click font downloads

* palette extraction (copy hex codes straight to clipboard)

* private design collections

Appreciate feedback into the ux/ui, feature set and general usefulness in your own workflow.

Tech Stack Website:

* Vanilla Client-Side rendered ReactJS

* PWA via workbox: https://developer.chrome.com/docs/workbox

* SEO html injection via Cloudflare workers via HtmlRewriter

* HeroUI + Tailwind

* Rust Backend with Axum

* Authentication with OTP email and google social auth (via openidconnect)

* Sqlite and VectorDB running on the same VPS as the API service

* $15/mo VPS (Alwyzon)

* Cloudflare CDN

* Cloudflare R2 for storage

* Cloudflare workers for proxy service, hosting, sitemap and rss feed generation, SEO tag injection and miscellaneous tasks

* Zeptomail for very cheap transactional mail * ICloud Mail for custom domain inbox (e.g [email protected])

* Simple Analytics + Google Analytics: https://dashboard.simpleanalytics.com/fontofweb.com

* Logging: Journalctl

Tech Stack Chrome Extension:

* Lit Components for lightweight UI: lit.dev

* Rust library compiled to Wasm for offline font metadata parsing via docs.rs/allsorts

* Multimodal embeddings via vertex api

I have a short term memory and i have no passion to writing but i want to learn to write something, so i need my note as my second brain, but i need not only note app, i want to freely to write something from my mind, and set some to-do list, so i decide to create one web application that fit to my requirement.

And here is my final product that you can try and maybe give me some feedback.

This is a free application. Access https://paperly.id for detail

I ran this yesterday at PyCon IL.

It has some very nice exercises that you can try at home, especially the LLM evals exercise.

Posting it as a Show mostly because I'm proud of the Excalidraw aesthetics which many of you might appreciate.

If there's interest I can run it in English online. Shoot me an email if you're interested.

With PageIndex MCP, you can chat with long PDFs without worrying about context limits.