Show stories

AI prediction experiment inspired by recent submissions from dosaygo-studio https://news.ycombinator.com/from?site=dosaygo-studio

Hey HN,

GitHub has hundreds of wallpaper repositories with thousands of images, but actually browsing them is painful. You either clone gigabytes locally or click through the file browser one by one.

So I built WALL·E Gallery. Use existing collections or Paste a repo URL→ instant gallery.

How it works: - Fetches repo tree via GitHub (no cloning) - Proxies thumbnails (~50KB instead of 10MB originals) - Works with private repos too (with GitHub token)

Infinite scroll, search, dark mode, mobile friendly, self-hostable. No accounts, no tracking.

Live: https://walle.theblank.club Source: https://github.com/amitray007/wall-e

Do share your suggestions/feedback. Also, I did find my desktop wallpaper from this.

I built a CLI tool that lets you do common video/audio operations without remembering ffmpeg syntax.

Instead of: ffmpeg -i video.mp4 -vf "fps=15,scale=480:-1:flags=lanczos" -loop 0 output.gif

You write: ff convert video.mp4 to gif

More examples: ff compress video.mp4 to 10mb ff trim video.mp4 from 0:30 to 1:00 ff extract audio from video.mp4 ff resize video.mp4 to 720p ff speed up video.mp4 by 2x ff reverse video.mp4

There are similar tools that use LLMs (wtffmpeg, llmpeg, ai-ffmpeg-cli), but they require API keys, cost money, and have latency.

Ez FFmpeg is different: - No AI – just regex pattern matching - Instant – no API calls - Free – no tokens - Offline – works without internet

It handles ~20 common operations that cover 90% of what developers actually do with ffmpeg. For edge cases, you still need ffmpeg directly.

Interactive mode (just type ff) shows media files in your current folder with typeahead search.

npm install -g ezff

I'm sharing a project I've maintained for two years: a powerful Word plugin called Word-GPT-Plus. It integrates modern AI and agent capabilities directly into your document workflow. I recently completely rewrote the project with a modern UI and added an "Agent Mode" for handling complex, multi-step tasks within Word and multiple tools like web fetch/search, document manipulate can be used by LLM. Feedback and criticism are very welcome!

Repo: https://github.com/Kuingsmile/word-GPT-Plus

