2026-04-19~6 min readtui ansi retrocomputing bubble-tea

Ansizalizer and the quiet TUI renaissance

Why a Go program that turns images into ANSI art just sent me back to 1996

Save Latin

@savelatin

// contents (11)

Ansizalizer TUI showing the Mona Lisa rendered in colorful ANSI characters using the Iridescent Crystal palette from Lospec, with side panels for colors, characters, size, and text style. — ansizalizer rendering the Mona Lisa · Iridescent Crystal palette · 71×49

There's a specific kind of nostalgia that doesn't live in the photos. It lives in the sound of a 14.4 handshake. It lives in the grey-on-black of EDIT.COM, in the way MemMaker would drumroll its way through your upper memory blocks, in the satisfying thunk of startx actually working on kernel 2.0.something. You can't pay to get that feeling back. You can only be ambushed by it.

Ansizalizer ambushed me.

What it is

At its most literal, Ansizalizer is a tool that converts .png/.jpg/.jpeg/.gif files into ANSI art. You can export to a .ansi file, copy the escape-code blob straight to your clipboard, or batch-render a whole directory. But describing it that way undersells it, because the point isn't the conversion — the point is the interface.

~/code/ansizalizer

$ go build && ./ansizalizer

opens a full-screen TUI

┌─ browse ─────────────┐ ┌─ preview ────────────┐

│ ▸ assets/ │ │ ░░▒▒▓▓██████▓▓▒▒░░ │

│ logo.png │ │ ░▒▓██▓▒░ ░▒▓██▓▒░ │

│ cat.gif ● │ │ ▒██▓░ ░▓█▒ │

│ frame.jpg │ │ ██░ ░█ │

│ palettes/ ▾│ │ ▓█░ ░█▓│

└──────────────────────┘ └──────────────────────┘

[space] render · [p] palette · [d] dither · [?] help

It's written in Go on top of Bubble Tea — Charm's elm-inspired TUI framework that has quietly become a movement of its own. The whole app is keyboard-navigable with tooltips. You can browse Lospec for palettes without leaving the terminal. You get real-time preview, per-frame GIF rendering, alpha transparency via partial-block characters, adjustable dithering, and six built-in color themes.

It is, by any reasonable metric, overbuilt for what it does. Which is exactly why I love it.

Why this, why now

There's a whole genre of software right now that reads like a love letter to the command line — lazygit, btop, yazi, tldr, gum, glow, atuin, the entire Charm catalogue. The phrase I keep seeing is TUI renaissance, and it fits. Terminals are fast. They compose. They survive over SSH. They work on the eight-year-old laptop you keep meaning to reformat. They don't autoplay video ads at you.

But Ansizalizer is a little different from the productivity-TUI crowd. It's not a better top. It's not trying to replace a web app. It's a tool for making images out of characters — which is to say, it's a tool that only makes sense if you grew up with a medium where characters were the image.

The stack of memories that fell out

I clicked "build" and then I just sat there.

I was ten, on a 2400 baud modem, watching the WWIV welcome screen paint itself across the CRT like a Polaroid developing. Top-down. Magenta title. A cyan dragon I distinctly remember thinking was the coolest thing that had ever happened to me. The whole thing was ANSI escape codes over a serial line. I didn't know that at the time. I just knew it was magic, and I could only see it if I let the whole screen finish.

I was twelve, typing EDIT CONFIG.SYS in the dim monochrome of a 486 my dad had brought home from work. EMM386, HIMEM.SYS, DOS=HIGH,UMB. I had memorized the dance not because I understood it but because without it X-Wing wouldn't load its sound. Every game had a readme that read like a chemistry textbook: "requires at least 580K of conventional memory free." I'd run MEM /C /P and stare at the upper memory block map like I was reading tea leaves. If I could claw back 8K I could finally hear the TIE fighter engines.

That was a whole aesthetic, and I hadn't thought about it in years, and then I watched Ansizalizer dither a gradient into half-blocks and it all came back in one wave.

I was fifteen, following a Slackware install guide printed off at the library, floppy by floppy, and when X11 came up for the first time on a Trident card I remember having the genuinely disorienting thought: I did this. This is on my machine. Nobody gave me this. Linux was a private clubhouse then. The guide said "you may need to manually edit XF86Config," and that was considered a helpful sentence.

I bring all of this up not to be the old man yelling about real computers (a little, maybe), but because that's the strata of memory Ansizalizer cracked open, and I think it's not an accident.

Why TUIs hit different

My working theory is this: the terminal is the last place on a modern computer that still has a stable surface.

A TUI in 2026 runs on ncurses-era primitives that haven't fundamentally changed since the VT100 in 1978.
Escape codes from 1976 still paint pixels on Alacritty and Ghostty.
You can pipe the output to a file, check it into git, diff it against next week's run, and it'll still make sense.

The web, by contrast, is a pile of rewrites standing on rewrites. Every six months the framework changes, the bundler changes, the deploy story changes, the accessibility story changes. Building a product for the browser means signing up for a maintenance treadmill that never stops accelerating.

A TUI is a small, durable surface. That's why it feels like the 90s — because in the 90s we hadn't invented as many reasons for software to decay yet. A TUI is a little pocket of that discipline.

What Ansizalizer actually gets right

Going back to the project itself, a few design choices stood out to me on a first pass:

It's keyboard-first, not keyboard-accessible. There's a difference. Keyboard-accessible means "you can use the keyboard if you have to." Keyboard-first means the entire mental model assumes the mouse isn't there — and the app is faster for it.
Live preview + incremental settings. Every slider and toggle redraws the render. This is the thing that makes image-to-ANSI fun instead of tedious. You twiddle, you see, you twiddle again.
It respects the medium. Partial-block characters (▀, ▄, ▌, ▐) for smoother edges is the kind of detail you only think about if you care about ANSI as a format, not just as an output.
Palette browsing from Lospec built in. That's the move. Pixel art Twitter meets 1994 BBS.
MIT licensed, single-binary Go build. One go build and you're in. No npm dance.

How to try it in two minutes

git clone https://github.com/Zebbeni/ansizalizer
cd ansizalizer
go build
./ansizalizer

You need Go 1.21+. That's the whole install. Feed it an image, hit space, and watch a slab of text become something you recognize.

The real point

I don't think Ansizalizer is going to change anybody's workflow. It's not a productivity tool. It's not an AI whatever-it-is. What it is is a reminder — that there is a whole lineage of craft in this medium, that the terminal is not just where you run ls, that a lot of us first fell in love with computers by watching text do something it wasn't supposed to do. A cyan dragon painting itself across a CRT at 2400 baud.

If you followed me this far, go lurk r/tui for twenty minutes. Something will hit the same nerve for you — maybe it's a lazysql demo, maybe it's somebody's 400-line htop alternative, maybe it's a weather app that draws ASCII clouds. Follow that feeling. That's the whole thing.