← Back to all projects

LEARN TUI PROGRAMMING PROJECTS

Learn TUI Programming: From ANSI Escape Codes to Modern Frameworks

Goal: Deeply understand how to build rich, interactive terminal applications—from the low-level escape codes that control the cursor to high-level, component-based frameworks that rival web applications in complexity.

Why Learn TUI Programming?

In a world of web and mobile apps, Text User Interfaces (TUIs) represent a powerful, efficient, and increasingly popular way to build applications. They are fast, accessible over SSH, require minimal resources, and offer a focused, keyboard-driven user experience loved by developers.

After completing these projects, you will:

  • Understand how terminals actually work, beyond just printing text.
  • Master ncurses, the foundational C library for TUI development.
  • Build complex, responsive layouts entirely in the terminal.
  • Use modern TUI frameworks like Textual (Python), Bubbletea (Go), and Ratatui (Rust).
  • Develop applications that are fast, efficient, and work anywhere from a Raspberry Pi to a massive cloud server.
  • Appreciate the art of crafting a beautiful and functional keyboard-centric UX.

Core Concept Analysis

The TUI Landscape: From Raw Codes to Frameworks

It all starts with a terminal emulator, a program that acts like the physical computer terminals of the past. It processes a stream of text, but some text sequences are special “escape codes” that control color, cursor position, and more.

┌───────────────────────────────────────────────────────────┐
│                    APPLICATION LOGIC                      │
│ (e.g., text editor, file browser, chat client)            │
└───────────────────────────────────────────────────────────┘
                  ▲                                │
                  │ User Input (keystrokes)          │ UI State / Draw Commands
                  ▼                                │
┌───────────────────────────────────────────────────────────┐
│                 TUI ABSTRACTION LAYER                     │
├─────────────────────┬───────────────────┬─────────────────┤
│ High-Level Framework│  Mid-Level Library  │   Low-Level     │
│ (Textual, Bubbletea)│ (ncurses)         │  (ANSI Codes)   │
│ --------------------│-------------------│----------------- │
│ • Component-based   │ • Screen canvas   │ • Cursor mov/col  │
│ • Layout management │ • Input handling    │ • Direct stdout │
│ • State management  │ • Windowing       │ • Brittle/manual  │
└─────────────────────┴───────────────────┴─────────────────┘
                                 │
                                 ▼ (Bytes sent to stdout)
┌───────────────────────────────────────────────────────────┐
│                    TERMINAL EMULATOR                      │
│ (GNOME Terminal, iTerm2, Windows Terminal)                │
│                                                           │
│  Parses text and ANSI escape codes to render the UI       │
│  `\x1b[10;20H` -> Move cursor to row 10, col 20           │
│  `\x1b[31mHello\x1b[0m`  -> Print "Hello" in red            │
└───────────────────────────────────────────────────────────┘

Key Concepts Explained

1. ANSI Escape Codes (The “Bare Metal”)

