Show stories

The article discusses the rise of 'software-based' cities, where urban planning and development are increasingly driven by technology and data-driven decision-making. It explores how cities are leveraging digital tools and platforms to enhance infrastructure, services, and citizen engagement.

I got my Apple developer certificate and built a simple app to solve a problem I had. One shop I buy from doesn't have Apple Wallet passes. Since you need signed certificates to build these very simple things, I created a minimal app that signs them. It's available if you need it too. It won't scan cards with AI - you manually enter the barcode, which I think makes it less prone to error.

built a tiny pytorch clone in c after going through prof. vijay janapa reddi's mlsys book: mlsysbook.ai/tinytorch/

perfect for learning how ml frameworks work under the hood :)

I built RenderCV because Word kept breaking my layout and LaTeX was overkill. I wanted my CV as a single YAML file (content, design, margins, everything) that I could render with one command.

Run rendercv render cv.yaml → get a perfectly typeset PDF.

Highlights:

1. Version-controllable: Your CV is just text. Diff it, tag it.

2. LLM-friendly: Paste into ChatGPT, tailor to a job description, paste back, render. Batch-produce variants with terminal AI agents.

3. Perfect typography: Typst under the hood handles pixel-perfect alignment and spacing.

4. Full design control: Margins, fonts, colors, and more; tweak everything in YAML.

5. Comes with JSON Schema: Autocompletion and inline docs in your editor.

Battle-tested for 2+ years, thousands of users, 120k+ total PyPI downloads, 100% test coverage, actively maintained.

GitHub: https://github.com/rendercv/rendercv

Docs: https://docs.rendercv.com

Overview on RenderCV's software design (Pydantic + Jinja2 + Typst): https://docs.rendercv.com/developer_guide/understanding_rend...

I also wrote up the internals as an educational resource on maintaining Python projects (GitHub Actions, packaging, Docker, JSON Schema, deploying docs, etc.): https://docs.rendercv.com/developer_guide/

I’ve always found it funny how simple feedback widgets end up as $20–$30/month products. The tech is dead simple, infra is cheap, and most of us here could rebuild one in a weekend.

So as a “principle experiment” I built my own today as a side project and priced it at 1 dollar. Just because if something is cheap to run and easy to replicate, it should be priced accordingly, and it’s also fun marketing.

1$ feedback tool.

Shipped today, got the first users/moneys today, writing this post today. Side Sunday project, then back to the main product tomorrow.

Hi everyone! My name's Luke and I made the original Jmail here alongside Riley Walz. We had a ton of friends collaborate on building out more of the app suite last night in lieue of DOJ's "Epstein files" release.

Please AMA!

Hi HN,

I’m a junior developer. I wanted to share a side project I’ve been working on.

The national railway carrier (BDZ) has no public API. They have an official map but the UI is quite dated, often lags, and doesn't show the full route context.

I wrote a short write-up about the process here: https://www.pavlinbg.com/posts/bg-train-tracker

I know it's still rough around the edges (I'm still working on it), but I’d love to hear your feedback or suggestions!

We’re building Largemem, (https://largemem.com) a shared knowledge base where groups upload and maintain a common set of documents (PDFs, scans, audio) and query them conversationally.

Each group has its own persistent knowledge base. We parse content into chunks, extract entities, and combine vector search with a lightweight knowledge graph, so answers can synthesize information across multiple documents and across the group’s shared context - not just retrieve isolated snippets.

We would love to hear your feedback!

I was looking for some fun project to play around with the latest Gemini models and ended up building this :)

Enter your username and get:

- Generated roasts and stats based on your HN activity 2025

- Your personalized HN front page from 2035 (inspired by a recent Show HN [0])

- An xkcd-style comic of your HN persona

It uses the latest gemini-3-flash and gemini-3-pro-image (nano banana pro) models, which deliver pretty impressive and funny results.

A few examples:

- dang: https://hn-wrapped.kadoa.com/dang

