2026년 4월 21일의 Show HN

Some of the features: multi-track timeline, frame accurate seek, MP4 export, audio, video, image, and text tracks, and a WebGL backed canvas where available. It also works on mobile.

Under the hood, WebCodecs handles frame decode for timeline playback and scrubbing, which is what makes seeking responsive since decode runs on the hardware decoder when the browser supports it. FFmpeg compiled to WebAssembly handles final encode, format conversion, and anything WebCodecs does not cover. Rendering goes through Pixi.js on a WebGL canvas, with a software fallback when WebGL is not available. Projects live in IndexedDB and the heavy work runs in Web Workers so the UI stays responsive during exports.

Happy to answer technical questions about the tradeoffs involved in keeping the whole pipeline client-side. Any feedback welcome.

Link: https://vidstudio.app/video-editor

I’ve been building GoModel since December with a couple of contributors. It's an open-source AI gateway that sits between your app and model providers like OpenAI, Anthropic or others.

I built it for my startup to solve a few problems:

  - track AI usage and cost per client or team
  - switch models without changing app code
  - debug request flows more easily
  - reduce AI spendings with exact and semantic caching

  - ~17MB docker image
    - LiteLLM's image is more than 44x bigger ("docker.litellm.ai/berriai/litellm:latest" ~ 746 MB on amd64)
  - request workflow is visible and easy to inspect    
  - config is environment-variable-first by default

Website: https://gomodel.enterpilot.io

Any feedback is appreciated.

The one thing we've noticed over the last 3 months is that the more you use agents, the more work they create. Dozens of pull requests means older code gets out of date quickly. Documentation drifts. Dependencies become stale. Developers are so focused on pushing out new code that this crucial work falls through the cracks. That's why we pivoted away from agents and invented what we think is the necessary next step for AI powered software development.

Today, we're introducing Daemons: a new product category built for teams dealing with operational drag from agent-created output. Named after the familiar background processes from Linux, Daemons are added to your codebase by adding an .md file to your repo, and run in a set-it-and-forget-it way that will make your lives easier and accelerate any project. For teams that use Claude, Codex, Cursor, Cline, or any other agent, we think you'll really enjoy what Daemons bring to the table.

I built this MCP that you can install into your coding agents so they can actually access the web properly.

Right now it can:

- search the general web

- search Reddit

- read and scrape basically any webpage

Install it:

npx openalmanac setup

The MCP is completely free to use. We have also built a central store where you can contribute things you learned while exploring. If you find something useful, you can contribute it to the encyclopedia we're building at Almanac using the same MCP.

This was originally not my idea. There used to be a NoJS club on nojs.club some years ago. But it got discontinued. So someone continued its legacy on https://no-js.club. However the list is fairly outdated and many of the sites have added JavaScript in some way since they were added. I found the original domain nojs.club to be free and decided to start my own No JS club on the legacy of the original domain.

Hydra wraps your AI coding CLIs (Claude Code, Codex, OpenCode, Pi, or any terminal-based tool) in a single command. It monitors terminal output for rate limit patterns, and when one provider runs out, you switch to another with one keypress. Your conversation history, git diff, and recent commits are automatically copied to your clipboard so you can paste and keep going.

The fallback chain is configurable. Mine goes Claude Code → OpenCode (free Gemini) → Codex → Pi (free Gemini). The free tiers alone give you ~3000 requests/day, so even after burning through paid limits you can keep working.

Key details: Full PTY passthrough you see the exact same TUI as running the CLI directly hydra switch from another terminal signals ALL running sessions (rate limits are account-wide) Context extraction parses Claude Code's JSONL session files for real conversation history, not just recent output Any CLI that runs in a terminal works as a provider Single Go binary, ~200 lines of core logic

https://github.com/saadnvd1/hydra

Nothing amazing, but wanted to share with others in case it's useful. Feel free to modify it as you see fit.

it has been a crazy journey seeing how AI agents gets smarter every single day but interaction layer is still missing

we are launching Spectrum TODAY: one Unified API connect your AI Agents into iMessage, WhatsApp, Telegram and more

The core idea is still the same — when a test fails, you should immediately know why without having to add debug prints.

https://github.com/Kairum-Labs/should

Palmier bridges your AI agents and your phone.

It does two things:

1. It lets you use your phone to directly control AI agents running on your computer, from anywhere.

2. It gives your AI agents access to your phone, wherever you are — including things like push notifications, SMS, calendar, contacts, sending email, creating calendar events, location, and more.

A few details:

* Supports 15+ agent CLIs

* Supports Linux, Windows, and macOS

* What runs on your computer and your phone is fully open source

* Works out of the box — no need to set up GCP or API keys just to let agents use phone capabilities

* Your phone can act as an agent remote: start tasks, check progress, review results, and respond to requests while away from your desk

* Your phone can also act as an agent tool: agents can reach into phone capabilities directly when needed

* Optional MCP server: if you want, Palmier exposes an MCP endpoint so your agent can access phone capabilities as native MCP tools. This is optional — you can also use Palmier directly from the phone app/PWA, with those capabilities already built in

