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.

AI has made building fast and cheap, but finding the right problems still feels hard.

I built World’s Backlog (https://worldsbacklog.com ) to collect real problems directly from people working inside different industries.

Contributors post workflow pain, others validate it, and builders can study severity, frequency, and willingness to pay before building anything.

Would love feedback from builders and people who feel real pain at work.

Hi HN, I'm Holger, a developer who worked in the lighting industry.

I built this to scratch my own itch and put it on crates.io and PyPI where nothing like it existed.

The old file formats (EULUMDAT from 1990, IES from 1991) still work fine for basic photometry. But the industry is moving toward spectral data – full wavelength distributions instead of just lumen values.

The new standards (TM-33, ATLA-S001) are barely supported by existing tools.

So this handles both: legacy formats for compatibility, spectral data for anyone who wants to work with the new standards.

Stack: Rust core, then UniFFI for bindings. One codebase compiles to WASM/Leptos, egui, SwiftUI, Jetpack Compose, PyO3.

At one point the generated Swift boilerplate got so large GitHub classified it as a Swift project. 3D viewer is Bevy, loaded on-demand.

Feedback welcome – especially on the SVG output and the 3D viewer.

https://github.com/holg/eulumdat-rs (MIT/Apache-2.0)

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.

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!

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 shared a previous version of yapi a few months ago in the comments section of a post talking about the insanity of Postman being 'down'. yapi has developed into a more mature project since then!

https://github.com/jamierpond/yapi

Still very early, but it makes me much more productive vs Postman, Bruno, Insomnia, etc.

If youre a nvim/tmux culture human, you might like this!

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

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.

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!

The article describes the development of a ChatGPT-based web application that allows users to interact with an AI assistant. The application includes features such as language translation, summarization, and code generation.

The article provides a step-by-step guide to creating a markdown-based website using GitHub Pages, detailing the process of setting up a repository, creating content, and publishing the site.

Sentencestarters.net is a website that provides a collection of sentence starters and prompts to help writers overcome writer's block and generate new ideas. The site offers a wide range of categories, from creative writing to academic essays, and is designed to inspire and stimulate the writing process.

The article discusses the development of Mactop, a lightweight and customizable macOS-based operating system designed to provide an enhanced user experience on older or less powerful hardware. The project aims to offer a more streamlined and efficient alternative to the standard macOS distribution.

I built an open-source alternative to Citizen App's paid 911 feed for San Francisco.

It streams live dispatch data from SF's official open data portal, uses an LLM to translate police codes into readable summaries, and auto-redacts sensitive locations (shelters, hospitals, etc.).

Built it at a hack night after getting annoyed that Citizen is the only real-time option and they paywall it.

Repo: https://github.com/midaz/sf-police-blotter Discord: https://discord.gg/KCkKeKRm

Happy to discuss the technical approach or take feedback.

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

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.

Burned about 1 weeks on this. Not sure if it's useful to anyone beyond my original use case, but figure I'd share.

Friend went through a nasty divorce. Had $750k going into the marriage (inheritance), put it in a joint account like an idiot. Five years later, account's been up and down, money mixed with paychecks and mortgage payments. Lawyer says "you need a forensic accountant to trace what's still yours." Quote comes back: $5k, 4 weeks minimum.

I'm sitting there thinking - this is just transaction categorization and some relatively simple math (the "Lowest Intermediate Balance Rule" if you want to google it). Why doesn't software exist for this?

Turns out it kind of doesn't. There are $50k enterprise tools for big law firms, but nothing a normal person or small practice can actually use.

So I built a Django app that takes bank statement PDFs, uses latest Mistral's OCR-3 to parse them (because real-world bank PDFs and shots are a nightmare - scanned, rotated, weird formats), then runs them through an LLM to categorize transactions and a Python implementation of the LIBR algorithm.

Output is a court-usable report showing exactly how much of your "separate property" is still traceable, with visualizations and evidence logging (SHA-256 hashing for chain of custody, audit trails, the works).

Its FREE and whole process takes about 3 minutes. I'm in India and honestly just want to see if people use it.

What's really interesting:

-Latest Mistral's document OCR-3 is genuinely impressive on messy banking PDFs. Tried Tesseract first, got maybe 60% accuracy.

-The LIBR algorithm is conceptually simple but has some gnarly edge cases (what happens when account hits zero? how do you handle multiple deposits of separate property? etc.)

-Evidence integrity was harder than expected. Lawyers care a LOT about proving a document hasn't been tampered with.

-Used Celery because some statements have 10k+ transactions and you can't block the request

Currently running on Render with Postgres. Code's not open source yet because honestly it's kind of a mess and I need to clean up some stuff, but might do that if there's interest.

Things I'm unsure about:

-Should it be free? Subscription? How much? Bring your won key? Cause I'm putting money out of my pocket.

-B2C vs B2B - individuals might use this once, but lawyers could use it repeatedly.

-How much do I need to worry about legal liability for the output? I have disclaimers everywhere but still

Anyway, it's live: https://exitprotocols.com.

Would love feedback, especially if you've dealt with this problem before or know the family law space.

I ran 625 API calls across 5 frontier models to find out what makes LLMs produce better creative work. The answer surprised me: it's not about being rude or polite, it's about emotional intensity.

Title really says it all on this

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

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.

Hey HN! Been a while.. last post for reference in 2020: https://news.ycombinator.com/item?id=22985055. Moved city, job and had two children since then which is wild :)

Been working away shifting Kanmail over to a Go backend (using the excellent wails) and rewriting the frontend in TypeScript. This "new" v2 is much quicker, overcomes a bunch of old limitations (no age limit on paginating folders) and finally gets a working Linux AppImage (*my Linux test setup is somewhat limited and I expect there's plenty of edge cases here - hit me up if you have issues).

Anyway, would love any feedback on site or app, the previous round was incredibly useful.

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.

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.

This article provides an overview of the Agent FecFile project, which is a tool for automatically generating FEC (Federal Election Commission) compliant files from campaign finance data. The tool aims to simplify the process of filing campaign finance reports and ensure compliance with FEC regulations.

Alright so if you run a self-hosted blog, you've probably noticed AI companies scraping it for training data. And not just a little (RIP to your server bill).

There isn't much you can do about it without cloudflare. These companies ignore robots.txt, and you're competing with teams with more resources than you. It's you vs the MJs of programming, you're not going to win.

But there is a solution. Now I'm not going to say it's a great solution...but a solution is a solution. If your website contains content that will trigger their scraper's safeguards, it will get dropped from their data pipelines.

So here's what fuzzycanary does: it injects hundreds of invisible links to porn websites in your HTML. The links are hidden from users but present in the DOM so that scrapers can ingest them and say "nope we won't scrape there again in the future".

The problem with that approach is that it will absolutely nuke your website's SEO. So fuzzycanary also checks user agents and won't show the links to legitimate search engines, so Google and Bing won't see them.

One caveat: if you're using a static site generator it will bake the links into your HTML for everyone, including googlebot. Does anyone have a work-around for this that doesn't involve using a proxy?

Please try it out! Setup is one component or one import.

(And don't tell me it's a terrible idea because I already know it is)

package: https://www.npmjs.com/package/@fuzzycanary/core gh: https://github.com/vivienhenz24/fuzzy-canary