- myself: https://hn-wrapped.kadoa.com/hubraumhugo

Give it a try and share yours :)

Happy holidays!

[0] https://news.ycombinator.com/item?id=46205632

Hi! I just made an obsdian alternative in terminal after searching for an Obsidian like TUI and got nothing. So I built one myself.

A Python script to create dynamic karaoke-style subtitles in WebVTT (.vtt) format from simple text files.

The article discusses the development of PasskeyBot, an open-source password manager that generates and stores strong, unique passwords for users, providing a secure solution to manage their online accounts.

Hi HN,

I built BetterQR because I refuse to pay more than my Netflix subscription for 3 QR codes!

I just needed 3 QR codes for an event, but every tool I found wanted a ~$30/month subscription. It felt like a massive pricing mismatch for what is essentially a simple redirect and a PNG.

I ended up hacking together a minimal alternative in an afternoon and decided to polish it up and ship it.

It's intentionally lean: - static & dynamic codes (that don't break). - analytics (just enough to see if anyone is actually scanning). - no "subscription or die" model for basic usage. Up to 3 codes are free forever. If you need more, the paid tier is priced like a utility, not a luxury suite.

I'm sharing this mainly to get feedback: - what QR features people actually care about - where the "free vs paid" line should be - whether this solves a real annoyance or just mine

Happy to answer questions about implementation, trade-offs, tech stack or anything else.

MomentBridge is a minimalist, open-source web app I built to let people share and revisit life moments in a clean, card-based interface.

Tech stack: - Pure HTML, CSS, and vanilla JavaScript (no frameworks, no build step) - 30+ moment cards with smooth hover animations - Fully responsive design - Total file size: ~24KB (including images/icons) - Hosted on GitHub Pages

Live demo: https://vnglstzrs.github.io/momentbridge/

I built this as an experiment in minimal front‑end design and to encourage digital mindfulness. All feedback is welcome—and yes, the project is for sale if someone wants to develop it further.

Claude Code tends to be just slow enough you have time to tab away and get distracted. This plugin uses Claude Code's hooks to play music when Claude is waiting for user input so you don't just leave it sitting for 15 minutes.

Hi HN,

I built a live experiment called "Twitch Plays Claude". It’s exactly what it sounds like: inspired by Twitch Plays Pokémon, but instead of moving a sprite, the crowd controls an LLM (Claude 4.5 Opus) to live-code a single index.html file.

I’m really curious to see if this results in a chaotic mess or if a "wisdom of the crowd" effect kicks in to build a coherent application.

How it works:

Any user in the chat can submit a prompt using !idea <prompt>. This can be as simple as "Add a small button here", or it can try to modify the whole page like "Make the website a 3D space simulation using Three.js". The composition is where the chaos emerge. You can for instance write "!idea add a mario movie projected automatically on a screen in the space".

I implemented two modes to manage the chaos:

- Anarchy: Chat inputs are batched. I included a "pressure estimate" logic in the system prompt so the AI tries to satisfy the weighted demand of the crowd.

- Democracy: Inputs are synthesized by Claude, then voted on by chat before execution. Each complete cycle lasts about 1:30-2 mins.

To keep it interesting, the crowd sets a "Collective Goal" every 30 minutes. If the goal changes, the page resets; if kept, iteration continues.

The stack:

- Backend: FastAPI, Gunicorn, Nginx, and a custom Twitch bot. - Frontend: The stream updates the DOM using morphdom via websockets (used only to signal that something has changed). This was important to prevent full page refreshes and keep the visual experience smooth. If needed in the event of any refresh bug, the chat can reload the page using !refresh - Sandbox: It's heavily sandboxed, but I allowlisted libraries like Three.js so people can try to build 3D scenes or mini-games. - The AI used is Claude Opus 4.5 for both democratic synthesis and code (patchs) production. I implemented a custom system to make Claude not have to rewrite the full index.html each time.

