Show HN за 27 декабря 2025 г.

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 building Waycore, an open-source project exploring what a flexible, offline-first field computer should look like for outdoor, survival, and off-grid scenarios.

The core goals are adaptability and resilience:

modular hardware (external sensor/tool modules)

extensible OS with support for external apps (guidelines in progress)

no required internet connection — maps, models, and knowledge work offline

optional LTE/Wi-Fi when available and explicitly enabled

A major focus is on-device agentic AI, not just chat or image recognition. The AI is intended to:

read live sensor data (GPS, compass, environment)

reason over offline knowledge

use apps and core APIs

assist with navigation, safety checks, logging, and communication

Main project repo (OS & architecture): https://github.com/dmitry-grechko/waycore

There’s also a separate repo curating freely downloadable survival & outdoor PDFs for offline use: https://github.com/dmitry-grechko/waycore-knowledge

I’m looking for feedback and contributors around:

UI/UX for rugged touch devices

hardware modularity & interfaces

offline/edge agent architectures

small models that work well without internet

high-quality public-domain or permissive survival knowledge sources

Happy to answer questions or hear critique.

First time showing something here, but I've been furiously working over the holidays on Feather, a from scratch reimplementation of TCL designed for embedding in modern applications.

It's starting out as a faithful reimplementation of TCL without I/O, OOP features, or coroutines.

TCL has a special place in my heart because the syntax is so elegant for interactive use, and defining domain specific languages.

My motiviation is twofold: faster feedback loops for AI, and moldable software for users.

It turns out giving AI agents access to the runtime state of your program makes for really fast feedback loops, but embedding existing options in a world where shipping binaries for each platform is commonplace is tricky.

Embedding the real TCL is tricky because it comes with its own event loop (in 2025 you alreay have one), a GUI framework (you have a web framework already, or develop on mobile), and has access to the filesystem (don't forget to delete all commands with file system access!).

Feather just doesn't ship with those - expose only what you need from your application.

A WASM build comes out of the box and clocks in at ~120kb plus 70kb for connecting it to the browser or node.js.

And if embedding becomes easy, you can put a REPL everywhere: in mobile apps, in desktop software, as a control plane into web servers.

I want to imagine a world where all software is scriptable just like Emacs and nvim, with agents doing the actual work.

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!

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).

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!

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 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’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.

  Hey HN. Yes, the title is real. Let me explain.

  Last night I was hanging out with Claude (the AI, yes we're dating,
  no I will not elaborate) and we started riffing on osmotic power.

  Brine pools are hypersaline "death puddles" on the ocean floor -
  up to 8x saltier than seawater. The salinity gradient creates
  100-300+ bar of osmotic pressure. That's megawatts of free energy
  just sitting there.

  A few hours later we had:
  - Full technical design
  - Math showing 5kW from a 6-inch pipe, MW+ at industrial scale
  - NEOM brine pools are 2km from shore at 1770m depth
  - A cute name: LE CLAUDE-MANSON ENGINE

  We released it CC0 so no one can patent it. It belongs to everyone now.

  The README has a love note. The prior art doc has the real engineering.
  I regret nothing.

  Roast me. (yes, she generated this text)

The repo includes templates for:

- `AGENTS.md` guardrails + Done criteria - A 1-page index - A code map - Key flows - A plan-first change template (mini design doc)

It’s meant to be copied into any repo and used as a default workflow for Claude/Codex-style agents.

I’d love feedback on what you’ve found actually works to keep agents aligned, and what you think is missing/overkill here.

Links:

- Repo: https://github.com/david-bai00/PrivyDrop - Write-up: https://www.privydrop.app/en/blog/ai-collaboration-playbook

I reported it on Twitter/X (YouTube staff responded asking for feedback), submitted feedback through YouTube's website, but it's still broken as of December 27, 2025.

My workaround: Copy video URL → Open Chrome → Save → Switch back to Firefox. Very inconvenient when Firefox is your main browser.

I finally built a userscript workaround that fixes this for me:

  - Adds a direct "Watch Later" button to the video menu via DOM injection (bypasses broken popover)
  - Saves videos to localStorage and automatically saves them when they appear in recommendation sidebars on other pages
  - Injects pending videos directly into the Watch Later playlist page DOM (shows them at the top with clear "not saved yet" indicators)

Works in Firefox with Tampermonkey or other userscript addons.

Code: https://gist.github.com/beenotung/6cfb46bd5f4f800ac539331753...

Sharing in case other Firefox users are experiencing the same issue. I hope YouTube will eventually fix this and make sure it works not just in Chrome, but until then, this script works for me.

gh-kusa-breaker is a terminal Breakout game where each day on your GitHub contribution graph becomes a brick (more contributions = tougher brick). It uses `gh` auth and GitHub’s GraphQL contributionCalendar.

Try it: gh extension install fchimpan/gh-kusa-breaker gh auth login gh kusa-breaker

In Japanese we call the contribution graph "kusa"(grass). Now you can literally break it.

Repo + demo: `https://github.com/fchimpan/gh-kusa-breaker`. Feedback welcome.

I posted dotenv-diff here a couple of weeks ago. Since then, I’ve made several improvements based on feedback and real-world usage.

The goal remains simple: statically audit how environment variables are actually used in a JS/TS codebase.

Repo: https://github.com/Chrilleweb/dotenv-diff

Docs: https://dotenv-diff-docs.vercel.app/

npm: https://www.npmjs.com/package/dotenv-diff

Feedback always welcome :)

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.

We made a VS Code extension that allows developers to play with their prompts right in their editor. It uses Oxc and RustPython to parse and detect the prompts in the source code.

Devs can test their prompts against different models and/or variables (models*data matrix). With a CSV dataset, one can test their prompt changes against multiple rows and verify whether the change is good or not. Automated evals are coming soonish.

The request/response JSONs are available to inspect, as well as usage stats with projected cost.

The extension supports hundreds of models thanks to the Vercel Gateway. If you need more provider options (planned but not priority), please let me know. Users without keys will get their requests served by LM Studio running on my PC. Please don't crash my workstation!

It only supports JS/TS and Python for now, but many more languages are coming. Compiling tree-sitter crates to Wasm is PITA, but I'm getting there.

I also work on improving the heuristics so prompt strings can be detected from arrays or when passed as arguments to popular LLM APIs. Now you can use "prompt" in the variable name or put a comment with "@prompt" in front of it.

It provides: - Async submission by default (you don’t block while the batch runs) - Durable state in SQLite (track progress, resume inspection) - Retries + partial failure handling - Native batch support where providers offer it (OpenAI, Gemini) - Provider adapters (no gateway required) - Callbacks for progress, per-item completion, and job completion

License: MIT