Please AMA!
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.
Give it a try and let me know what you think :)
I left AWS a few months ago and created CodinIT, a local, open-source AI app builder made with remix + Electron.
The motivation: I tried one of the popular cloud-based AI app builders, but when I pulled down the app to run locally, it just didn’t work especially with the monthly costs needed to build something half decent without being limited.
So I created CodinIT, an app builder that runs fully on your computer, making it easy to switch between CodinIT and coding tools like Cursor or Claude Code.
Source code: https://github.com/codinit-dev/codinit-dev Download (free, no sign-up): https://codinit.dev Read the docs: https://codinit.dev/docs
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 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!
And quite some of my neuroscience friends are loving it.
This has been a fun little side project. You simply click to shoot arrows at falling circles (and the arrows of other players!) Hopefully, I make other social & simple games over time. I had to struggle with all the usually problems of game synchronization. It was a fun way to explore phoenix & elixir.
You'll notice the signature claude code purple gradient. I'll be honest, I couldn't have built it without AI!
If you really like it you can vote with your wallet and toss me $1.99. Or not!!
You'll
- Support for 10+ audio formats including lossless and high-resolution files Lossless & Hi-Res: FLAC, OGA, WAV, AIFF, AIF, APE, WV, TTA, DFF, DSF Compressed: MP3, MP2, AAC, OGG, OPUS, M4A, M4B, M4P, MP4, M4V, MPC Specialized: CAF, WEBM, SPX
- Bit-perfect playback with sample rate synchronization and Obtain Exclusive Access of audio device (Hog mode)
- Gapless Playback: Seamless transitions between tracks with no silence or interruption
- Built-in equalizer with customizable presets
- Browse by tracks, albums, artists, or genres
- Smart Recommendations: Auto play functionality, you don't have to think what to play next Lyrics Support:
- Download lyrics directly within the app from lrclib
- Real-time line-by-line lyrics highlighting
- Mini Player: Compact floating window with integrated queue and lyrics panels
- Audio device change option within UI
- Advanced Search: Find tracks instantly across your entire library with FTS5 (Rebuild search index if you not able to see any results: Settings -> Advanced -> Rebuild FTS)
- Playback History: Keep track of what you've listened to
- Favorites: Mark and organize your favorite tracks
- Import playlist with m3u or Import Folder as playlist
- Menu bar controls and Now Playing info
Key features:
- Canadian income tax calculator (federal + provincial)
- Mortgage calculator with CMHC insurance
- RRSP/TFSA contribution planners
- All calculations stay in your browser (no data sent to servers)
Built with React and designed for speed and accuracy. Open to feedback from the HN community!
This tool allows you to create a new audio track in the video file containing the commentary track merged with an existing audio track from the video. It also allows you to adjust the offset of the commentary track, so you can line it up with the audio in the movie at arbitrary points in case they are not already in sync. The script tries to do this automatically using subtitles and audio analysis, followed by an optional 'fine-tuning' step if you really want it dialed in to the millisecond.
I hope this is useful to anyone else who wants to enjoy these "riff tracks" more easily :)
The main problem it solves: AI agents lose context between sessions. Memora acts as a context manager that persists knowledge across multiple agent sessions, so your AI assistant remembers past work, decisions, and learned patterns.
Key features: - Persistent context across agent sessions (single or multi-agent workflows) - SQLite-backed with optional S3/R2 cloud sync - Semantic search using embeddings (TF-IDF, sentence-transformers, or OpenAI) - Interactive knowledge graph visualization (vis.js) - Structured memory types: TODOs, Issues, Knowledge entries - Cross-reference links between related memories - Image storage support with R2
The graph visualization lets you explore connections between memories, filter by tags/status, and see how your knowledge base grows over time.
Built for Claude Code but works with any MCP-compatible client.
GitHub: https://github.com/agentic-mcp-tools/memora
Would love feedback on the architecture and feature ideas!
The key idea: every node in a scene graph can be expanded into its own detailed sub-graph, infinitely. Then Gemini's image model (Nano Banana) renders each level as actual artwork (you pick your style).
Requires a GCP account for image rendering — I know it's friction, but Vertex AI was the only way to get reliable image generation.
Feel free to use for your own projects or implement the concept better than I did.
In October 2024, I started thinking about how to present aiologic queues. Andrew Svetlov's Janus library [1] had been around for quite some time and was much more popular, so I knew that comparisons with it would be inevitable. However, Janus seemed to be in a suspended state: there had been no major changes for three years, and almost all commits during that period were made by Dependabot. So I asked a relevant question [2].
During the discussion, I pointed out Janus' performance issues and stated that they could be solved by implementing queues on top of my primitives. But since Janus is a mature library, such a radical change could not be accepted. Therefore, as proof of concept, I implemented a new library - Culsans. That is how its story began.
Over time, both libraries underwent changes. Janus received significant performance improvements in 1.2.0, not least due to my PRs [3]. In 2.0.0, contrary to the above, backward compatibility was broken as a result of the implementation of shutdown methods. And Culsans became an independent library with its own features (which neither aiologic nor Janus have).
So, what is Culsans? It is a library that provides a way to communicate within a single process between different threads, different tasks (including from different event loops; asyncio, Curio, Trio, AnyIO - whatever you want), and even different greenlets (eventlet/gevent), all in a single instance. Its queues are fully compatible with the standard queues via Janus-like interfaces (as well as with Janus itself) and provide additional features such as dynamic maxsize. In short, I invite you to try out my library and see for yourself.
[0] https://news.ycombinator.com/item?id=46308839 [1] https://github.com/aio-libs/janus [2] https://github.com/aio-libs/janus/issues/679 [3] https://github.com/aio-libs/janus/pull/704
The goal of this project was to build a better webapp based on the conclusions of my case study: https://rkdvis.com/chase-travel
Per JPMC confidentiality policies, no internal information was used in any way on this project— everything was based solely on observations of the existing public-facing product.
Features include real-time visibility of friends' tasks, Pomodoro timer, vim-style keyboard shortcuts (j/k to navigate, space to complete), color-coded goals, and an inbox for quick capture. Built for people who want social motivation to get things done.