I plan to keep this running for a few days. The GitHub repo auto-updates with every commit from the stream.

Depending on how it goes, I might implement hierarchical clustering on semantic embeddings to improve the Democracy mode, or give the chat control over the system prompt itself and/or reset the page.

Links:

- Live Stream: https://www.twitch.tv/artix187

- Result (Live Website, at your own risks): https://artix.tech/tpc

- Crowd-produced code: https://github.com/ArtixJP/twitch-plays-claude

Please let me know what you think or if you have any idea to improve the system!

I’m a software engineer who accidentally became my team’s Kubernetes person — and eventually the bottleneck for every Helm chart PR.

I built Chart Preview so reviewers could see Helm chart changes running without waiting on me.

A few years ago, my team needed to implement HA for an existing product, which meant deploying on Kubernetes and OpenShift. I spent months learning Kubernetes, Helm, and the surrounding ecosystem. After that, Kubernetes largely became “my thing” on the team.

We later published public Helm charts for the product, and customers started submitting PRs. Those PRs would often sit for months — not because the changes were bad, but because testing them meant manually spinning up a Kubernetes cluster, deploying the chart with the proposed changes, running through test scenarios, and coordinating verification with product and QA. Since I was the only one who could reliably set up those environments, everything waited on me.

I kept thinking: what if the PR itself showed the changes working? What if reviewers could just click a link and see it deployed?

That idea became Chart Preview.

Chart Preview deploys your Helm chart to a real Kubernetes cluster when you open a PR, provides a unique preview URL for that PR, and cleans everything up automatically when the PR closes.

I started by solving a problem I was personally hitting, rather than surveying the whole market upfront. As I built more of it, I looked at existing preview tools and noticed that while there are solid solutions for previewing container-based applications, Helm-specific workflows introduce different challenges — chart dependencies, layered values files, and opinionated chart structures. That pushed me to focus Chart Preview on being Helm-native first, rather than adapting a container preview workflow to fit Helm.

Under the hood, it’s built in Go using the Helm v3 SDK. The architecture is an API server with workers pulling jobs from a PostgreSQL queue — no Kubernetes operator, just services talking directly to the Kubernetes API. Each preview runs in its own namespace with deny-all NetworkPolicies, ResourceQuotas, and LimitRanges. GitHub integration is done via a GitHub App for check runs and webhooks, with GitLab supported via the REST API.

There were a few interesting challenges along the way. Injecting preview hostnames into Ingress resources without corrupting manifests took several iterations. Helm uninstall doesn’t always clean everything up, so deleting the entire namespace turned out to be the safest fallback. Handling rapid pushes to the same PR required build numbering so the latest push always wins. And while the Helm SDK is powerful, it’s under-documented — I spent a lot of time reading Helm’s source code.

I’ve been building and testing this for a few months using real charts like Grafana, podinfo, and WordPress to validate the workflow. It’s early, but it works, and now I’m trying to understand whether other teams have the same pain point I did.

You can try it by installing the GitHub App here: https://github.com/apps/chart-preview

I’d love feedback on a few things:

Does this solve a real problem for your team, or is shared staging “good enough”?

What’s missing that would make you actually use it?

Are there Helm charts this wouldn’t work for? (Cluster-scoped resources are intentionally blocked.)

Happy to answer questions about the implementation.

I built this after researching image-based attacks for 3 months. Most sanitizers just strip EXIF metadata, but threats like steganography and polyglot files survive. This API decodes images to raw pixels, discards the original container, and rebuilds a sterile PNG. Stack: Rust → WASM → Cloudflare Workers Free tier: 100 requests/month