The absolute foundation. Your terminal is constantly interpreting text. When it sees the “Escape” character (\x1b or ^[) followed by [ and a sequence of characters, it treats it as a command, not text to be displayed.

┌────────────────────────────────────────────────────────────────────────┐
│ Command             │ Escape Code             │ Description            │
├────────────────────────────────────────────────────────────────────────┤
│ Move Cursor         │ `\x1b[<L>;<C>H`          │ To Line L, Column C    │
│ Move Up/Down/Fwd/Bck│ `\x1b[<N>A/B/C/D`       │ By N rows/columns      │
│ Clear Screen        │ `\x1b[2J`                │ Clears the entire view │
│ Set Foreground Color│ `\x1b[38;2;<r>;<g>;<b>m` │ Set to an RGB color    │
│ Set Background Color│ `\x1b[48;2;<r>;<g>;<b>m` │ Set to an RGB color    │
│ Reset All           │ `\x1b[0m`                │ Back to default style  │
└────────────────────────────────────────────────────────────────────────┘

Why it matters: Libraries like ncurses are sophisticated wrappers around these codes. Understanding this layer explains why those libraries are necessary.

2. The ncurses Model (The Canvas)

ncurses (New Curses) is a C library that abstracts away the raw escape codes and the differences between terminal types (via terminfo). It gives you a “canvas” (stdscr) and tools to draw on it.

  • Initialization: initscr() starts ncurses mode; endwin() cleans up and returns to normal.
  • The Screen Buffer: ncurses keeps a virtual representation of the screen. When you call refresh(), it compares the new state to the old state and sends only the minimal set of escape codes needed to update the physical terminal. This is its key optimization.
  • Windows: You can create sub-windows (newwin()) that act as independent drawing surfaces, which you can layer and manage separately.
  • Input: It provides functions like getch() to handle keyboard input, including special keys like arrows and function keys.

3. The Modern Framework Model (The Declarative UI)

Frameworks like Textual (Python), Bubbletea (Go), and Ratatui (Rust) take inspiration from web development (especially React) and the Elm Architecture.

            ┌───────────────┐
            │   User Input  │
            │ (e.g., 'j' key) │
            └───────┬───────┘
                    │
                    ▼
┌───────────┐   ┌───────┐   ┌──────────────────────────┐
│   View()  │◀──│ Model │──▶│         Update()         │
│           │   │(State)│   │ (Processes input,        │
│ Renders   │   └───────┘   │  updates Model,          │
│ the Model │               │  returns new Model + Cmd)│
└───────────┘   │       │   └──────────────────────────┘
                │       │
                ▼       └─────────┐
            ┌───────┐         ┌───┴───┐
            │  Draw │         │  Cmd  │
            │(To term)│        │(Effect) │
            └───────┘         └───────┘
  • Model: A struct or class that holds the entire state of your application.
  • View: A function that takes the Model and returns a string (or a tree of components) representing what the UI should look like. You declare the UI, you don’t draw it.
  • Update: A function that takes an input message (like a keypress) and the current Model, and returns a new, updated Model. It can also return a Command (like an HTTP request) to be executed.

Why it’s a big deal: This pattern makes managing complex state much easier than the imperative ncurses style. You no longer manually track what needs to be redrawn; the framework does it for you based on state changes.

Project List

The following 12 projects will guide you from direct terminal manipulation to building sophisticated, modern TUI applications.

Project 1: ANSI Paint

  • File: LEARN_TUI_PROGRAMMING_PROJECTS.md
  • Main Programming Language: Python
  • Alternative Programming Languages: C, Go, Rust
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 1: Beginner
  • Knowledge Area: Terminal Control / Escape Codes
  • Software or Tool: Any standard terminal
  • Main Book: “The Linux Programming Interface” by Michael Kerrisk

What you’ll build: A simple “paint” program where you move the cursor with arrow keys and press the spacebar to “draw” a colored block at the cursor’s position, all by printing raw ANSI escape codes.

Why it teaches TUI programming: This project forces you to grapple with the raw, low-level mechanics of terminal control. You’ll understand the “magic” behind all TUI libraries because you’ll have implemented the magic yourself. It’s painful, which makes you appreciate the abstractions that come next.

Core challenges you’ll face:

  • Disabling canonical mode and echo → maps to reading keystrokes instantly without waiting for Enter
  • Parsing multi-byte escape codes for arrow keys → maps to understanding that special keys are not single characters
  • Manually tracking cursor position → maps to managing your own UI state
  • Sending the correct codes to move the cursor and change color → maps to direct terminal manipulation

Key Concepts:

  • Terminal Modes (canonical, raw): “The Linux Programming Interface” Chapter 62 - Terminals
  • ANSI Escape Codes: ANSI escape code (Wikipedia)
  • Non-blocking I/O: Python tty and termios modules documentation

Difficulty: Beginner Time estimate: Weekend Prerequisites: Basic programming in any language.

Real world outcome: A simple, full-screen drawing application. You can move the cursor around with arrow keys. Pressing the spacebar leaves a colored block. Pressing a number key changes the “paint” color. Pressing ‘q’ exits.

(Terminal Output)

    +----------------------------------------+
    |                                        |
    |                                        |
    |          ███                           |
    |          █  █                          |
    |          ███                           |
    |                                        |
    |                 █████                  |
    |                                        |
    +----------------------------------------+
  Current Color: RED | Position: (18, 9) | Press 'q' to quit

Implementation Hints:

Questions to guide your implementation:

  1. How do you put the terminal in a state where you can read single key presses? (Hint: termios in Python/C). Remember to restore it on exit!
  2. When you read from stdin, an up-arrow key might look like \x1b[A. How do you parse this sequence?
  3. How do you construct the string to move the cursor to position (row, col)? (e.g., \x1b[{row};{col}H)
  4. How do you clear the screen at the start of the program?

Learning milestones:

  1. Read a single keypress without echo → Understand terminal I/O modes.
  2. Move the cursor with arrow keys → Master cursor control codes.
  3. Draw colored blocks → Master color and style codes.
  4. Build a working interactive application → You’ve created a TUI from absolute scratch.

Project 2: A top-like Process Viewer with Ncurses

  • File: LEARN_TUI_PROGRAMMING_PROJECTS.md
  • Main Programming Language: C
  • Alternative Programming Languages: Python (with curses module), Rust (with ncurses-rs)
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: TUI / Systems Programming
  • Software or Tool: ncurses library, /proc filesystem on Linux
  • Main Book: “The Linux Programming Interface” by Michael Kerrisk

What you’ll build: A read-only, auto-refreshing dashboard that lists running processes, their PIDs, CPU usage, and memory usage, similar to the classic top or htop commands.

Why it teaches TUI programming: It’s the perfect ncurses project. It forces you to handle a main loop, manage dynamic data, format it into columns, and handle resizing and user input for sorting or quitting, all within the ncurses paradigm.

Core challenges you’ll face:

  • Initializing and cleaning up ncurses → maps to managing the ncurses lifecycle
  • Creating a non-blocking main loop → maps to updating the UI without waiting for user input
  • Reading and parsing /proc filesystem → maps to fetching the data to display
  • Formatting data into aligned columns → maps to controlling screen layout precisely

Key Concepts:

  • Ncurses Windows: “NCURSES Programming HOWTO” - Pradeep Padala
  • Non-blocking Input: Setting nodelay(stdscr, TRUE) and a timeout.
  • /proc/[pid]/stat & /proc/[pid]/status: man proc for the format of these files.
  • Formatted Printing: Using mvprintw and attron/attroff for colors and styles.

Difficulty: Intermediate Time estimate: 1-2 weeks

  • Prerequisites: Project 1 (optional but helpful), solid C programming skills, basic understanding of Linux processes.

Real world outcome: A full-screen TUI application that refreshes every few seconds, displaying a sorted list of processes. The header shows system stats, and columns are neatly aligned. Pressing ‘q’ quits.

(Terminal Output)

MyTop - 14:05:21 | Tasks: 123, 1 running | Uptime: 5 days
CPU: [■■■□□□□□□□□□□□□□□□□□] 15.0% | Mem: [■■■■■■■■■□□□□□□□□□□□] 45.2%

  PID   USER      CPU%  MEM%  COMMAND
 1234   root      12.5   2.3  ./my-app
 5678   douglas    2.1   5.8  chrome
 9101   douglas    0.5   1.2  zsh
 1121   root       0.2   0.8  systemd
...

Implementation Hints:

Your main loop should look something like this:

// Pseudo-code
init_ncurses();
while (running) {
    // Check for user input
    int ch = getch();
    if (ch == 'q') running = false;

    // Only update data on a timer
    if (time_to_update()) {
        process_list = read_proc_data();
        sort_processes(process_list, sort_key);
    }

    // Draw the UI
    clear();
    draw_header();
    draw_process_table(process_list);
    refresh();

    // Sleep for a short duration
    napms(100);
}
end_ncurses();
  • Use nodelay(stdscr, TRUE); to make getch() non-blocking.
  • To parse /proc/[pid]/stat, be prepared for a space-delimited format where fields can have spaces (e.g., the command name).
  • Calculate CPU % by storing the previous utime and stime values and comparing them against the change in total system time.

Learning milestones:

  1. Display static data in a loop → Master the basic ncurses draw loop.
  2. Fetch and display real process data → Integrate system data into the TUI.
  3. Implement auto-refresh → Create a dynamic, “live” application.
  4. Add sorting via keyboard input → Handle user interaction to modify state.

Project 3: A menuconfig-style Configuration Editor

  • File: LEARN_TUI_PROGRAMMING_PROJECTS.md
  • Main Programming Language: C
  • Alternative Programming Languages: C++, Rust
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: TUI / Interactive Forms
  • Software or Tool: ncurses library
  • Main Book: “C Programming: A Modern Approach” by K. N. King

What you’ll build: An interactive, menu-driven tool for editing a configuration file. Users navigate a nested menu with arrow keys, toggle options with the spacebar, and enter string values.

Why it teaches TUI programming: This project is all about state management and user interaction in a structured way. You’ll move beyond simple display and build a genuinely interactive application that manipulates data, which is a core skill for any UI development.

Core challenges you’ll face:

  • Representing the menu structure in C → maps to using structs and arrays to model your UI state
  • Handling navigation and selection logic → maps to managing a “currently selected item” index and input handling
  • Drawing different widget types (checkbox, textbox) → maps to rendering state visually
  • Reading initial state from a file and writing it back → maps to persistence

Key Concepts:

  • Data-Driven UI: Your C structs define the menu, not hardcoded draw calls.
  • State Management: Keeping track of the cursor, selected values, and menu hierarchy.
  • Ncurses Forms Library (or manual implementation): The forms library can help, but building it manually teaches more.

Difficulty: Intermediate Time estimate: 1-2 weeks Prerequisites: Project 2, strong C skills (structs, pointers, enums).

Real world outcome: A TUI that allows a user to configure a simple application. The tool reads config.ini, presents a menu, and saves the changes on exit.

(Terminal Output)

     Application Configuration
 ┌──────────────────────────────────┐
 │                                  │
 │    [X] Enable Networking         │
 │    ( ) Enable TLS                │
 │    --- Server Settings ---       │
 │    Host: [localhost      ]       │
 │    Port: [8080           ]       │
 │                                  │
 └──────────────────────────────────┘
   <  OK  >      < Cancel >

Implementation Hints: Define your menu items with a struct:

// Pseudo-code for menu item structure
typedef enum { CHECKBOX, TEXT, LABEL } ItemType;

typedef struct {
    char* label;
    ItemType type;
    union {
        bool checked;
        char* text_value;
    } value;
} MenuItem;

Your main loop will:

  1. Draw all visible menu items based on the current state.
  2. Highlight the currently selected item.
  3. Wait for getch().
  4. If arrow keys, update the selected item index.
  5. If spacebar, toggle the value of a checkbox.
  6. If Enter on a text field, enter a sub-loop to handle text input.
  7. Redraw the screen.

Questions to guide you:

  • How will you handle a text input field? (Hint: You’ll need a separate function that captures characters until Enter is pressed).
  • How do you represent nested menus? (Hint: A menu item could have a pointer to a sub-menu).
  • How will you manage screen space if the menu is longer than the terminal height? (Hint: Scrolling, by tracking a top_visible_item index).

Learning milestones:

  1. Render a static list of items → Basic data-to-UI rendering.
  2. Implement selection and navigation → Core interaction loop.
  3. Implement a checkbox toggle → Modifying boolean state.
  4. Implement a text input field → Handling complex user input and string state.

Project 4: A lazygit-style Git Client with Go & Bubbletea

  • File: LEARN_TUI_PROGRAMMING_PROJECTS.md
  • Main Programming Language: Go
  • Alternative Programming Languages: Rust (with Ratatui)
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Modern TUI Frameworks / Git
  • Software or Tool: Go, Bubbletea & Lipgloss libraries, Git
  • Main Book: “The Go Programming Language” by Donovan & Kernighan

What you’ll build: A multi-pane TUI for managing a Git repository. It will have panels for unstaged files, staged files, and recent commits. You’ll be able to stage files and write commit messages.

Why it teaches TUI programming: This project catapults you into modern, declarative TUI development. You’ll learn the Model-View-Update architecture, how to compose complex UIs from smaller components, and how to manage application state in a clean, maintainable way.

Core challenges you’ll face:

  • Structuring the app with Model-View-Update → maps to learning the Elm architecture
  • Creating a multi-pane layout → maps to using lipgloss for flexbox-like styling
  • Executing shell commands (git) and parsing their output → maps to handling asynchronous operations and commands (Cmds)
  • Managing focus between different panels → maps to complex state management in your Model

Key Concepts:

  • The Elm Architecture: Bubbletea documentation.
  • Styling with Lipgloss: Lipgloss documentation for borders, padding, colors.
  • Bubbletea Commands (Cmds): How to perform I/O without blocking the UI loop.
  • Component Composition: Building smaller models (like a list view) and combining them in a parent model.

Difficulty: Advanced Time estimate: 2-3 weeks Prerequisites: Basic Go programming, familiarity with Git commands.

Real world outcome: A fast, responsive Git TUI. The user can navigate between files and commits, stage files by pressing the spacebar, and open a prompt to commit changes.

(Terminal Output)
┌───────────GIT STATUS─────────────┐┌───────────RECENT COMMITS───────────────┐
│ Status in /path/to/repo          ││ > feat: Add new TUI layout (HEAD)      │
│ ▽ Staged Changes (1)             ││   fix: Correct off-by-one error        │
│   M internal/ui/view.go          ││   refactor: Simplify state management  │
│ ▽ Unstaged Changes (2)           ││   docs: Update README for new feature  │
│ >?? .gitignore                   ││                                        │
│  AM main.go                      ││                                        │
└──────────────────────────────────┘└────────────────────────────────────────┘
┌───────────────────────────────────────────────────────────────────────────┐
│ Diff for main.go                                                          │
│@@ -10,5 +10,6 @@                                                           │
│ import (                                                                  │
│-   "fmt"                                                                   │
│+   "fmt"                                                                   │
│+   "os/exec"                                                               │
│ )                                                                         │
└───────────────────────────────────────────────────────────────────────────┘
 [s]tage [c]ommit [q]uit

Implementation Hints:

Your Model struct might look like this:

// Pseudo-code
type Model struct {
    filesPanel list.Model  // Using a list "bubble"
    commitsPanel list.Model
    diffView viewport.Model // Another bubble for scrollable content
    activePanel int // 0 for files, 1 for commits
    err error
}
  • Start with one panel. Get it to display the output of git status.
  • Use the exec.Command package to run Git commands. Wrap this in a tea.Cmd so it doesn’t block your UI. The result of the command will be sent back to your Update function as a message.
  • Use lipgloss.JoinHorizontal and lipgloss.JoinVertical to arrange your panels.
  • Your Update function will become a large switch statement, handling key presses, window resize messages, and messages from your Cmds (e.g., gitStatusResultMsg).

Learning milestones:

  1. Display git status in a simple list → Master basic Model-View-Update and Cmds.
  2. Create a two-pane layout → Learn Lipgloss for layout.
  3. Implement focus switching and staging files → Handle more complex state and user interaction.
  4. Add a commit prompt overlay → Learn to manage layered UIs and different application “modes”.

Project 5: A TUI File Explorer with Python & Textual

  • File: LEARN_TUI_PROGRAMMING_PROJECTS.md
  • Main Programming Language: Python
  • Alternative Programming Languages: Go (with Bubbletea), Rust (with Ratatui)
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Modern TUI Frameworks / Filesystem
  • Software or Tool: Python, Textual library
  • Main Book: “Fluent Python” by Luciano Ramalho

What you’ll build: A multi-pane file explorer like ranger. It will have a directory tree, a file listing, and a preview pane that shows the contents of text files or metadata for directories.

Why it teaches TUI programming: Textual brings an object-oriented, widget-based, and CSS-styled approach to TUIs. This project teaches you how to compose a complex UI from reusable widgets and how to handle events and data binding in a very modern, web-like way.

Core challenges you’ll face:

  • Designing a widget-based hierarchy → maps to thinking in components, like React
  • Styling the application with Textual CSS → maps to separating presentation from logic
  • Handling asynchronous file I/O → maps to using workers to prevent UI blocking
  • Binding data to widgets → maps to reactive programming concepts

Key Concepts:

  • Textual App & Widgets: Textual documentation on App and built-in widgets like DirectoryTree, DataTable.
  • Layouts and CSS: Textual’s docs on grid layouts and CSS styling.
  • Workers and run_in_thread: Handling blocking I/O without freezing the app.
  • Messages and Event Handling: on_... methods for handling user input and widget events.

Difficulty: Advanced Time estimate: 2-3 weeks Prerequisites: Strong Python skills (OOP), basic CSS knowledge is helpful.

Real world outcome: A fast, usable TUI file manager. You can navigate the filesystem with arrow keys, see live previews of files, and potentially add features like renaming or deleting files.

# Textual App pseudo-code
from textual.app import App
from textual.widgets import DirectoryTree, Header, Footer, Static

class FileExplorer(App):
    CSS_PATH = "styles.css"

    def compose(self):
        yield Header()
        yield DirectoryTree("./")
        yield Static(id="preview") # Preview pane
        yield Footer()

    def on_directory_tree_file_selected(self, event):
        # A message handler for when a file is clicked
        preview_pane = self.query_one("#preview")
        # Use a worker to read the file asynchronously
        self.read_file_content(event.path, preview_pane)

# styles.css
# Screen {
#     layout: horizontal;
# }
# DirectoryTree {
#     width: 33%;
# }
# #preview {
#     width: 67%;
# }

The real outcome would be the running application, not the code.

Learning milestones:

  1. Display a functional DirectoryTree → Master a core Textual widget.
  2. Add a second pane for previews → Learn layout management with Textual CSS.
  3. Load file content asynchronously into the preview pane → Understand workers and thread safety in a TUI context.
  4. Bind keys for navigation and actions → Implement custom application logic and key bindings.

The projects continue, covering topics like chat clients, music players, and even building your own TUI framework to solidify your understanding. Here is a summary table and recommendation.

Project Comparison Table

Project Difficulty Time Main Concept Taught Fun Factor
1. ANSI Paint Beginner Weekend Raw Terminal Control 🎨🎨🎨
2. top Clone Intermediate 1-2 weeks Ncurses & Dynamic Data 💻💻💻💻
3. menuconfig Clone Intermediate 1-2 weeks Interactive Forms (Ncurses) ⚙️⚙️⚙️
4. lazygit Clone Advanced 2-3 weeks Declarative UI (Go) 🔥🔥🔥🔥🔥
5. File Explorer Advanced 2-3 weeks Widget-based UI (Python) 📂📂📂📂📂

Recommendation

For a true “first principles” understanding, start with Project 1: ANSI Paint. It’s a short project that will make you deeply appreciate the problems that libraries like ncurses solve.

If you already have some systems programming experience and want to build something immediately practical, start with Project 2: A top-like Process Viewer. It’s the quintessential ncurses project and will give you a solid foundation in classic TUI development.

If you are coming from a web development background and want to see the modern state-of-the-art, jump into Project 4 (Go/Bubbletea) or Project 5 (Python/Textual). You’ll feel right at home with the component-based, declarative style.

Final Overall Project: A TUI IDE

  • File: LEARN_TUI_PROGRAMMING_PROJECTS.md
  • Main Programming Language: Python or Rust
  • Coolness Level: Level 5: Pure Magic (Super Cool)
  • Business Potential: 4. The “Open Core” Infrastructure
  • Difficulty: Level 5: Master
  • Knowledge Area: Advanced TUI / Language Server Protocol
  • Software or Tool: Textual or Ratatui, Language Server Client
  • Main Book: “Crafting Interpreters” by Robert Nystrom (for inspiration on language tooling)

What you’ll build: A minimal, vim-like Integrated Development Environment (IDE) in the terminal. It would feature a file explorer, a text editing area, and a diagnostics pane. It would communicate with a Language Server (e.g., pyright for Python, rust-analyzer for Rust) to provide features like autocomplete, go-to-definition, and error highlighting.

Why it teaches TUI programming: This is the ultimate TUI project. It combines everything: complex layouts, asynchronous communication with an external process (the language server), text editing, state management, and building a highly interactive, performance-sensitive application. It’s a real, powerful tool that you would genuinely use.

Core challenges you’ll face:

  • Implementing a text editor widget from scratch (or extending one) → maps to handling text, selections, and a cursor efficiently
  • Communicating with a Language Server over JSON-RPC → maps to asynchronous I/O and protocol implementation
  • Displaying diagnostics and autocomplete menus → maps to dynamic overlays and complex UI state
  • Optimizing for performance to feel “snappy” → maps to efficient rendering and state updates

Summary of Projects

Project Main Language
1. ANSI Paint Python
2. A top-like Process Viewer with Ncurses C
3. A menuconfig-style Configuration Editor C
4. A lazygit-style Git Client with Go & Bubbletea Go
5. A TUI File Explorer with Python & Textual Python
(and 7 more projects not fully detailed here)  
Final Project: A TUI IDE Python or Rust