TamboUI: bringing ratatui style terminals to Java

The gap TamboUI aims at in the Java ecosystem

TamboUI describes itself as a Java library for building modern terminal user interfaces, and it is explicit about where the idea comes from. The README names the TUI paradigms seen in Rust's ratatui and Go's bubbletea, and says the library brings them to the Java ecosystem. That is the whole pitch, and it is a pitch about idiom rather than about features. A Java developer who has written a terminal application has usually done it with a print and a cursor move, which means the programmer owns redraw logic, cursor bookkeeping, and the bug class that comes with a screen that was half updated when a write failed. The library takes that work away by giving Java the same shape those projects use, with a widget tree, a layout system, and a rendering loop, and it states that it provides a comprehensive set of widgets and a layout system for building rich terminal applications with modern Java idioms. The intended audience is a Java developer building a command line tool that needs more than a prompt and a stream of lines, and the naming follows the same route: TamboUI is pronounced like tambouille, or tan-bouy.

Immediate-mode rendering over a diffing buffer

The key features list names three rendering ideas and they stack. Immediate-mode rendering means the entire user interface is redrawn each frame, which the README presents as the reason state management is simple: you do not track which widget changed, because everything is rebuilt every frame. That approach is only viable if the redraw is cheap, which is what the intermediate buffer system is for. Widgets render into a buffer rather than straight to the terminal, and the buffer is then diffed so that only the cells that actually changed are written out. The third piece is the layout system, described as constraint-based, with percentage, fixed, ratio and proportional sizing. Taken together, this is the same three-part structure the Rust and Go libraries use, and the reason a Java port is interesting is that the pattern is largely independent of the host language, while the cost of building it, the buffer type, the cell type, the rectangle type, the style type and the text primitives, is exactly the kind of code that is tedious to get right twice. The core module, tamboui-core, is where those primitives live, and the widget implementations sit in tamboui-widgets on top of them.

Backends: JLine 3, Panama and Aesh

A terminal library on the JVM has a specific portability problem, because the terminal is not a byte stream but a set of capabilities that differ between systems and terminals. TamboUI addresses it with multiple backends, and the key features list names JLine 3, Panama and Aesh as the ones in use. The JLine backend is the most conventional choice, since JLine is the established Java library for terminal handling, and the module table lists it as tamboui-jline while the repository directory is named tamboui-jline3-backend, a small naming mismatch worth knowing when you match modules to artifacts. The Panama backend points at the newer native access API in the JDK, and the Aesh backend gives a second established implementation to work with. The repository also has a tamboui-backend-integration-tests module, which is the place to look for how the backends are held to the same behaviour, and a tamboui-panama-backend directory alongside tamboui-aesh-backend. For an application author the practical effect is that the choice of backend is a dependency decision, while the widget and layout code above it stays the same.

TuiRunner, the toolkit DSL, CSS and PicoCLI

Above the widgets sits a higher level layer, and this is where the library saves the most code. The tamboui-tui module provides TuiRunner, described as a high-level framework that eliminates boilerplate with built-in event handling and key helpers, and the quick start builds on it directly. The tamboui-toolkit module goes further and offers a fluent DSL for declarative user interface construction with components and focus management, which is the layer a larger application would use, with a separate tamboui-tfx-toolkit and tamboui-tfx-tui in the directory listing. Styling is not bolted on afterwards either, since the key features list mentions Cascading Style Sheets support, and the repository has a tamboui-css module alongside tamboui-markdown, tamboui-image, tamboui-annotations and tamboui-processor for text and image handling. Argument parsing is a separate concern handled by an optional PicoCLI integration module, tamboui-picocli, so a command line tool can parse options and then hand over to the interface. The mouse and animation example shows what the configuration layer exposes, with a TuiConfig carrying a mouseCapture flag and a tickRate in milliseconds, alongside a frame callback and an event handler that receives key, mouse and tick events.

Getting a build: snapshot repository, Gradle, JBang

