TamboUI: Modern Java Terminal UI with GraalVM Native

Java can finally build terminal UIs as polished as Rust’s Ratatui or Go’s Bubble Tea. TamboUI, announced February 17 by Cédric Champeau and Max Andersen, fills a critical gap in the Java ecosystem with immediate-mode rendering, a rich widget library, and declarative syntax. Moreover, the killer feature is GraalVM native support that enables Java CLI tools to start in under 100 milliseconds—competitive with Go and Rust. Born from an AI-assisted experiment porting Ratatui with Claude Code, TamboUI offers three API abstraction levels from low-level primitives to high-level DSL. While experimental with unstable APIs, this represents Java’s long-overdue entry into the modern terminal UI space.

The Java CLI Gap TamboUI Fills

Java has been terrible for CLI tools for decades. JVM startup takes 3-4 seconds, memory consumption is heavy, and developers resort to dated libraries like Lanterna or build from scratch with JLine. Meanwhile, Rust developers enjoy Ratatui, Go developers have Bubble Tea, and Python has Rich and Textual—modern frameworks with clean APIs and instant responsiveness.

However, GraalVM native images changed the equation. Spring Boot microservices that took 3-4 seconds to start now boot in under 100 milliseconds with 75% less memory. Furthermore, Docker images shrink to 30MB instead of 200MB. As a result, Java CLIs can finally compete with Go and Rust in the DevOps space.

Nevertheless, the ecosystem lacked a modern TUI framework to take advantage of this performance. TamboUI solves that problem by bringing proven terminal UI patterns from Ratatui and Bubble Tea to Java with GraalVM optimization baked in from day one.

Three API Levels, From Primitives to Declarative DSL

TamboUI offers flexibility through three abstraction levels. First, low-level widget primitives provide maximum control for complex use cases, similar to Ratatui’s immediate-mode approach. Second, the mid-level TuiRunner API manages event handling and reduces boilerplate while giving you control over the render loop. For most developers, the high-level Toolkit DSL provides the cleanest, most declarative approach.

Here’s a complete TUI application using the Toolkit DSL:

public class HelloTamboUI extends ToolkitApp {
    @Override
    protected Element render() {
        return panel("Hello",
            text("Welcome to TamboUI!").bold().cyan(),
            spacer(),
            text("Press 'q' to quit").dim()
        ).rounded();
    }

    public static void main(String[] args) throws Exception {
        new HelloTamboUI().run();
    }
}

In addition, the framework handles event loops, rendering threads, and terminal cleanup automatically. TamboUI includes 14+ widgets: tables, charts, gauges, lists, sparklines, tabs, text inputs, bar charts, calendars, and canvases. Under the hood, immediate-mode rendering with intermediate buffers ensures only diffs hit the terminal, keeping performance snappy even with complex UIs.

TamboUI supports three backends (JLine 3, Panama, Aesh) with framework-agnostic design, so you can switch terminal libraries without rewriting code.

Getting Started: JBang Demos to GraalVM Native

The quickest way to try TamboUI is running demos via JBang: jbang demos@tamboui. This lets you explore the widget library without setup.

For projects, add TamboUI snapshot dependencies via OSSRH: tamboui-core, tamboui-widgets, tamboui-toolkit, and a backend like tamboui-jline3-backend. Additionally, the Toolkit DSL approach is recommended—extend ToolkitApp, override the render() method to return your UI tree, and call run() in main.

For GraalVM native compilation, TamboUI is designed for compatibility from day one. Simply add native-image configuration to your project and build with the native-image tool. Consequently, your Java TUI will start in milliseconds with minimal memory, just like Go or Rust CLIs.

The TamboUI documentation provides full getting started guides, API references, and examples.

Real-World Proof: Dan Vega’s Spring Initializr TUI

Dan Vega, Spring Developer Advocate, built a production-quality Spring Initializr TUI using TamboUI. The tool provides an interactive configuration form for project type, language, Spring Boot version, dependencies, and more. Moreover, a searchable dependency picker offers fuzzy search and category filtering. Users can preview generated build files (pom.xml, build.gradle, build.gradle.kts) with syntax highlighting before downloading.

Compiled to GraalVM native, the tool starts instantly and feels as responsive as Go-based CLIs. This proves TamboUI isn’t just for demos—it can build professional developer tools that integrate with APIs like start.spring.io and deliver rich user experiences.

Born from AI-Assisted Development

TamboUI has a unique origin story. When Cédric Champeau asked what TUI libraries AI coding tools like Claude Code use, he learned most rely on Ratatui for Rust. Wondering if Java could have similar capabilities, Champeau experimented by asking Claude Code to port Ratatui to Java. Surprisingly, the AI-generated code was impressive enough to spark a collaboration with Max Andersen from the Quarkus team, refining the concept into TamboUI. This AI-assisted development angle reflects modern software practices and shows how developers are leveraging AI tools to fill ecosystem gaps faster than ever.

Java’s Terminal Renaissance

TamboUI brings Java into competition with Go and Rust for CLI tools and DevOps utilities. With GraalVM native support, Java developers can build monitoring dashboards, interactive installers, and developer tools that start instantly and consume minimal resources.

The framework is experimental—APIs are unstable and only snapshot builds are available. However, with active development (629 commits, 296 GitHub stars), community interest, and a Devoxx France 2026 talk scheduled, TamboUI represents an early adopter opportunity. Try the JBang demos, watch the project evolve, and consider TamboUI for your next Java CLI tool. The Year of Java in the Terminal might actually be 2026.