* Still in alpha stage, with bugs. Opinions and bug reports very welcome

The basic idea is that AI agents become much more useful if they can both:

* interact with the device you actually carry around all day

* be controlled when you are away from your computer

Palmier is my attempt at that bridge.

It already works with agent CLIs like Claude Code, Gemini CLI, Codex CLI, Cursor CLI, OpenClaw, and others. You can run tasks on demand, on a schedule, or in response to events.

Would especially love feedback on:

* whether this feels genuinely useful

* which phone capabilities are most valuable

* which agent CLIs I should support next

* what feels broken, awkward, or confusing

Site: https://www.palmier.me

Github:

* https://github.com/caihongxu/palmier

* https://github.com/caihongxu/palmier-android

Happy to answer questions.

I built cli-use, a small Python tool that turns any MCP server into a native CLI.

The idea is simple: HTTP has curl, Docker has docker, Kubernetes has kubectl — MCP should have a shell-native client too.

Why I made it:

MCP is useful, but using it through agents has overhead:

every session pays schema discovery cost every call carries JSON-RPC framing responses are often verbose JSON when the useful output is just a line or two

cli-use converts that into a terse CLI so tools can be called like normal shell commands.

Example:

pip install cli-use cli-use add fs /tmp cli-use fs list_directory --path /tmp

After that, the MCP server behaves like a regular CLI:

usable by agents usable by humans usable from scripts / subprocess.run composable with grep, head, xargs, etc.

Example:

cli-use fs search_files --path /tmp --pattern "*.md" | head cli-use fs read_text_file --path /tmp/notes.md | grep TODO

One thing I cared about a lot is agent ergonomics.

Every add also emits a SKILL.md plus an AGENTS.md pointer, so agents working in a repo can discover and use the CLI automatically.

A few details:

pure Python stdlib zero runtime deps persistent aliases works with npm, pip, pipx, and local MCP servers built-in registry for common MCP servers

I also benchmarked it against the real @modelcontextprotocol/server-filesystem server (14 tools). Depending on session size, token savings were around 60–80%, mostly by removing schema overhead and verbose request / response framing.

It’s still alpha, but already usable.

Repo: https://github.com/JustVugg/cli-use

Wrote up the full thinking here: https://tinyurl.com/agent-brain-trust

Currently my biggest issue is that systemd is unable to shut down gracefully when rootfs is mounted from such a deep loop stack. The other is that installing to full disk crashes right after it successfully damages the partition table. I think I could solve both by copying the ISO contents to ramdisk before systemd takes over (initramfs needs to stay slim as I mentioned before) - maybe opportunistically if there is enough RAM (3,5G is not so unreasonable to expect).

