2026年1月9日 の Show HN

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.

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.

The feedback I'm looking for is: UI improvements and possible future physics implementations that I can work on.

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

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.

Then:

chmod +x task.md

./task.md

These aren't just prompts. Claude Code has tool use, so a markdown file can run shell commands, write scripts, read files, make API calls. The prompt orchestrates everything.

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.

Because stdin/stdout work like any Unix program, you can chain them:

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

git log -10 | ./summarize.md

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

Or mix them with traditional shell scripts:

for f in logs/*.txt; do

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

done

This replaced a lot of Python glue code for us. Tasks that needed LLM orchestration libraries are now markdown files composed with standard Unix tools. Composable as building blocks, runnable as cron jobs, etc.

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`

Where install.md says something like "Detect my OS and architecture, download the right binary from GitHub releases, extract to ~/.local/bin, update my shell config." A normal human can actually read and verify that.

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?

Shape regularization is a technique used in computational geometry to clean up noisy or imprecise geometric data by aligning segments to common orientations and adjusting their positions to create cleaner, more regular shapes.

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.

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.

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 a free, no-registration noise evidence generator for tenant noise complaints.

Features: - Supports 27 US cities with accurate noise ordinances - Real-time recording + professional court-ready PDF reports - 100% local processing (no data upload, privacy-first) - Auto day/night noise limit detection - Completely free (10 PDF generations/day)

Why: As a tenant dealing with noise issues, I was frustrated that existing tools either required subscriptions or uploaded data to servers. This tool is: - Totally free, no hidden costs - No registration or installation required - All processing happens locally on your device

Website: https://noiseevidence.com

Feedback welcome!

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.

Hi HN,

I’m experimenting with commit-based code review as an alternative to PR-based review.

Instead of analyzing large PR diffs, this reviews each commit incrementally, while context is still fresh. It’s fully configurable and intentionally low-noise, high signal - focused on catching issues that tend to slip through and compound over time.

The goal isn’t to replace CI or PR review, but to move some feedback earlier:

risky changes hidden in small diffs

architectural or consistency drift

performance or security footguns

Happy to answer questions

Hi HN,

I’m the author of agent-contracts, a Python library that explores a contract-based approach to structuring LangGraph agents.

When building larger LangGraph-based systems, I kept running into the same issues: - node responsibilities becoming implicit - state dependencies spreading across the graph - routing logic getting harder to reason about - refactoring feeling increasingly risky

agent-contracts is an attempt to make these boundaries explicit. Each node declares a contract that describes: - which parts of the state it reads and writes - what external services it depends on - when it should run, using rule-based conditions with optional LLM hints

From these contracts, the LangGraph structure can be assembled in a more predictable and inspectable way.

This is still early-stage and experimental. I’m mainly interested in feedback on the design trade-offs and whether this mental model resonates with others building complex agent systems.

Wall Street pays up to $3k/mo for terminals. They have access to better & faster datea, that's why they win.

The playing field is changing...

We built a Wall Street terminal for independent traders and investors.

Real-time breakouts, smart money tracking, AI-powered analysis, Congress trades...

All in one place, at a fraction of the cost.

Hi HN,

I rebuilt my side project into a small “all-in-one” image toolbox: https://imagesplitter.tools

The part I’m most proud of (and personally use the most) is the collage workflow:

1. Grid collage (templates + merge cells for “one big + many small” layouts)

2. Long-image stitching (great for screenshots / step-by-step guides / chat logs)

3. Freeform collage (DIY your own grid layout — split/merge cells however you want — then apply that layout to the grid collage)

My motivation was pretty simple: I kept bouncing between different sites for basic image chores, and many of them add watermarks, require login, or feel sketchy for privacy. So I made this with a few strict rules:

1. Free, no watermark 2. Privacy-first: processing happens locally in the browser (no upload/storage)

Besides collages, it also includes common utilities I often need:

crop (free/aspect/circle/shape), grid split + ZIP export, batch convert (JPG/PNG/WebP/ICO…), compress, images→GIF, text/markdown/html→image, QR generate/decode, color picker, image info, etc.

I’d really love feedback:

1) What’s the most annoying part of making collages / long images?

2) Any “must-have” features you’d expect for this kind of tool?

Thanks for taking a look — happy to iterate based on your comments.

Hey HN,

I'm a solo developer from Nigeria. I built Quran Unlock - an app that blocks distracting apps (TikTok, Instagram, etc.) until you complete your daily Quran reading.

The idea came from my own struggle with phone addiction. I wanted to read Quran daily but kept getting distracted. So I built this for myself, then shared it.

Some stats after 2 months: - 123K+ users - 64.9% returning user rate - 31M events tracked

Tech stack: - React Native - Firebase (Auth, Firestore, Analytics, Cloud Messaging) - RevenueCat for subscriptions - iOS Screen Time API + Android UsageStats

App Store: https://apps.apple.com/app/quran-unlock/id6754449406

Play Store: https://play.google.com/store/apps/details?id=com.app.quranu...

Would love feedback from the HN community!

Hi HN, Martin, Nils, and Jannes here.

We are building Legit, an open source version control and collaboration layer for AI agents and AI native applications.

You can find the repo here https://github.com/Legit-Control/monorepo and the website here https://legitcontrol.com

Over the last years, we worked on multiple developer tools and AI driven products. As soon as we started letting agents modify real files and business critical data, one problem kept showing up. We could not reliably answer what changed, why it changed, or how to safely undo it.

Today, most AI tools either run without real guardrails or store their state in proprietary databases that are hard to inspect, audit, or migrate. Once agents start collaborating on shared data, you are often just crossing your fingers and hoping nothing goes wrong.

We noticed something interesting. Developers do not have this problem when collaborating on code, and agent like workflows took off there first. The reason is relatively simple. Git already solves coordination, history, review, and rollback.

That insight led us to build Legit. We bring Git style versioning and collaboration to AI applications and to most file formats. Every change an agent makes is tracked. Every action is inspectable, reviewable, and reversible. No hidden state. No black box history.

Legit works as a lightweight SDK that AI apps can embed anywhere the filesystem works. It handles versioning, Sync, rollback, and access control for agens. Everything lives in a repository that you can host yourself or on any Git hosting provider you already trust.

We believe the right way to scale AI collaboration is not to hide what agents do, but to let developers and users see, review, and control every change. Legit is our attempt to bring the discipline, visibility, and safety of modern developer workflows to write enabled AI applications.

Give it a spin: https://github.com/Legit-Control/monorepo and let us know your feedback, criticism, and thoughts.

ping6.it can compare IPv4 vs IPv6 side by side, from the same probes.

You can run: - ping - traceroute - mtr - dns - http …and immediately see where v6 behaves differently (latency, loss, reachability, path).

Chris Wiles showcased his setup for Claude Code and I thought it was sick. So I adapted it for Django projects. Several skills have been added to address the pain points in Django development.

Fun agent I've been playing with - the idea is it only has access to a bash tool, and it's directed to create CLIs for use (with additional direction to make the CLIs composable, follow the Unix philosophy, etc).

It persists these CLIs and knowledge about them get injected into the system prompt dynamically, so each time it runs it gets access to a larger and larger toolset of composable CLIs.

One interesting dynamic that's emerged from this is I've started using these CLIs myself since they're the same interface for the agent or for me, and it's turned into kind of non-chat channel to interact with the agent.

One example - I'll add tasks throughout the day myself using the `tasks` CLI it made, then when I interact with the agent it'll run `tasks list` and see everything I've added, or use it to prioritize/update things for me. Later on when I run `tasks list` myself I see all the updates/priorities it set.

You can think of it as a memory toolbox. Memory is stored not only as vectors, but also as readable natural language, so everything you save remains visible. When needed, the system retrieves relevant memories and makes them available for reasoning.

This is an episode guessing game using Star Trek: The Next Generation (TNG) episode images as clues. This game has been a side project for a few years now. Finally got it to a point that it is worth showing. Hope you experiance some nostalgia and find some enjoyment out of it. Inspired by framed.wtf

Wanted a simple way to install command line tools released on GitHub without waiting for the repository owner to create and publish a Chocolatey package.

For now works for simple .zip releases based on Regex. The website simply replies to choco with a nupkg that essentially just says "install/update this release from GH".

If some package release is not being recognized or you want me to add support for MSI and other package types, post to https://github.com/GitCho-co/GitChoco/issues

I wrote a short playbook capturing behaviors I’ve seen in consistently effective developers. Posting it here in case it’s useful. Curious what others agree or disagree with.

Hi HN,

I built Layoffstoday, an open platform that tracks tech layoffs across ~6,500 companies.

What it does:

Aggregates layoff events from public news sources

Normalizes data by company, date, industry, and affected headcount

Shows historical patterns instead of isolated headlines

Why I built it: During job transitions, I noticed people had to jump across news articles, spreadsheets, and social posts just to answer simple questions like “Has this company laid people off before?” or “Is this happening across the industry?”

This is an attempt to make that information structured, searchable, and accessible.

Would love feedback on:

Data accuracy / gaps

Signals that would actually help job seekers

Whether alerts or trend indicators are useful or noisy

Hi HN! I built Image Scaler because I was frustrated with existing free online image tools. They either limit batch processing to a handful of images, require login/registration, or add watermarks. And they usually upload your images to unknown servers.

I originally made this for myself when I needed to resize large batches of product photos. I wanted something fast, lightweight, and privacy-respecting that could handle real workflow volumes without artificial restrictions.

What makes it different:

- Complete client-side processing using Canvas API, so images never leave your browser

- Batch processing up to 60 images simultaneously (most free tools cap at 3-10)

- No login, no watermarks, no usage limits

- Traditional interpolation algorithms (nearest-neighbor, bilinear, bicubic) instead of AI black boxes

- Supports JPG, PNG, and WebP

- Fast and lightweight (built with vanilla JavaScript)

Technical notes: The entire processing pipeline runs in your browser's Canvas API. There's no server upload step, which eliminates privacy concerns and makes it surprisingly fast even for large batches. I chose traditional algorithms over AI because they're transparent, predictable, and work well for most use cases (pixel art, web images, photo preparation).

Feel free to try it out: https://image-scaler.com

We're Tutor Intelligence, a robotics company building generally capable robot workers for American industry. We've been thinking about what technical evaluation should look like in a world where AI agents can 1-shot our hardest hour-long coding interviews, and this is one of our first experiments.

The challenge: command 5 robots in a 60x40 warehouse to fulfill 1000 orders. Your score is the number of timesteps to complete everything. Robots can move, pick items from pallets, dock to pallets (so they move together), and fulfill orders at the edge of the warehouse. Simple rules, but the optimization problem has surprising depth (it's NP-hard in about 10 different ways) with lots of room for strategy and creativity.

This is actually a simplified version of a real problem we work on. Warehouse coordination is one of those domains where the gap between a naive solution and a good one is enormous, and there are many valid approaches.

We built a web visualizer so you can see your solution play out, and a leaderboard if you want to submit. AI agent use is encouraged (probably necessary). So far only my cofounder and I have submitted, so we genuinely have no idea how good solutions can get.

Sharing this early because we'd love feedback on the problem design. And yes, we're hiring (that's why we made it): 70 people, Series A, based in Boston, founded out of MIT. But mostly just curious if others find this problem as interesting as we do.

I built Vect AI because I calculated that 80% of my startup's burn was going to "human latency"—waiting for agencies to deliver work I could have done myself if I had the time.

Vect AI is an Autonomous Marketing OS designed for high-leverage founders. It is not a "writing tool." It is a state-machine that:

Ingests your Brand DNA (Voice, Strategy, ICP). Monitors Market Signals (Real-time trends on Reddit/Search). Spins up Agents to execute the work (Full SEO clusters, Video Ads, Email sequences). It is designed to let a single founder output the volume of a 10-person Series A marketing team.

We are live. You can deploy your first agent for free.

I'm currently having slightly too much time and wanted to explore how much is possible to do with just 24h, iPad, ChatGPT and SSH to a Linux box.

The effect is Fujifilm Manager available at https://git.nakarmamana.ch/alfanick/fujifilm-manager (the Show HN is just a demo). It's a collection of bash scripts generating highly optimised static HTML/CSS/JS to display virtual "film rolls" made with Fujifilm X-half camera that I sometimes use (think of it as a digital version of infinite amount of disposable analog cameras). Initially it was just a personal project, as I am sitting a bit bored in a clinic, but I am happy to share.

I am a Linux, optimization and UX freak. So I wanted to see how much can be done with ChatGPT from an iPad from a hospital bed. I practically did not write a single line a code, but I did proper engineering - ChatGPT was basically my intern doing coding for me, with tens (hundreds?) of iterations.

The effect is: - a static webpage for previewing "film" rolls, - that uses progressive and lazy loading of highly optimised pictures (with heavy caching too), - with UI/UX optimised for mobile devices like iPhone/iPad, - that can be used to share memories with friends and family, - but also cat be used to improve the photographic skills with the critic mode (try "a").

More functionality is explained in the readme of the repository. I might be slow to respond, it is getting late here, but I am happy to reply when I am around.

I'm a Software Engineer who loves typography.

I love to dig fonts but none of the services satisfied my taste.

I wanted a program that:

- has an intuitive GUI

- let's you install fonts very easily (either with file or code)

- let's you swap elements with different fonts

- let's you detect the font actually displayed

So I built it myself. It's free, and no sign-in.

You can install it on Mac App Store: https://apps.apple.com/app/id6757154893

I have 1,323 bookmarks and exactly 2 tags so I created raindrip to fix my organizing skills in Raindrop.io.

After I threw an AI agent at the problem with raindrip, all my bookmarks were sorted nicely into folders and now I have 17 tags.

If you trust AI enough to sort your bookmarks, give it a try:

https://github.com/rinvii/raindrip

Technical details:

- Built with uv

- TOON by default (https://github.com/toon-format/toon)

- 99% test coverage and readable API error messages to help AI vibe it out

Completely rebuilt this app from the ground up following feedback from non-native speakers who shared that they wanted help improving the audio quality of their screen recordings. Stripe isn't even setup, so this is really about getting feedback from folks that want auto script generation and auto narration of their screen recordings. Thanks!

Hi HN,

I’ve released GoPico v1.0, a native Android app for running PICO-8 carts locally, with a focus on minimizing startup time, input latency, and rendering overhead compared to browser-based players.

The app executes carts on-device and is optimized specifically for mobile hardware.

Current scope:

~350 curated carts used for compatibility and performance validation

No ads, no accounts, no monetization

First public release

Planned next steps:

Physical controller support

Tuning for handheld devices

Broader compatibility and performance testing

If you try it, feedback is especially useful if it includes:

Device model and Android version

Any crashes, inaccuracies, or performance regressions

Game List: https://paste.rs/vVrKl.md

Community Discord(for bug reports): https://discord.gg/vRzyKKS9VY

I spent the last couple years maintaining a popular, public Helm chart. It was a struggle, and I very often heard many others complain about the similar struggles. It seems to be widely accepted that Helm chart maintenance is full of quirks and pitfalls. I wrote a lot of words about this on the blog post on the site.

I was always curious about how to improve that. In particular, I was curious about the idea of compiling a better, more structured language into a helm chart, to strike a balance between compatibility and maintainer experience. So I built helmtk and a new structured template language htkl, and some other tools along the way (the test suite in particular is super helpful).

(I'm actually planning to drop the hosted decompiler and just publish the prompts that back it, so if you're interested in that, send me an email at [email protected])

I built an AI assistant that runs completely in your browser using WebGPU. After the initial model download (~200MB-4GB depending on model choice), it works offline. No API keys. No subscriptions. No data leaves your device.

Browser-based local AI addresses this:

1. Works offline after first load – Local AI makes possible offline AI use. Resilience – Work continues even during outages. Affordability – No recurring cloud or bandwidth costs. Privacy – Data stays on the device, reducing exposure risks.

2. No paywall or subscription – Removing or reducing paywalls on essential AI tools is crucial. Promoting open-source AI platforms provides powerful tools to everyone at no cost, democratizing access to AI technology.

3. Democratizes creative tools – AI tools have the potential to democratize creative processes, making art and design tasks more accessible to individuals without traditional expertise. AI tools can act as equalizers, providing non-professional users with the means to execute complex projects and bring their visions to life.

4. Privacy for sensitive use cases – AI is an alternative way to empower and democratize the access to creative tools and resources by making it easier for individuals with varying levels of artistic skill or expertise to engage in creative expression.

What it does:

Text chat – Switch between 10+ models (SmolLM-360M to Llama 3.2 8B) Vision – Webcam/screen share analyzed by SmolVLM-256M running locally Voice – Whisper speech recognition (VAD-powered hands-free mode) TTS – Browser-native text-to-speech Image generation – SD Turbo via ONNX Runtime (experimental) Research mode – Multi-step research with optional web search Deep thinking – Chain of Thought, Tree of Thoughts, Reflexion modes

Requirements:

Chrome 113+, Edge 113+, Safari 26+ 4GB+ GPU memory for larger models One-time download, then cached/offline

LTX Video Generator is a beautiful, native macOS application built with SwiftUI. It harnesses the power of Apple Silicon to generate AI videos directly on your Mac using the LTX-Video model from Lightricks.

Key Features Apple Silicon Optimized - Leverages Metal Performance Shaders (MPS) for fast GPU-accelerated generation Intuitive Interface - Clean, native macOS design that feels right at home Generation Queue - Queue multiple videos and track progress in real-time Smart History - Browse, preview, and manage all your generated videos with thumbnails Flexible Presets - Quick access to common configurations or customize every parameter

Hi guys,

I was mad at all heavy slow loading postgres viewers, I ended up starting this. I don't really know much about neovim plugins but I wanted to take my changes. I have already started using it actively and there are a lot to do. Hope you will like it as well and waiting for your comments.

The Morning Struggle: Every night you promise yourself you'll wake up early, be productive, start that workout, finally tackle your goals. But morning comes and that alarm? It's just noise. You hit snooze, roll over, and another day slips away. You're not lazy - you're just tired of being tired.

The WakeCall Solution: What if your wake-up call felt like a friend who genuinely cares about your success? Someone who knows your name, your goals, and believes in you? Our AI doesn't just wake you up - it connects with you, motivates you, and starts your day with purpose.