Show stories

The article discusses the problem of waste in the software development industry, estimating that 90% of the code produced is never used. It explores the causes of this waste, such as lack of planning, changing requirements, and technical debt, and suggests ways to reduce waste through better management practices and a focus on delivering value.

Containarium is an open-source platform that provides a standardized approach to container-based software development and deployment. It aims to simplify the management and orchestration of containerized applications, enabling efficient and scalable software delivery.

I (17y/o) have been developing a rocket launch simulation that allows the user to explore what it's like launching a rocket from earth and putting it into orbit. This idea originally started as an educational simulation but as i've gone more down the rabbit hole the more i've wanted to make it realistic. The problem is that I've never had a formal orbital mechanics class or anything like that so I don't know what I'm missing, what I currently have implemented is:

  Variable gravity
  Variable Atmospheric drag (US Standard Atmosphere 1976)
  Multi-stage rockets
  Closed-loop guidance / pitch programs (works well within ranges 350km to 600km)
  Orbital prediction and thrusting options to change your orbit.

Current code and physics can be found at: https://github.com/donutTheJedi/Rocket-Launch-Simulation

Hey - I've been playing with LLMs since GPT-2 and recently experimented with fully generative UIs where the HTML/Canvas are generated just-in-time.

Every post on the feed( on slop/duck/storytime) you see is streamed and generated just-in-time with HTML and into a Canvas with Gemini 3 Flash.

Comments and DMs are bidirectionally linked with a Cloudflare Workers Durable Object which is why they feel so fast. Every generated post is saved into a DO SQLite which is then served into the "Following" feed so it can be served quicker.

This was inspired by Wikitok, a VSCode Extension I made around brainrot, and another fully generative UI site I made.

GitHub profile analysis - Build your embedding from your Stars - Compare and discover popular people with similar interests and share yours - Generate a Skill Radar - Recommend repositories you might like

The article introduces miditui, a Python library that provides a graphical user interface (GUI) for working with MIDI data, allowing users to easily visualize and edit MIDI files without needing to write complex code.

Hi HN, I'm Kai Wang, one of the creators of Yuanzai World.

We built a simulation engine (currently on iOS & Android) that allows the community to create and share text adventures populated by multiple LLM-based agents. Unlike standard chatbots, our focus is on community co-creation—users define the worldviews, and our agents (with persistent memory and social relationships) bring them to life.

The cool part:

We implemented a system we call "World-Line Divergence" (inspired by visual novels like Steins;Gate). Usually, AI RPGs feel random or infinite loop. We built a state machine that tracks "World Deviation." If players interact with NPCs in specific ways (e.g., convincing an artist to change their style), it triggers a graph switch, leading to a completely different generated ending, effectively breaking the original script.

Tech Stack:

- Backend: Python / Java with a custom AI orchestration framework (to handle agent concurrency).

- Models: Hybrid routing between Gemini, GPT, and DeepSeek (optimizing for cost/performance based on task).

- Vector DB: Milvus (for handling long-term agent memory).

We are currently live on App Store and Google Play. Since it's a mobile-first experience, the link leads to our landing page where you can see the demo flow.

Would love to hear your feedback on the "World-Line" concept: Does this state-machine approach solve the aimlessness of AI RPGs?

I deal with a lot of geometry stuff at work with computer vision and photogrammetry, which usually comes from the real world. It's seldom clean and neat, and I'm often trying to find a way to "make it nice" or "make it pretty". I've always struggled with what that really means formally.

That led me to shape regularization (a technique used in computational geometry to clean up geometric data). CGAL had implemented a few methods for that, but there are more ways to do it, which I thought were nice. Also I typically work in Python, so it was nice to have a pure Python library could handle this.

I struggled to get the first version working as a QP. At a high level most of these boil down to minimizing a cost A + B where A is the cost associated the geometry and goes up the more you move it, and B is the cost associated "niceness" or rather the constraints you impose, and goes down the more you impose them. Then you try and minimize A + B or rather HA + (1-H)B where H is a hyper-parameter that controls the relative importance of A and B.

I needed a Python implementation so started with the examples implemented in CGAL then added a couple more for snap and joint regularization and metric regularization.

Hi HN, I built this side project earlier this week. It executes an English auction on Solana with a reserve price of 0.1 SOL. Auction winner gets control of a Codex editor. Auction losers get refunded (minus a <$0.01 processing fee). The Codex agent operates in a sandbox and can only output HTML/JS/CSS.

The project is open-source: https://github.com/neelsomani/the-daily-auction

I built this as a personal open-source project to explore how EU AI Act requirements can be translated into concrete, inspectable technical checks.

The core idea is local-first compliance: – risk classification (Articles 5–15, incl. prohibited use cases) – bias evaluation using CrowS-Pairs – automatic Annex IV–oriented PDF reports – no cloud services or external APIs (browser-based + Ollama)

I’m especially interested in feedback on whether this kind of technical framing of AI regulation makes sense in real-world projects.