I decided to make it paid for now (maybe not eligible for show? if so, sorry, I've been mostly a HN reader so far), but I am still considering if my project brought more good by being free of charge. It is free as in GPL3+ though, so although I can politely ask you not to exercise it too hard until I turn Bad™, you (will) have several ways to obtain it without paying anyway.

The website itself (especially payments) is also an interesting story, I can share it too some day.

What do you think?

No need to fiddle with adding the plugin the tmux.conf and then installing. You can manage plugins directly with muxforge.

Lock file for reproducibility, one-command migration from TPM, and a managed block in your tmux.conf that keeps plugin declarations clean without touching the rest of your config.

Works with stow and dotfile managers, the lock file is designed to live in version control.

MIT licensed. Would love the feedback.

https://muxforge.dev

Maybe this solution already exists? I couldn't find it.

Enjoy! And if you decide to tweak it, please submit your work back in a PR! Or of course you're welcome to fork it. Please share your improvements!

I work on security engineering, and it's incredibly hard to try to defend against an attack that you don't know how to perform yourself. There's also next to nowhere to improve your skills. I'd heard all about fooling AI agents with just "IGNORE ALL PREVIOUS INSTRUCTIONS", but I'd never actually put that into practice, and it turns out it's harder than you'd expect!

Just like knowing basic security skills is important for all software engineers, anyone working with AI should know what prompt injection looks like, and should be thinking about how to prevent it. Flight Risk lets you practice your AI agent manipulation skills: it's got your standard prompt injection and social engineering, but more than that too, each a real vulnerability.

Think you could crack it? Every engineer I've given it to has been surprised by the challenge! You can use the hints, but they affect your score ;)

Give it a try, and let me know how you do!

The link above is the WASM build running entirely client-side — drop a PS, EPS, or PDF and it renders. It's a capability sampler, not a production viewer: no system fonts (browser sandbox), fixed zoom stops, single-threaded at ~2× native overhead.

Why build it: GhostScript is AGPL, pdfium is enormous, and there wasn't a pure-Rust stack that covered PostScript and PDF end-to-end. Apache-2.0 OR MIT.

Source: https://github.com/AndyCappDev/stet Install: cargo install stet-cli for the CLI, cargo add stet for the library (the stet facade crate re-exports the whole toolkit).

I've been building https://blogmaker.app since April 2021, 5 years now. The launch tweet: https://x.com/BlogmakerApp/status/1383742023627247630

I had built it initially as a personal challenge to see if I could have a working product for 20 hours worth of work, and I did it. This was way before AI tools.

A few months later, I included a Stripe button and the first payment came immediately in.

In September 2022 I decided to focus (give up my contract gigs as a designer/dev). I took out a personal loan for $20K and then an angel investor handed me another $30K, so I could fully focus on Blogmaker (blogstatic then). And that's what I did. Night and day. Mostly working on the product and getting it to where it is now. It was super basic in the beginning, with one theme and non–SEO advanced features that it has now.

Up to the end of 2024, prices were yearly only with $19/year and $49/year being the bestsellers.

Throughout this time, I was constantly told (by good meaning friends) that I am charging too low and I should charge more. Combine that with my restlessness to make it a real monthly MRR (yearly prices kinda skew MRR), so at the end of 2024, I took the dive and changed the pricing to monthlies. First starting with $25/month, which I think due to January being a "new year's resolutions" month, got me a solid few upgrades, but it turned out to be a false positive, because sales stalled after that.

Then throughout 2025, I flailed with various monthlies: $12, $19, $29, $39, and even $49/month at one point. The $12/m and $19/m seemed to be working fine, but customers would stay a few months and then leave.

In the back of my mind, I always wanted to go back to yearlies because, in all honesty, I felt "yearly prices" were "the brand" and I loved the kick I would get from customers saying: "WOW! What a product at this price!". I loved being the face of accessibility and running a product that is filling a real gap.

To test my assumptions that "yearlies" are great, throughout the "monthlies" period in 2025, I would run flash sales with $19/year and $39/year plans, and they'd sell like hot cakes.

So after 16 months of not really being convinced on the monthlies, this April I happily reverted to the original yearly prices of $19, $49, and $59/month, and I've already sold a few, as expected.

Changing back to yearlies, feels like a huge burden has been lifted off my shoulders. Customers really loved the yearly Blogmaker and I'm 100% happy to be that!

I strongly believe Blogmaker is an amazing product at an insanely great price, but I'm banging my head against the wall not knowing how to get everyone wanting to start a blog to know about it.

If you look at the showcase of current customer blogs, you'll see what I mean: https://blogmaker.app/showcase

An important note: Historically, yearly prices have converted 10% visits–to–trial, and 15% trial–to–paid (sometimes insanely more), and this was all done with just 40 visits/day, some of those visits were actual customers coming back to the website to login, so % were clearly higher.

I've tried most marketing things, short of paid ads, which there was never a real budget for AND the yearly prices didn't really allow for much wiggle room as far as CAC goes.

Currently there are ~250 active paying customers with blogs ranging from business, SEO, product, services, journals, culture, hobbies, and everything in between. The peak it's ever been was circa 500.

There are two individuals currently interested in buying it out and the money would somewhat help to focus on another SaaS, but I'm crying inside not wanting to let it go.

The ideal outcome would be to convert 5 payments/day which would make it a $5K/month revenue business, and that's completely fine. Which statistically means roughly about 300 visits/day.

Technically, not sure how to get there.

Please, feel free to ask me anything. I've been super open throughout.

ProtoWall sits as a reverse proxy in front of your app. You invite reviewers by email, they click a link, read and sign a versioned NDA, and then get proxied through to your prototype. No SDK, no code changes on your end.

How it works:

- You add your prototype's origin URL and configure an NDA - Invite specific people by email; they get a one-click link - Reviewer accepts the NDA (name, timestamp, IP, user agent all recorded) - A 30-day proxy session is created; traffic flows through to your app - You can revoke access instantly; the session terminates immediately, not at the next token refresh

Every action is audit-logged. You can export a CSV of the full trail or download a per-reviewer PDF evidence package with consent records, NDA text, and SHA-256 content hashes; useful if you ever need to prove someone agreed to your terms.

Auth is magic-link only (no passwords to manage or leak). NDAs are versioned; if you update the text, existing reviewers must re-accept before they can access again.

Free tier: 1 project, 5 invites. Pro is $19/mo for 5 projects and PDF evidence export.

Happy to answer questions about the architecture or the legal side of things.

Some of the backstory:

- I'd seen Boris's X thread of lesser known claude code features

- I taught two of my non-technical friends some claude code features in person recently (I did a few AI tutoring sessions with friends, for fun and curiosity)

- In the process of teaching others, I consumed some of the official educational content from Anthropic

- I saw how many not well known features there are!

- With a lot of Claude's help I made this.

- The UI scope expansion was very fun to indulge.

Let me know what you think!

Site (explanation & demos): https://flipbook.browserbox.io

I like the idea of scrubbable assets in a consistent format. Toyed with making it an actual fileformat (zipped manifest + folder of images) but for now settled on this static site generator.

You can also capture your browser sessions (e.g. https://browser-session-it94u.pages.dev/ ) if you have a BrowserBox license. Example: https://asciinema.org/a/eXhizwQ9FU5y49eP

I like doing a lot with simple technology.

I've been using a small version of this on myself at the gym for the past year. Instead of logging sets and counting macros, you could just upload a photo of yourself every week and the AI tells you how close you are to the goal and what to adjust in the plan.