I wrote a type checker (minfern - https://github.com/sinelaw/minfern) for a subset of javascript with no transpilation. It accepts valid JS as input and allows a subset of JS code to pass the checking. There’s no transpilation or compilation needed. The input code can be run directly.

Try it online at: https://sinelaw.github.io/minfern/

It could be used for checking code targeting normal JS runtimes, or runtimes like mquickjs (though minfern is more strict but also allows things like ‘const’ which mquickjs doesn’t). minfern is based on the type system for Infernu, which I wrote back in 2015, but is less hacky and has a cleaner implementation.

Very simple example:

  function calculateTotal(product, quantity) {
    return product.price * quantity;
  }
  var item = {
    name: "Wireless Mouse",
    cost: 25 // Note the property name is 'cost', not 'price'
  };
  console.log(calculateTotal(item, 2));

  Error: Property 'price' not found in type {cost: Number, name: String}
      ╭─[ tests/example_error.js:11:13 ]
      │
   11 │ console.log(calculateTotal(item, 2));
      │             ───────────┬───────────  
      │                        ╰───────────── Property 'price' not found in type {cost: Number, name: String}
  ────╯

- Full type inference with principle typing, support for type annotations

- Parameteric polymorphism (aka “generic functions”)

- Structural typing with row-type polymorphism

- Object method typing with equi-recursive types (for self/“this”)

- Polymorphic object methods (still considered rank-1)

- Basic constraints “Plus a” and “Indexable a” to allow + and [] to apply to different types like numbers, strings, arrays.

This allows a subset of JS expressions to be checked.

Some JS idioms are not allowed by this system:

- No union types (design choice) - return values, variables, arrays, etc must have a single type. Currently it doesn’t support returning null/undefined either, this can be fixed in the future by adding Optional as a type, but makes principle typing harder.

- No sum types (yet) - this explains why I haven’t added Optional<T>, I think sum types will fit in the type system and are doable. Once added also enums could be expressed.

- Value restriction forbids reassigning to polymorphic variables after declaration (ML-style).

- As a result of the above - can’t use && / || operators like some people do in JS. The operators are required to have the same type on both sides (no allowing “undefined” on one side)

- No type coercion, converting a number to a string (for example) requires using String() constructor.

- And probably other limitations that people might see as a limitation rather than a feature of the type system.

Disclaimer: this type checker comes with NO WARRANTY. I am not a language expert. I didn’t prove soundness, and would love someone who’s an expert to look at it. That being said - it looks correct on all the tests I’ve tried. It’s based on HMF and other published type systems but combines things in a different way.

GitHub: https://github.com/sinelaw/minfern

I had a post in the start of December about Postgresus 2.0: self hosted tool for PostgreSQL. Since then the project changed the name and added support of other databases: MySQL, MariaDB and MongoDB.

Website - https://databasus.com

GitHub - https://github.com/databasus/databasus

Main features:

- Scheduled backups for multiple PostgreSQL, MySQL, MariaDB and MongoDB databases

- Storage to S3, Cloudflare R2, Google Drive, Azure Blob, NAS, SFTP, rclone, etc.

- Notifications about backup status via email, Telegram, Slack, Discord, MS Teams and customizable webhooks

- Works with both self-hosted and managed PostgreSQL (RDS, Cloud SQL, etc.)

- Runs as a single Docker container or via Helm on Kubernetes, can be installed via script

- There are workspaces and role-based access with audit logs

Hey HN! I'm Baha, creator of Mysti.

The problem: I pay for Claude Pro, ChatGPT Plus, and Gemini but only one could help at a time. On tricky architecture decisions, I wanted a second opinion.

The solution: Mysti lets you pick any two AI agents (Claude Code, Codex, Gemini) to collaborate. They each analyze your request, debate approaches, then synthesize the best solution.

Your prompt → Agent 1 analyzes → Agent 2 analyzes → Discussion → Synthesized solution

Why this matters: each model has different training and blind spots. Two perspectives catch edge cases one would miss. It's like pair programming with two senior devs who actually discuss before answering.

What you get: * Use your existing subscriptions (no new accounts, just your CLI tools) * 16 personas (Architect, Debugger, Security Expert, etc) * Full permission control from read-only to autonomous * Unified context when switching agents

Tech: TypeScript, VS Code Extension API, shells out to claude-code/codex-cli/gemini-cli

License: BSL 1.1, free for personal and educational use, converts to MIT in 2030 (would love input on this, does it make sense to just go MIT?)

GitHub: https://github.com/DeepMyst/Mysti

Would love feedback on the brainstorm mode. Is multi-agent collaboration actually useful or am I just solving my own niche problem?

Repo: https://github.com/valdanylchuk/xcc700

Hi Everyone! I just wrote my first compiler!

- single pass, recursive descent, direct emission

- generates REL ELF binaries, runnable using ESP-IDF elf_loader

- very basic features only, just enough for self-hosting

- treats the Xtensa CPU as a stack machine for simplicity, no register allocation / window usage

- compilable on Mac, probably also Linux, can cross-compile for esp32 there

- wrote for fun / cyberdeck project

Sample output from esp32:

    xcc700.elf xcc700.c -o /d/cc.elf
    
    [ xcc700 ] BUILD COMPLETED > OK
    > IN  : 700 Lines / 7977 Tokens
    > SYM : 69 Funcs / 91 Globals
    > REL : 152 Literals / 1027 Patches
    > MEM : 1041 B .rodata / 17120 B .bss
    > OUT : 27735 B .text / 33300 B ELF
    [ 40 ms ] >> 17500 Lines/sec <<

Hi HN,

I built a small Linux CLI tool called witr (Why Is This Running?).

The idea came from a situation most of us have hit: you log into a machine, see a process or port running, and immediately wonder why it exists, who started it, and what is keeping it alive right now.

witr traces a process, service, or port back to its origin and responsibility chain and explains it in a way that’s quick to read, especially when you’re debugging under pressure.

This is v0.1.0. It’s intentionally small and focused. Feedback, criticism, and edge cases are very welcome.

Repo: https://github.com/pranshuparmar/witr

This began as a passion project and an opportunity to learn new tech.

I've always experienced frustration developing APIs, especially the RESTful CRUD style of data APIs. It always felt like I was repeating the same patterns over and over again, and that was tedium I didn't want. A little over a year ago, I wanted to learn more about Go, Firecracker microVM, and Svelte and thought "Could I build an API framework that was just a simple description of resources? What would that look like?"

That lead me to https://firecracker-microvm.github.io/, which landed me on https://fly.io, then https://rqlite.io, and the further I got into it, the more I really liked what I had. It's been over a year of learning and trying out all forms of tooling, CLIs, LSPs, and finally I landed on this.

So I decided to try my hand at making this a product. I'd really enjoy feedback about it and whether it's something folks would use. Here's hoping others feel the way I do about APIs and the developer experience building them!

I wanted to share this fun craft activity for the holidays that I've been doing with my family over the last few years. I came up with these while cutting up some cans trying to make an aluminum version of paper spinners.

There are a variety of shapes that work, but generally bigger+lighter spinners are better. Also incandescent bulbs are the best, but LEDs work too.

They remind me of candle carousels I would see at my grandparents' house during Christmas. Let me know what you think!

Hello HN,

I’m a hobby music producer with a changing studio setup and got tired of losing track of what’s patched where (especially after gear swaps).

I built PatchMyGear, a website to map audio setups / routing and generate a cable list + wiring checklist, save / load locally. (no signup)

Let me know what you think. Happy holidays!

Hi HN,

I’ve been working on Gaming Couch, a web-based game platform where up to 8 players use their smartphones as controllers to play real-time action mini-games on a central browser screen.

TL;DR:

- 18 competitive mini-games for up to 8 players

- Runs entirely in the browser

- Phones act as controllers (no apps, no accounts required)

- Focused on fast, chaotic, real-time party games (no trivia)

- Currently in public early access

Try it here: https://gamingcouch.com. Open the link on a computer, host a session, scan the QR code with your phone(s) and play!

What is it?

Gaming Couch is a party game platform where friends play short competitive action games together on one screen, using their phones as controllers (there's also support for physical gamepads if that's more your thing!)

I intentionally avoided trivia and text-heavy games. Many people don’t write or read English fluently, and I wanted games where reaction, timing, and chaos matter more than spelling.

It’s currently in early public access with 18 mini-games, all made by me and a two friends. All game rounds last ~1 minute, scores carry over, and after each round players vote on the next game. If you’re solo, 3 games support bots, but it’s best with a full couch of people as half the fun comes from the social aspect of playing together!

Why I built it:

For the last 15+ plus years, me and my friends have loved video game nights but organizing them has always been a PITA when you have more than 4 people playing:

- Different games were under different Steam accounts requiring downloads and installation.

- Extra controllers were missing (somebody forgot to bring theirs) or they wouldn’t pair.

- Consoles were expensive and not always available if we were on the road.

Once I started building it, other dev friends asked if they could make games for it too, which led me to realize this could also be a platform for small party games, especially for gamejam devs who don’t want to or have time to build multiplayer infrastructure from scratch. This is why supporting third-party games is the next major feature I’m working on.

Tech stack:

- Games run locally in the host’s browser (no streaming of games)

- Phones connect via WebRTC to the host session (1–10ms latency in ideal conditions with P2P connection)

- Fallback to TURN when direct P2P connection isn’t possible e.g. due to strict firewall settings in corporate networks or use of VPN's

- Website/Platform made with React + TypeScript

- Existing games made with Unity or just plain JS/TS.

- Backend: Supabase (Postgres + auth only, currently only used for optional user accounts)

How is it different from e.g. Jackbox, Airconsole or Nintendo?

Jackbox is absolutely great, but it’s heavily dependent on English literacy and "being funny" on the spot. I wanted something focused on fast, chaotic, real-time action games that work even if your friends speak different languages or just want to smash buttons. Also, I'm not a fan of their party pack model...

AirConsole is the most well known comparison to Gaming Couch in terms of technology and execution, but I feel there is a gap for a curated experience where the UI is unified, rounds are 60 seconds, and the competitive "meta-game" (scoreboards/voting) is baked into the platform. And in any case AirConsole was acquired by a car-software company and have pivoted their focus from couch gaming toward in-car entertainment.

Nintendo games are usually the gold standard in the party game category but the HW and games cost so much! With Gaming Couch, I want to keep the accessibility threshold as low as possible so everyone is able to play without upfront HW or SW costs.

What do you think of this? Are you an interested player or perhaps a developer who has had an idea to develop a fun 8 player mini-game but has been daunted by the idea thus far?

i've been a big fan of fedora's atomic distros and i decided to make my own but arch based to get the best of both worlds, which is kind of funny now because it looks exactly like silverblue. is it worth it? not sure, but it's been a interesting experience – and it's usable as a daily driver if your specs match.

worth noting that because of the constraints of the setup you can develop something similar on your main machine without any realistic possibility of data loss since you never really touch the bootloader or the filesystem (partitioning and so on).

I made a web game inspired by Geoguessr and Wordle, where you get shown a 3D model of a random human protein each day, and you have to triangulate its gene name using similarity clues.

My background is in wet lab molecular biology and I intend this game to be engaging mostly to other biologists. But if you're outside the field, I'm interested to know if you can still solve it with browser use LLMs, and if you learned something interesting doing so. Let me know what you think.

I made it with Claude over the last 2 months. My coding experience is limited to basic python data analysis and figure making. I've seen people online asking, "Now that we have coding AI, why isn't there a deluge of awesome AI-generated apps made by non-coders?" - if this sounds like you, check out Geneguessr to understand what a web app by a non-coder looks like.

I might write more about the process if there's a demand, but what really unlocked the project for Claude was Linear MCP, where it could put each individual issue on a shared Kanban board. This, and Playwright MCP for testing on live site, were the two workhorses that got me through this. For bugs Claude couldn't one-shot, Linear was great for consolidating issue information so that I could dump it into ChatGPT Codex - it would usually think for like half an hour, output very confusing explanations, but the bug was gone.

Game is free, no log-in required, sorry if you run into any mobile bugs - didn't test it much there.

https://geneguessr.brinedew.bio/

The article introduces Jsonic, a Python library that simplifies JSON serialization and deserialization. It highlights Jsonic's ease of use, performance, and flexibility compared to the built-in JSON module in Python.

I had a problem with keeping focus on opencode terminal when it was doing tasks longer than ~30 seconds, so I built a small plugin that sends telegram notification to ping me when agent finishes.

Setup:

1. Send /start to the bot

2. Execute bash command that the bot sends you back. You can see source code of the script here [1] and the built plugin here [2].

3. Done! Whenever your agent finish, you will get message with project name, session title and duration of the agent work.

I decided to make it available to everyone on my free tier of cloudflare workers, but it's fully hostable on your own cloudflare accounts or even docker containers on custom infra with few minor changes in the code.

Development was done mostly by Claude Opus 4.5 and custom agents in opencode.

[1] https://github.com/Davasny/opencode-telegram-notification-pl...

[2] https://github.com/Davasny/opencode-telegram-notification-pl...

I wanted to see how far I could go building a notes app using only what modern browsers already provide – no frameworks, no storage APIs, no build step.

What it does:

Single HTML file, no deps, 111 loc

Notes live in the URL hash (shareable links!)

Auto-compressed with CompressionStream

Plain-text editor (contenteditable)

History support

Page title from first # heading

Respects light/dark mode

No storage, cookies, or tracking

The entire app is the page source.

https://textarea.my/

I made this for my wife, who’s a big Stranger Things fan, to keep her entertained while we wait for the final episode coming out in a few days.

Built in ~2 hours. It’s a short clicker game (~15–20 minutes) and it actually ends.

I personally love the tree ui, if I spent more time i'd definitely improve the performance and replace those emojis with actual images.

OP here. I've been trying to "build in public" recently, but I found that switching context from VS Code to Twitter/X just to write "Fixed a race condition" felt like friction. I often ended up posting nothing because translating code-diffs to human-readable text takes more mental energy than fixing the bug.

I built Git to Tweet to automate this loop.

How it works:

It hooks into your GitHub repo (via OAuth).

It pulls the metadata and diff summaries of your recent commits.

It passes the diff through a specifically tuned prompt (to avoid generic "AI slop") that extracts the intent of the code change rather than just listing file names.

It generates a draft that you can edit before posting.

The Tech Stack:

Frontend: React + Framer Motion (spent way too much time on the "terminal" animations you see on the landing page).

Backend: Node.js/Supabase.

LLM: Currently testing models to see which is best at understanding code context without hallucinating features.

The landing page includes an interactive simulator (hardcoded scenarios for now) if you want to see how the "translation" logic works without connecting a repo.

I’m curious if others find this "translation" layer useful, or if you prefer manual changelogs? Feedback on the diff parsing accuracy would be awesome.

URL: https://landkit.pro/git-to-tweet

i started the selenium project 21 years ago. vibium is what i'd build if i started over today with ai agents in mind. go binary under the hood (handles browser, bidi, mcp) but devs never see it. just npm install vibium. python/java coming. for claude code: claude mcp add vibium -- npx -y vibium v1 ships today. ama.

HookVerify is a platform that provides webhook verification and management services, allowing developers to securely receive and validate webhook notifications from various services.

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 built CineCLI — a cross-platform terminal app to browse movies, view details, and open torrents directly in your system torrent client.

Features: - Search movies from the terminal - Rich UI with ratings, runtime, genres - Interactive & non-interactive modes - Magnet handling via system default client - Linux/macOS/Windows support - No ads, no tracking

GitHub: https://github.com/eyeblech/cinecli PyPI: https://pypi.org/project/cinecli/

Would love feedback from terminal + Python folks

I built InsideStack to make it easier to find high-quality technical and software articles.

Why? - The web is flooded with AI-generated content - Businesses are publishing tons of articles with biased content - Search results are often driven by engagement rather than quality. - AI-generated summaries of articles don’t drive traffic back to the original creators

InsideStack lets you: - Search across curated RSS feeds with semantic search - Subscribe, bookmark, and follow topics or authors

Currently, only a small set of feeds is included, but I am adding more every day. Suggestions for high-quality RSS feeds and any feedback are very welcome!

Hey everyone, I made another bedside clock, because my last one was getting a bit long in the tooth. This is a very straightforward build, because it turned out you don't need to mess with the AliExpress-bought hardware, so you can easily make your own!

Hey HN,

I’ve been building agents recently, and I hit a problem: I fell asleep while a script was running, and my agent got stuck in a loop. I woke up to a drained OpenAI credit balance.

I looked for a tool to prevent this, but most solutions were heavy enterprise proxies or cloud dashboards. I just wanted a simple "fuse" that runs on my laptop and stops the bleeding before it hits the API.

So I built AgentFuse.

It is a lightweight, local library that acts as a circuit breaker for LLM calls.

Drop-in Shim: It wraps the openai client (and supports LangChain) so you don't have to rewrite your agent logic.

Local State: It uses SQLite in WAL mode to track spend across multiple concurrent agents/terminal tabs.

Hard Limits: It enforces a daily budget (e.g., stops execution at $5.00).

It’s open source and available on PyPI (pip install agent-fuse).

I’d love feedback on the implementation, specifically the SQLite concurrency logic! I tried to make it as robust as possible without needing a separate server process.