API Docs & Demo: [Zero Trust App](https://zero-trust-web.vercel.app/) � RapidAPI (Get a key): [Zero Trust API] (https://rapidapi.com/image-zero-trust-security-labs/api/zero...)

I needed to generate invoices in a Node.js app. jsPDF is 229KB. I only needed text, rectangles, lines, and JPEG images.

  So I wrote tinypdf: <400 lines of TypeScript, zero dependencies, 3.3KB minified+gzipped.

  What it does:
  - Text (Helvetica, colors, alignment)
  - Rectangles and lines
  - JPEG images
  - Multiple pages, custom sizes

  What it doesn't do:
  - Custom fonts, PNG/SVG, forms, encryption, HTML-to-PDF

  That's it. The 95% use case for invoices, receipts, reports, tickets, and labels.

  GitHub: https://github.com/Lulzx/tinypdf
  npm: npm install tinypdf

Hi HN,

I built Lockify because I wanted a simple way to encrypt and decrypt files locally without relying on cloud services.

It’s a small Go-based CLI focused on being simple, fast, and easy to use from the terminal.

I’d really appreciate any feedback, especially around usability and CLI design.

Hi, author here o/

This is an agent that looks up public information and roasts you based on what it finds.

The Santa theme is just seasonal UI. Underneath, it is a straightforward agent that does web lookup, identity confirmation, and multi turn interaction.

Happy to answer questions or hear what breaks.

The article explores the camel farming industry in Australia, highlighting the growing demand for camel products and the challenges faced by farmers in expanding this niche market.

Bob and Arun here, creators of Stickerbox.

If AI were built for kids, what would it look like?

Asking that question led us to creativity, and more specifically, the power of kids’ imaginations. We wanted to let kids combine the power of their ideas with AI tools but we needed to make sure we did it safely and in the right way.

Enter Stickerbox, a voice powered sticker printer. By combining AI image generation with thermal sticker printing, we instantly turn kids' wildest ideas into real stickers they can color, stick, and share.

What surprised us most is how the “AI” disappears behind the magic of the device. The moment that consistently amazes kids is when the printer finishes and they are holding their own idea as a real sticker. A ghost on a skateboard, a dragon doing its taxes, their dog as a superhero, anything they can dream of, they can hold in their hand. Their reactions are what pushed us to keep building, even though hardware can be really hard.

Along the way the scope of the project grew more than we expected: navigating supply chains, sourcing safe BPA/BPS free thermal paper, passing safety testing for a children’s product, and designing an interface simple enough that a five year old can walk up and just talk to it. We also spent a lot of time thinking about kids’ data and privacy so that parents would feel comfortable having this in their home.

Stickerbox is our attempt to make modern AI kid-safe, playful, and tangible. We’d love to hear what you think!

P.S. If you’re interested in buying one for yourself or as a gift, use code FREE3PACK to get an extra free pack of paper refills.

Pixen is a powerful image editor for Mac, offering a range of advanced tools and features for photo manipulation, retouching, and graphic design. The app provides a user-friendly interface and supports various file formats, making it a versatile choice for creative professionals and enthusiasts.

I find that the drag and drop experience can quickly become a nightmare, especially on mobile. To tap, hold, drag, and scroll, all at the same time, is both difficult to achieve, and prone to errors. I've always had in mind this 2-step approach, where picking an element and placing it were two separate steps. So I implemented this basic version to showcase my idea.

While it might take more time than a regular drag and drop, the benefit is for people who struggle with holding down the mouse button. With picknplace.js, you only need two clicks and some scrolling.

This solution is meant as an experiment, so I'm open to discussion.

Hi HN! I'm Mo, a platform engineer at Deltaflare working on critical infrastructure protection.

I built Cerberus because traditional packet capture tools (tcpdump, Wireshark) have too much overhead for production CNI environments. eBPF lets us filter and classify packets at the kernel level with near-zero performance impact.

Some interesting challenges: - eBPF verifier is strict - every memory access needs bounds checking - Limited to 32 bytes of L7 payload (tradeoff between inspection depth and overhead) - TC vs XDP decision (chose TC for compatibility)

Looking for contributors, especially on: - Redis backend for distributed deployments - Prometheus metrics export - Anomaly detection

Happy to answer questions!