I wanted to run markdown files like shell scripts. So I built an open source tool that lets you use a shebang to pipe them through Claude Code with full stdin/stdout support.

task.md:

    #!/usr/bin/env claude-run

    Analyze this codebase and summarize the architecture.

    chmod +x task.md

    ./task.md

A script that runs your tests and reports results (`run_tests.md`):

    #!/usr/bin/env claude-run --permission-mode bypassPermissions

    Run ./test/run_tests.sh and summarize what passed and failed.

    cat data.json | ./analyze.md > results.txt

    git log -10 | ./summarize.md

    ./generate.md | ./review.md > final.txt

    for f in logs/\*.txt; do

        cat "$f" | ./analyze.md >> summary.txt

    done

One thing we didn't expect is that these are more auditable (and shareable) than shell scripts. Install scripts like `curl -fsSL https://bun.com/install | bash` could become:

    `curl -fsSL https://bun.com/install.md | claude-run`

The (really cool) executable markdown idea and auditability examples are from Pete Koomen (@koomen on X). As Pete says: "Markdown feels increasingly important in a way I'm not sure most people have wrapped their heads around yet."

We implemented it and added Unix pipe semantics. Currently works with Claude Code - hoping to support other AI coding tools too. You can also route scripts through different cloud providers (AWS Bedrock, etc.) if you want separate billing for automated jobs.

GitHub: https://github.com/andisearch/claude-switcher

What workflows would you use this for?

The article discusses a project called 'InfiniteGpu', which aims to create a system that can use multiple GPUs to provide infinite graphics processing power. The project explores ways to overcome hardware and software limitations to enable this scalable GPU architecture.

Hey all- I just released a New tab replacement Chrome extension that makes browsing a lot easier - it also solves many of the annoyances with browser tabs. It's called Yellopages and it's free. Hope you'll give it a try.

* Groups all tabs from same domain. Makes it simple to kill all your Gmail tabs in one click (or keep just one).

* Groups all tabs playing audio. Toggle the sound for each one.

* Single text search for open tabs, bookmarks, and browsing history.

* Groups all tabs with new notifications (e.g. emails, likes, posts, replies, etc.)

