Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

Developer Voices

Developer Voices artwork

Asciinema: Terminal Recording Done Right (with Marcin Kulik)

Feb 19, 20261 hr 27 minAudio
ShareXLinkedInFacebookWhatsAppEmail

I have a theory that only bad projects get finished - good ones keep finding new things to do. Asciinema is a case in point. What started as a way to share terminal sessions with friends has, over 14 years, grown into a full suite of tools covering recording, hosting, playback, and live streaming - and been rebuilt multiple times along the way. So what does it actually take to record and replay a terminal session faithfully in a browser? Joining us for this conversation is Marcin Kulik, Asciinema's creator. The project's architecture has passed through almost every interesting corner of software engineering: a Python recorder built around pseudo-terminals (PTY), a ClojureScript terminal emulator for the browser that hit performance limits with immutable data structures and garbage collection pressure, a move to Rust compiled to WebAssembly, a Go experiment that didn't last, and a new Rust CLI for concurrent live streaming backed by an Elixir/Phoenix server that calls Rust code via NIFs. The same Rust terminal emulator library now powers all three components - the browser player, the server, and the CLI. If you've ever looked at those terminal animations embedded in a README and wondered what's underneath them, or if you're interested in how a passionate open-source developer navigates 14 years of language changes and rewrites, this conversation has plenty to offer. --- Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join Asciinema: https://asciinema.org Asciinema Docs: https://docs.asciinema.org Asciinema CLI (GitHub): https://github.com/asciinema/asciinema Asciinema Player (GitHub): https://github.com/asciinema/asciinema-player Asciinema Server (GitHub): https://github.com/asciinema/asciinema-server AVT - Rust terminal emulator library: https://github.com/asciinema/avt vt-clj - the original ClojureScript terminal emulator: https://github.com/asciinema/vt-clj Paul Williams' ANSI/VT100 State Machine Parser: https://vt100.net/emu/dec_ansi_parser Rust: https://www.rust-lang.org WebAssembly: https://webassembly.org SolidJS: https://www.solidjs.com Elixir: https://elixir-lang.org Phoenix Framework: https://www.phoenixframework.org Rustler (Rust NIFs for Elixir/Erlang): https://github.com/rusterlium/rustler Clojure: https://clojure.org ClojureScript: https://clojurescript.org cmatrix: https://github.com/abishekvashok/cmatrix Marcin Kulik on GitHub: https://github.com/ku1ik Marcin Kulik on Mastodon: https://hachyderm.io/@ku1ik Marcin Kulik on asciinema.org: https://asciinema.org/~ku1ik "They're Made Out of Meat" demo: https://asciinema.org/a/746358 Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social Kris on Mastodon: http://mastodon.social/@krisajenkins Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/ --- 0:00 Intro 2:28 What Is Asciinema? 4:48 How Asciinema Started 9:51 The Problem of Parsing Terminal Output 14:07 Building a Cross-Platform Recorder 17:01 Rewriting the Parser in ClojureScript 22:19 The Hidden Complexity of Terminals 29:28 Rendering Terminals in the Browser 39:47 When ClojureScript Can't Keep Up 45:28 Moving to Rust and WebAssembly 52:01 The Go Experiment 57:43 Adding Live Terminal Streaming 1:07:12 Can You Scrub Back in a Live Stream? 1:14:40 Editing Recordings 1:25:27 Outro

Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.

Hosts and Guests

Nobody is credited on this episode yet.

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. Why Lisp Thrives In The Age Of AI (with Cameron Barré)

    Nov 11, 20261 hr 40 minAudio

    Earlier this year it looked like AI might kill programming language innovation. Coding agents were at their best in the mainstream languages with decades of training data, which made the barrier to adopting anything new...

    Credit the people on this episode

  2. How Would You Type-Check 30 Million Lines of PHP? (with Julien Verlaguet)

    Sep 25, 20262 hr 22 minAudio

    How would you manage 30 million lines of PHP? You can't rewrite it - you'd be fired long before you delivered. That was the problem facing Facebook around 2011, and their answer was to add a type system, giving birth to...

    Credit the people on this episode

  3. DuckDB And The Burden of Success (with Hannes Mühleisen)

    Aug 26, 20261 hr 46 minAudio

    Building something people actually want is supposed to be the happy ending. But it arrives with a bill attached: feature requests you didn't ask for, pull requests you'd rather not maintain forever, users demanding the...

    Credit the people on this episode

  4. The Enterprise AI Gap (with James Brown)

    Aug 12, 20261 hr 2 minAudio

    My guest this week is James Brown, an engineering lead at Schroders, and that's a useful vantage point - asset managers carry all the regulation and organisational weight of a bank, mixed with the first-to-market...

    Credit the people on this episode

  5. What If Every SQL Query Could Update Incrementally? (with Lalith Suresh)

    Jul 8, 20261 hr 5 minAudio

    There's a problem that's bugged the database industry since the 1980s: you run an expensive query over millions of rows, cache the result, and then a single new row arrives. Logically that's one small update, but most...

    Credit the people on this episode