PIMP MY IDE
Interface craft / 15 October 2026 / field note 377

One view. Two outputs.

Ito lets a Lua terminal interface feed a native terminal or a browser Canvas. The smart part is not "TUI in a browser." It is the shared cell frame between application state and the final painter.

Inspection boundary
We read the repository at revision 08c6a5ac8bdf, its browser documentation and tests, the live playground, Ratatui documentation, and the launch discussion. We exercised the public playground. We did not build the Rust crate or WebAssembly bundle locally.

RENDER TRANSFER / CUTAWAYSHARED FRAME
STYLED
CELL FRAMEtext / color / link / cursor
NATIVE ADAPTERTerminal
BROWSER ADAPTERCanvas 2D
The useful seam

Port the frame, not the whole terminal.

Ito is a young declarative interface library for Lua, built over Rust and Ratatui. Its public playground accepts Lua source, runs it in WebAssembly, and paints the resulting terminal cells onto a browser Canvas. The repository describes the native terminal as the default desktop output.

The implementation makes the split concrete. The Canvas output receives a frame made of cells. Each cell carries a row, column, width, text, foreground, background, modifiers, and an optional link. The frame also carries a cursor. The JavaScript painter does not need to understand the application's Lua controls.

A portable interface needs one stable state-and-layout contract. The final pixels can belong to another adapter.

Input travels back through the same seam

The browser owns keyboard, pointer, paste, focus, resize, and frame scheduling. Those events cross into the WebAssembly runtime. The Lua view updates its state and emits another cell frame. Repository tests exercise the same example through a terminal test host, including button, checkbox, slider, and text-field input.

That is more useful than a screenshot of a terminal. The browser output remains interactive because the host translates browser events into Ito's input model. The public playground also keeps the last accepted app running after an invalid edit. This is a practical workshop, not a static renderer.

The browser does not become a terminal

The repository names the missing parts. The Canvas output does not interpret raw ANSI writes. It does not provide a shell or filesystem host. It drops Kitty graphics instead of uploading them. Its drawn controls are not separate semantic DOM elements. The playground adds a readable text fallback, but that does not equal native HTML control accessibility.

The live playground exposes phone-width and full-width previews. In our browser pass, the example selector, Lua editor, reset action, preview-width controls, and fullscreen action were keyboard-visible in the page structure. That proves the hosted workshop exists and responds as a web page. It does not prove every generated Canvas control works with every assistive technology.

Read the API argument as design feedback

The Hacker News thread quickly moved from rendering to Lua style. Commenters questioned whether the chained builder API feels native to Lua and suggested table-based alternatives. The project author linked the discussion to an open design issue. That is a healthy boundary: renderer portability can be real while the authoring API remains unsettled.

For your own TUI, keep four records separate. Pin the view source. Name the runtime host. Define the frame contract. Test each output adapter with the same input sequence. If the terminal and browser land on different state after that sequence, the shared frame is not enough.

Interactive makeover / renderer cutaway

Move through the transfer.

A static architecture diagram makes the browser and terminal look like equal magic boxes. This cutaway puts the native range control on the real route: Lua view, runtime host, cell frame, output adapter. Select a layer to see what it owns and what still needs a test.

RENDER PATH / SOURCE TO PIXELSSTAGE 1 OF 4 / LUA VIEW
Owner / application author

Lua view

Declares controls, layout, state, and transitions. The same view function can enter a native terminal host or the playground host.

Artifactmain.lua or a returned view function
Source supportsShared controls and state transitions
Still testExact workflow, narrow width, keyboard path
Failure signalWrong state or layout before painting
ITO RENDER TRANSFER CHECK SELECTED_LAYER=01/LUA_VIEW ARTIFACT=main.lua or returned view function SOURCE_SUPPORTS=Shared controls and state transitions REQUIRED_REPLAY=[NATIVE_TERMINAL_OUTPUT] REQUIRED_REPLAY=[BROWSER_CANVAS_OUTPUT] STATUS=INSPECTION MAP / RUNTIME EVIDENCE REQUIRED
Source rack / read 15 October 2026

What holds up

  1. 01 / Live artifactIto playground

    The public workshop supplied the Lua editor, examples, preview controls, reset action, and interactive Canvas presentation exercised in the browser.

  2. 02 / Exact sourceIto repository at 08c6a5ac8bdf

    The repository supplied the MIT license, crate metadata, Canvas frame structure, WebAssembly host, limits, examples, and parity tests. We read source and tests but did not build them.

  3. 03 / Upstream rendererRatatui 0.30.2 documentation

    The upstream documentation describes the Rust TUI library, its widgets, terminal lifecycle, event handling, and lower-level backend contracts.

  4. 04 / Launch discussionHacker News discussion 50096300

    The launch post explains the browser demo's intent. Replies debate whether the current builder API reads like native Lua. These are opinions and author comments, not runtime proof.

Make the shared frame inspectable.

Then replay the same input against every adapter. Portability is matching state and output, not a second screenshot.