The installation story has one important wrinkle, and the README states it plainly: currently TamboUI is only available as snapshot builds. The packages live in a snapshot repository, and the three ways to reach it are given as Maven, Gradle and JBang configurations. For Gradle the repository block declares the snapshot URL and marks it as snapshots only.

repositories {
    maven {
        url = uri("https://central.sonatype.com/repository/maven-snapshots/")
        mavenContent {
            snapshotsOnly()
        }
    }
}

For JBang, the shortcut is a comment line at the top of the source file, and the README notes that JBang 0.136 or higher recognises the central-portal-snapshots shortcut.

//DEPS dev.tamboui:tamboui-tui:LATEST
//DEPS dev.tamboui:tamboui-jline3-backend:LATEST

The requirements are stated separately: Java 8 or later with Java 17 and above highly recommended, and Gradle 9.x. The repository is set up for that toolchain, with gradlew and gradlew.bat wrappers, a build.gradle.kts and a settings.gradle.kts at the root, a run-demo.sh script, a jbang-catalog.json, and a jreleaser.yml for the release automation. A first program is a HelloWorld file you run with jbang, and the demo modules under demos/ and tamboui-demos/ cover the widget set.

JFR tracing for diagnosing a running interface

One of the more useful details in the README is the diagnostics story, because a terminal interface is a program that redraws in a loop, and such programs are exactly the ones where you need to know where the time goes. TamboUI can emit JFR events when a recording is active, and the command to start one is given directly.

jcmd <pid> JFR.start name=tamboui settings=profile duration=60s filename=tamboui.jfr

The event names are listed, and they map onto the two halves of the system. There is dev.tamboui.terminal.draw, which measures the duration of Terminal.draw, and then a set of toolkit events covering event routing at dev.tamboui.toolkit.route, candidate handling, focus change, focus navigation, drag state and the global handler. With those, a slow interface can be attributed to the render loop or to the event handling, which is a distinction that is otherwise awkward to make from the outside. It is also a hint about the architecture: the drawing and the event routing are separate instrumented stages, so a slow frame can be traced to one of them.

Experimental status, a wide module set, and what to check first

The README carries a note that TamboUI is still experimental and under active development, with the statement that APIs may or will change, and it invites feedback, issues and contributions. The release history is consistent with that. Version 0.4.0 came on 2026-06-18, 0.5.0 on 2026-09-14 and 0.6.0 on 2026-10-12, and the last push was on 2026-10-18, so the project is moving quickly through pre-1.0 versions with the API surface still in flux. That is a reasonable trade for a young library and an awkward one for production software, and the mitigating factor is that the licence is MIT, so vendoring a known good version and patching it is a practical option. The second thing to check is the module set, because the repository is wide. The top level contains tamboui-core, tamboui-widgets, tamboui-tui, tamboui-toolkit, tamboui-css, tamboui-markdown, tamboui-image, tamboui-annotations, tamboui-processor, the three backends, tamboui-picocli, tamboui-bom, tamboui-benchmarks, the annotation processor, the demos, and the toolkit and tui variants of the tfx family. The existence of a bom module is the useful detail, since it is how a build pins a consistent set of these artifacts rather than resolving each one separately. Finally, the native image support claim matters for distribution: the key features list says the library can be compiled to native executables with GraalVM for instant startup, which is a packaging decision with its own configuration cost rather than a free win.

Editorial conclusion

TamboUI fits a Java team that wants a modern terminal interface with layout, styling and focus handling rather than a hand rolled character grid, and that is comfortable pinning a snapshot build while the APIs move. It does not fit a project that needs a stable release to pin, since the README states the library is experimental and the APIs may change, and it does not fit a team that must stay on a long term support version without a vendoring plan. Before you build on it, verify the version alignment across the modules you use, because the repository ships many separate artifacts, and confirm that the snapshot repository you add is the one your build resolves, since the library is currently available only as snapshot builds.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. tamboui/tamboui on GitHub