# Python Libraries Doom Uses for Its TUI: A Deep Dive into Textual

> Discover the Python libraries Doom uses for its TUI, focusing on the Textual framework. Learn how Textual builds interactive terminal interfaces for certificate exploration.

- Repository: [000pp/doom](https://github.com/000pp/doom)
- Tags: deep-dive
- Published: 2026-02-22

---

**Doom uses the Textual framework (version 6.0.0 or higher) as its primary Python TUI library, leveraging Textual's App, Screen, and Widget abstractions alongside indirect Rich rendering to build an interactive terminal interface for certificate template exploration.**

The open-source **Doom** repository (000pp/doom) provides a terminal-based tool for exploring certificate templates. Understanding what Python libraries Doom uses for its TUI reveals how modern Python applications achieve rich, mouse-aware console interfaces without external GUI dependencies. Doom's implementation demonstrates Textual's capabilities for building complex, multi-screen terminal applications.

## Core Python TUI Library: Textual Framework

Doom's interactive console UI is built on **Textual**, a modern TUI framework that leverages Rich for rendering. The project declares `textual>=6.0.0` as a runtime dependency and `textual-dev>=1.7.0` for development tooling in its [`pyproject.toml`](https://github.com/000pp/doom/blob/main/pyproject.toml) file.

Textual provides the core abstractions that Doom uses:

- **App**: The entry-point of the UI is a subclass of `textual.app.App` defined in [`src/doom/__main__.py`](https://github.com/000pp/doom/blob/main/src/doom/__main__.py).
- **Screen**: Individual UI screens (login, loading, main view) inherit from `textual.screen.Screen` and live in `src/doom/screens/`.
- **Widgets & Layouts**: Each screen composes Textual widgets (e.g., `Button`, `DataTable`, `Input`) to render certificate templates, status messages, and navigation controls.
- **Rich integration**: Textual automatically renders Rich objects, allowing Doom to display colorful tables and formatted text without adding Rich as a direct dependency.

## How Doom Structures Its Textual Application

### Application Entry Point in [`__main__.py`](https://github.com/000pp/doom/blob/main/__main__.py)

The application boots through [`src/doom/__main__.py`](https://github.com/000pp/doom/blob/main/src/doom/__main__.py), which defines a subclass of `textual.app.App`. This entry point initializes the TUI event loop and mounts the initial screen, establishing the foundation for Doom's interactive interface.

### Screen Management Architecture

Doom organizes its interface into discrete screens located in `src/doom/screens/`. Each screen inherits from `textual.screen.Screen` and encapsulates a specific view:

- **[`main_screen.py`](https://github.com/000pp/doom/blob/main/main_screen.py)**: Displays certificate templates in a sortable `DataTable`.
- **[`login_screen.py`](https://github.com/000pp/doom/blob/main/login_screen.py)**: Handles LDAP authentication input using `Input` widgets.
- **[`loading_screen.py`](https://github.com/000pp/doom/blob/main/loading_screen.py)**: Shows progress indicators during data fetching operations.

### Widget Composition and Rich Rendering

Within each screen, Doom composes **Textual widgets** to build the interface. The application utilizes `Button` for navigation controls, `DataTable` for displaying certificate metadata, and `Input` for form fields. Because Textual internally leverages **Rich** for rendering, Doom inherits advanced formatting capabilities—such as colorful tables and styled text—without declaring Rich as a direct dependency in [`pyproject.toml`](https://github.com/000pp/doom/blob/main/pyproject.toml).

## Implementation Examples from the Doom Source

The following examples demonstrate how Doom implements Textual patterns in its source code.

### Bootstrapping the Application

The entry point in [`src/doom/__main__.py`](https://github.com/000pp/doom/blob/main/src/doom/__main__.py) follows this pattern to initialize the TUI:

```python
from textual.app import App
from textual.widgets import Header, Footer, Button

class DoomApp(App):
    def compose(self):
        yield Header()
        yield Button("Quit", id="quit")
        yield Footer()

    async def on_button_pressed(self, event):
        if event.button.id == "quit":
            await self.action_quit()

if __name__ == "__main__":
    DoomApp().run()

```

*The actual entry point lives in* [`src/doom/__main__.py`](https://github.com/000pp/doom/blob/main/src/doom/__main__.py) *and follows the same pattern, but adds routing to the various screens.*

### Defining Custom Screens

Screens like the main certificate viewer in [`src/doom/screens/main_screen.py`](https://github.com/000pp/doom/blob/main/src/doom/screens/main_screen.py) inherit from `textual.screen.Screen`:

```python

# src/doom/screens/main_screen.py

from textual.screen import Screen
from textual.widgets import DataTable

class MainScreen(Screen):
    def compose(self):
        table = DataTable()
        table.add_columns("Template", "Issuer", "Valid‑From", "Valid‑To")
        # Populate the table with parsed certificate data…

        yield table

```

*Doom's real* `MainScreen` *extends this idea, showing parsed certificate templates in a sortable table.*

### Navigating Between Screens

Doom handles transitions between the login, loading, and main views using the `push_screen` method:

```python

# Example of navigating from login → loading → main

await self.app.push_screen("login")
await self.app.push_screen("loading")
await self.app.push_screen("main")

```

*Screen transitions are handled by the* `App` *instance, as seen throughout the screen modules (*[`login_screen.py`](https://github.com/000pp/doom/blob/main/login_screen.py)*,* [`loading_screen.py`](https://github.com/000pp/doom/blob/main/loading_screen.py)*).*

## Summary

Doom demonstrates how modern Python TUI applications can deliver rich, interactive experiences using the Textual framework. Key takeaways include:

- **Textual** serves as the sole primary Python TUI library, with version `>=6.0.0` required for runtime and `>=1.7.0` for development.
- The application architecture centers on Textual's **App** class (defined in [`src/doom/__main__.py`](https://github.com/000pp/doom/blob/main/src/doom/__main__.py)) and **Screen** subclasses (located in `src/doom/screens/`).
- **Rich** rendering capabilities are inherited indirectly through Textual, enabling colorful tables and formatted text without direct dependency.
- Widget composition using `DataTable`, `Button`, and `Input` creates the interactive certificate template interface.

## Frequently Asked Questions

### Does Doom use Rich directly as a Python TUI library?

No, Doom does not declare Rich as a direct dependency in [`pyproject.toml`](https://github.com/000pp/doom/blob/main/pyproject.toml). Instead, Doom leverages Rich's rendering capabilities indirectly through Textual, which automatically handles Rich objects for displaying colorful tables and styled text in the terminal.

### What is the minimum Textual version required for Doom's TUI?

Doom requires **Textual version 6.0.0 or higher** for runtime operations, as specified in the [`pyproject.toml`](https://github.com/000pp/doom/blob/main/pyproject.toml) dependencies. For development tooling, Doom requires `textual-dev>=1.7.0` to support development workflows and debugging.

### How does Doom handle navigation between different TUI screens?

Doom implements navigation using Textual's screen stack management through the `push_screen()` method available on the `App` instance. Each screen (such as login, loading, and main views) inherits from `textual.screen.Screen` and resides in separate modules within `src/doom/screens/`, allowing modular UI organization and clean separation of concerns.

### Is Doom's TUI mouse-interactive or keyboard-only?

Doom's TUI is fully mouse-aware and keyboard-navigable, inheriting these capabilities from the Textual framework. Users can interact with buttons, data tables, and input fields using either mouse clicks or keyboard shortcuts, providing flexibility for different terminal environments and user preferences.