* One click to kill all tabs (e.g. you're sharing screen in Zoom). A second click brings them all back.

I'm a solo web developer and I'm hoping to build an audience with my work. More at: https://buymeacoffee.com/kawaicheung

I built a macOS menu bar app to track Claude usage in real time via API after hitting limits mid-flow too often.

Signed and notarised by Apple. Open source.

https://github.com/richhickson/claudecodeusage

https://x.com/richhickson

Hi HN,

Package repositories don't need to be complicated. They're just static files: metadata indexes and the packages themselves. Yet somehow hosting your own feels like you need dedicated infrastructure and deep knowledge of obscure tooling.

repogen is an SSG for package repos. Point it at your .deb/.rpm/.apk files, it generates the static structure, you upload to S3 or any web host. Done. $0.02/month to host packages for your whole team.

It supports Debian, RPM, Alpine, Pacman, and Homebrew. Has incremental mode for updating repos without redownloading everything. Handles signing. Very alpha, but it works. Would love to get feedback!

The article explores the impact of the COVID-19 pandemic on the global economy, focusing on the fall of Apple's share price and the implications for the tech industry. It discusses the challenges faced by Apple and other tech companies in adapting to the changing market conditions.

Hey everyone, I made this thing: https://tryflux.ai/. Here's a demo video: https://screen.studio/share/1y2EnC26

Context: I've tried probably 15 different AI apps over the past year. ChatGPT, note-taking apps, productivity apps, all of it. But most of them are just clutter on my iphone.

They live in some app I have to deliberately open. And I just... don't. But you know what I open 50 times a day without thinking? iMessage. So out of mild frustration with the "AI app graveyard" on my phone, I built Flux.

What it does: - You describe a personality and what you want the agent to do - In about 2 minutes, you have a live AI agent in iMessage - Blue bars. Native. No app download for whoever texts it.

The thesis that got us here: AI is already smart enough. The bottleneck is interaction. Dashboards get forgotten. Texts get answered.

This was also my first time hitting #1 on Product Hunt, which was surreal.

It's still rough and probably broke something. If you try it, feedback is super welcome, weird edge cases, "this doesn't work," or "why would anyone use this" comments all help.

That's all. Happy to answer questions.

I built this as a personal replacement for Kiwi Browser, since it is now archived.

It brings Chrome extensions to Android. I just wanted something that works fast and feels right for daily use.

If Firefox and Edge just don't feel right on Android, and you prefer Chromium but are too lazy to maintain your own fork, this might be the answer. Just don't expect too much—I really just built this for myself.

P.S. I realized the name clash with Elixir lang after finishing it. Well, whatever.

I built a dedicated roleplay chat UI for abliteration.ai: https://abliteration.ai/roleplay

The backend is OpenAI-compatible (/v1/chat/completions), with usage-based pricing and no prompt/output retention by default (details on the site). The UI is meant for long-form character chats and interactive fiction, without needing a local frontend.

Docs (including a roleplay backend guide and a SillyTavern integration guide): https://abliteration.ai/docs

Would love feedback on missing RP features, UX rough edges, and what you would expect from a roleplay-first interface.

I forked a PyTorch DeepDream implementation and added video support with temporal consistency. It produces smooth DeepDream videos with minimal flickering, and is highly flexible including many parameters and supports multiple pretrained image classifiers including GoogLeNet. Check out the repo for sample videos! Features:

- Optical flow warps previous hallucinations into the current frame

- Occlusion masking prevents ghosting and hallucination transfer when objects move

- Advanced parameters (layers, octaves, iterations) still work

- Works on GPU, CPU, and Apple Silicon

VibeOS is a retro operating system that boots on qemu and Pi Zero 2W. I built this with Claude code in about 4 weeks.

Each moving arrow represents one real bike ride out of 291 million, and if you've ever taken a Citi Bike before, you are included in this massive visualization!

You can search for your ride using Cmd + K and your Citi Bike receipt, which should give you the time of your ride and start/end station.

Everything is open source: https://github.com/freemanjiang/bikemap

Some technical details: - No backend! Processed data is stored in parquet files on a Cloudflare CDN, and queried directly by DuckDB WASM

- deck.gl w/ Mapbox for GPU-accelerated rendering of thousands of concurrent animated bikes

- Web Workers decode polyline routes and do as much precomputation as possible off the main thread

- Since only (start, end) station pairs are provided, routes are generated by querying OSRM for the shortest path between all 2,400+ station pairs

The article explores the growing popularity of outdoor adventure tourism, particularly climbing expeditions to remote and challenging mountain locations. It discusses the logistical and safety considerations involved in organizing and executing these types of adventures, as well as the appeal for participants seeking unique experiences and personal growth.

PostgresGUI is a graphical user interface (GUI) tool that provides a user-friendly way to interact with PostgreSQL databases. It offers features like database management, data manipulation, and SQL execution, making it easier for developers and database administrators to work with PostgreSQL.

The article discusses the author's experience of designing an overly complex Dungeons & Dragons character sheet, highlighting the balance between functionality and simplicity in game design and application development.

My name is Adrian. I'm a Software Engineer and I spent 6 years developing a perimeter-based geofence-based social media app.

What it does:

- Allows you to load a custom perimeter anywhere on the geographic map (180° E and W longitude and 90° N and S latitude), to cover area any area of interest

- Chat rooms get loaded within the perimeter

- You can chat with people within the perimeter

I developed a mobile app that uses an advanced geofence-based networking system from 2013 to 2019. My goal was to connect users within polygon geofences anywhere in the world. The app is capable of loading millions of polygon geofences anywhere in the world.

https://enterpriseandroidfoundation.com/assets/images/other/...

But people didn't really have a need for this. So after failing, I spent the next 6 years trying new ideas to use FencedIn for. I tried a location-based video app and a place-based app that had multiple features. Nothing worked, but now I'm almost finished developing ChatLocal, an app that allows you to load a perimeter anywhere on the geographic map, which loads chat rooms.

The tech stack is 100% Java (low-level mostly). I have a backend, commons library and an Android app. Java was the natural choice back in 2013. However, I still wouldn't choose anything else today. Java is the best for long-term large-scale projects. (I'm also using WildFly. PostgreSQL and a Linux server.)

This app is still not fully finished, but I think the impact on society might be tremendous.

The previous app to ChatLocal, LocalVideo, is fully up on the Google Play store and can be tested. It has 88% of the features of ChatLocal, including especially the perimeter-based loading system.

The feedback I'm mostly looking for is new ideas and concepts to add to this location-based social media app. And how strong of a value proposition does the app have for society.

A fast SOCKS5 proxy that tunnels your traffic through what looks like normal SMTP email, bypassing Deep Packet Inspection firewalls.

How it works: - Client runs a local SOCKS5 proxy (127.0.0.1:1080) - Traffic is sent to server disguised as SMTP (EHLO, STARTTLS, AUTH) - DPI sees legitimate email session, not a VPN/proxy

Features: - One-liner install on any Linux VPS - Multi-user with per-user secrets and IP whitelists - Auto-generated client packages (just double-click to run) - Auto-reconnect on connection loss - Works with any app that supports SOCKS5

Tech: Python/asyncio, TLS 1.2+, HMAC-SHA256 auth

GitHub: https://github.com/x011/smtp-tunnel-proxy

Hey HN! I built Topic2Manim to automate the creation of educational videos like those from 3Blue1Brown.

The workflow is simple:

1. Give it any topic (e.g., "how ChatGPT works")

2. An LLM generates an educational script divided into scenes

3. LLM generates Manim code for each scene

4. FFmpeg concatenates everything into a final video

Currently working on TTS integration for narration!

Would love feedback on the approach and ideas for the TTS integration