C & C++ TUIs: ncurses, PDCurses & FTXUI

#define _XOPEN_SOURCE 700
#include <curses.h>
#include <locale.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

struct book {
    const char *title;
    const char *author;
    const char *borrower; /* NULL when on the shelf */
};

static struct book books[] = {
    {"The Pragmatic Programmer", "Hunt, Thomas", NULL},
    {"Structure and Interpretation", "Abelson, Sussman", "Ana"},
    {"The C Programming Language", "Kernighan, Ritchie", NULL},
    {"Designing Data-Intensive Apps", "Kleppmann", NULL},
    {"Code Complete", "McConnell", "Luis"},
    {"Refactoring", "Fowler", NULL},
};
enum { NBOOKS = sizeof books / sizeof books[0] };
enum { PAIR_SELECTED = 1, PAIR_LOANED = 2, PAIR_STATUS = 3 };

static void restore_terminal(void) { endwin(); }

static volatile sig_atomic_t stop_requested;
static void on_signal(int sig) { (void)sig; stop_requested = 1; }

static void install_handlers(void) {
    struct sigaction sa;
    memset(&sa, 0, sizeof sa);
    sa.sa_handler = on_signal;
    sigemptyset(&sa.sa_mask);                 /* no SA_RESTART: getch must return ERR */
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);
}

struct ui {
    WINDOW *list, *details, *status;
    int selected;
    char filter[64];
};

static void destroy_windows(struct ui *ui) {
    if (ui->list) delwin(ui->list);
    if (ui->details) delwin(ui->details);
    if (ui->status) delwin(ui->status);
    ui->list = ui->details = ui->status = NULL;
}

static void layout(struct ui *ui) {
    destroy_windows(ui);
    int left = COLS / 2;
    ui->list = newwin(LINES - 1, left, 0, 0);
    ui->details = newwin(LINES - 1, COLS - left, 0, left);
    ui->status = newwin(1, COLS, LINES - 1, 0);
    keypad(ui->list, TRUE);
}

/* strcasestr is not in POSIX, so the case-insensitive search is written out */
static int contains_nocase(const char *text, const char *needle) {
    size_t n = strlen(needle);
    for (; *text; text++) {
        size_t k = 0;
        while (k < n && text[k] && tolower((unsigned char)text[k]) == tolower((unsigned char)needle[k])) k++;
        if (k == n) return 1;
    }
    return n == 0;
}

static int matches(const struct ui *ui, int i) {
    return contains_nocase(books[i].title, ui->filter);
}

static void draw(struct ui *ui) {
    werase(ui->list);
    box(ui->list, 0, 0);
    mvwprintw(ui->list, 0, 2, " Books ");
    int row = 1;
    for (int i = 0; i < NBOOKS && row < getmaxy(ui->list) - 1; i++) {
        if (!matches(ui, i)) continue;
        if (i == ui->selected) wattron(ui->list, COLOR_PAIR(PAIR_SELECTED) | A_BOLD);
        else if (books[i].borrower) wattron(ui->list, COLOR_PAIR(PAIR_LOANED));
        mvwprintw(ui->list, row++, 1, "%-*.*s", getmaxx(ui->list) - 2, getmaxx(ui->list) - 2,
                  books[i].title);
        wattrset(ui->list, A_NORMAL);
    }
    werase(ui->details);
    box(ui->details, 0, 0);
    mvwprintw(ui->details, 0, 2, " Details ");
    mvwprintw(ui->details, 2, 2, "Title:    %s", books[ui->selected].title);
    mvwprintw(ui->details, 3, 2, "Author:   %s", books[ui->selected].author);
    mvwprintw(ui->details, 4, 2, "Borrower: %s",
              books[ui->selected].borrower ? books[ui->selected].borrower : "(on the shelf)");
    werase(ui->status);
    wbkgd(ui->status, COLOR_PAIR(PAIR_STATUS));
    mvwprintw(ui->status, 0, 1, "j/k move  / search  l loan/return  q quit   filter: %s", ui->filter);
    /* queue every window, then flush once: one minimal update of the terminal */
    wnoutrefresh(ui->list);
    wnoutrefresh(ui->details);
    wnoutrefresh(ui->status);
    doupdate();
}

static void move_selection(struct ui *ui, int step) {
    for (int i = ui->selected + step; i >= 0 && i < NBOOKS; i += step)
        if (matches(ui, i)) { ui->selected = i; return; }
}

static void read_filter(struct ui *ui) {
    werase(ui->status);
    mvwprintw(ui->status, 0, 1, "search: ");
    wrefresh(ui->status);
    echo();
    curs_set(1);
    wgetnstr(ui->status, ui->filter, (int)sizeof ui->filter - 1);
    curs_set(0);
    noecho();
    if (!matches(ui, ui->selected)) move_selection(ui, 1);
    if (!matches(ui, ui->selected)) move_selection(ui, -1);
}

int main(void) {
    setlocale(LC_ALL, "");                    /* before initscr, for UTF-8 */
    install_handlers();
    if (initscr() == NULL) return 1;
    atexit(restore_terminal);
    cbreak();
    noecho();
    curs_set(0);
    if (has_colors()) {
        start_color();
        use_default_colors();
        init_pair(PAIR_SELECTED, COLOR_BLACK, COLOR_CYAN);
        init_pair(PAIR_LOANED, COLOR_YELLOW, -1);
        init_pair(PAIR_STATUS, COLOR_WHITE, COLOR_BLUE);
    }
    struct ui ui = {0};
    layout(&ui);
    while (!stop_requested) {
        draw(&ui);
        int ch = wgetch(ui.list);
        switch (ch) {
        case 'q': stop_requested = 1; break;
        case 'j': case KEY_DOWN: move_selection(&ui, 1); break;
        case 'k': case KEY_UP: move_selection(&ui, -1); break;
        case 'l': books[ui.selected].borrower = books[ui.selected].borrower ? NULL : "you"; break;
        case '/': read_filter(&ui); break;
        case KEY_RESIZE: layout(&ui); break;  /* ncurses already updated LINES and COLS */
        case ERR: break;                      /* interrupted by a signal: loop tests the flag */
        }
    }
    destroy_windows(&ui);
    return 0;                                 /* atexit runs restore_terminal */
}

cc -std=c11 -Wall -Wextra shelf_tui.c -lncurses -o shelf_tui     # macOS
cc -std=c11 -Wall -Wextra shelf_tui.c -lncursesw -o shelf_tui    # Linux, wide-character build
./shelf_tui

#define _XOPEN_SOURCE_EXTENDED 1
#include <curses.h>
#include <locale.h>
#include <wchar.h>

#define NOTE_LINES 60

int main(void) {
    setlocale(LC_ALL, "");
    initscr();
    cbreak();
    noecho();
    keypad(stdscr, TRUE);
    curs_set(0);

    /* A pad is a window that is not limited by the screen size. */
    WINDOW *pad = newpad(NOTE_LINES, 200);
    for (int i = 0; i < NOTE_LINES; i++) {
        wchar_t line[96];
        swprintf(line, sizeof line / sizeof line[0],
                 L"%02d  Biblioteca: ñ é ü  本の棚 (width %d)", i + 1, 4);
        mvwaddwstr(pad, i, 0, line);
    }

    int top = 0;
    wint_t ch;
    int kind;
    for (;;) {
        mvprintw(0, 0, "Notes (arrows scroll, q quits)  top=%d", top);
        wnoutrefresh(stdscr);
        /* pad row/col to show, then the screen rectangle that receives it */
        pnoutrefresh(pad, top, 0, 2, 0, LINES - 1, COLS - 1);
        doupdate();
        kind = get_wch(&ch);                  /* KEY_CODE_YES for function keys, OK for text */
        if (kind == KEY_CODE_YES && ch == KEY_DOWN && top < NOTE_LINES - 1) top++;
        else if (kind == KEY_CODE_YES && ch == KEY_UP && top > 0) top--;
        else if (kind == KEY_CODE_YES && ch == KEY_RESIZE) { clear(); }
        else if (kind == OK && ch == L'q') break;
    }
    delwin(pad);
    endwin();
    return 0;
}

#define _XOPEN_SOURCE 700
#include <curses.h>
#include <form.h>
#include <locale.h>
#include <menu.h>
#include <panel.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/* A modal "loan" dialog: a menu of books in one panel, a form in another. */
int main(void) {
    setlocale(LC_ALL, "");
    initscr();
    cbreak();
    noecho();
    keypad(stdscr, TRUE);
    mvprintw(0, 0, "shelf: F2 loan dialog, q quit");
    refresh();

    /* menu */
    const char *titles[] = {"Refactoring", "Code Complete", "The C Programming Language", NULL};
    ITEM *items[4];
    int n = 0;
    for (; titles[n]; n++) items[n] = new_item(titles[n], "");
    items[n] = NULL;
    MENU *menu = new_menu(items);
    WINDOW *mwin = newwin(8, 40, 3, 4);
    keypad(mwin, TRUE);
    set_menu_win(menu, mwin);
    set_menu_sub(menu, derwin(mwin, 4, 36, 2, 2));
    set_menu_mark(menu, "> ");
    box(mwin, 0, 0);
    mvwprintw(mwin, 0, 2, " Pick a book ");
    post_menu(menu);

    /* form */
    FIELD *fields[2];
    fields[0] = new_field(1, 20, 0, 10, 0, 0);
    fields[1] = NULL;
    set_field_back(fields[0], A_UNDERLINE);
    field_opts_off(fields[0], O_AUTOSKIP);
    FORM *form = new_form(fields);
    WINDOW *fwin = newwin(5, 40, 12, 4);
    keypad(fwin, TRUE);
    set_form_win(form, fwin);
    set_form_sub(form, derwin(fwin, 1, 34, 2, 2));
    box(fwin, 0, 0);
    mvwprintw(fwin, 0, 2, " Borrower ");
    post_form(form);
    mvwprintw(fwin, 2, 2, "Name:");
    form_driver(form, REQ_FIRST_FIELD);

    PANEL *pm = new_panel(mwin);
    PANEL *pf = new_panel(fwin);
    top_panel(pm);
    int in_menu = 1;
    for (;;) {
        update_panels();                       /* recompute the stacking order... */
        doupdate();                            /* ...then touch the terminal once  */
        int ch = wgetch(in_menu ? mwin : fwin);
        if (ch == 'q' && in_menu) break;
        if (ch == '\t') { in_menu = !in_menu; top_panel(in_menu ? pm : pf); continue; }
        if (in_menu) {
            if (ch == KEY_DOWN) menu_driver(menu, REQ_DOWN_ITEM);
            else if (ch == KEY_UP) menu_driver(menu, REQ_UP_ITEM);
        } else if (ch == KEY_BACKSPACE || ch == 127) form_driver(form, REQ_DEL_PREV);
        else if (ch == '\n') break;
        else form_driver(form, ch);
    }
    form_driver(form, REQ_VALIDATION);          /* copy the editing buffer into the field */
    char name[32];
    strncpy(name, field_buffer(fields[0], 0), sizeof name - 1);
    name[sizeof name - 1] = '\0';
    const char *book = item_name(current_item(menu));

    /* panels first, then forms and menus, then the windows */
    del_panel(pf);
    del_panel(pm);
    unpost_form(form); free_form(form); free_field(fields[0]);
    unpost_menu(menu); free_menu(menu);
    for (int i = 0; i < n; i++) free_item(items[i]);
    delwin(fwin);
    delwin(mwin);
    endwin();
    printf("selected: %s / %s\n", book, name);
    return 0;
}

cmake_minimum_required(VERSION 3.20)
project(shelf_tui C)
set(CMAKE_C_STANDARD 11)

find_package(PkgConfig REQUIRED)
pkg_check_modules(NCURSES REQUIRED IMPORTED_TARGET ncursesw panelw menuw formw)

add_executable(shelf_tui shelf_tui.c)
target_link_libraries(shelf_tui PRIVATE PkgConfig::NCURSES)

cmake_minimum_required(VERSION 3.20)
project(shelf_ftxui CXX)
set(CMAKE_CXX_STANDARD 17)

include(FetchContent)
FetchContent_Declare(ftxui
  GIT_REPOSITORY https://github.com/ArthurSonzogni/ftxui
  GIT_TAG v7.0.3
)
FetchContent_MakeAvailable(ftxui)

add_executable(shelf_ftxui shelf_ftxui.cpp)
target_link_libraries(shelf_ftxui PRIVATE ftxui::ftxui)

#include <iostream>
#include <ftxui/dom/elements.hpp>
#include <ftxui/dom/table.hpp>
#include <ftxui/screen/screen.hpp>

int main() {
  using namespace ftxui;

  Table table({
      {"Id", "Title", "Borrower", "Due"},
      {"2", "Structure and Interpretation", "Ana", "2026-11-02"},
      {"5", "Code Complete", "Luis", "2026-11-09"},
  });
  table.SelectAll().Border(LIGHT);
  table.SelectRow(0).Decorate(bold);
  table.SelectColumns(0, -1).SeparatorVertical(LIGHT);

  Element document = vbox({text("Loans") | bold, table.Render()});

  // Dimension::Fit sizes the screen to the document; nothing is interactive.
  auto screen = Screen::Create(Dimension::Fit(document), Dimension::Fit(document));
  Render(screen, document);
  screen.Print();
  std::cout << std::endl;
}

Loans
┌──┬────────────────────────────┬────────┬──────────┐
│Id│Title                       │Borrower│Due       │
│2 │Structure and Interpretation│Ana     │2026-11-02│
│5 │Code Complete               │Luis    │2026-11-09│
└──┴────────────────────────────┴────────┴──────────┘

#include <algorithm>
#include <cctype>
#include <chrono>
#include <ftxui/component/component.hpp>
#include <ftxui/component/screen_interactive.hpp>
#include <ftxui/dom/elements.hpp>
#include <string>
#include <thread>
#include <vector>

using namespace ftxui;

struct Book {
  std::string title;
  std::string author;
  std::string borrower;  // empty when on the shelf
};

static bool contains_nocase(const std::string& text, const std::string& needle) {
  auto lower = [](std::string s) {
    std::transform(s.begin(), s.end(), s.begin(),
                   [](unsigned char c) { return std::tolower(c); });
    return s;
  };
  return lower(text).find(lower(needle)) != std::string::npos;
}

int main() {
  std::vector<Book> books = {
      {"The Pragmatic Programmer", "Hunt, Thomas", ""},
      {"Structure and Interpretation", "Abelson, Sussman", "Ana"},
      {"The C Programming Language", "Kernighan, Ritchie", ""},
      {"Designing Data-Intensive Apps", "Kleppmann", ""},
      {"Code Complete", "McConnell", "Luis"},
      {"Refactoring", "Fowler", ""},
  };

  std::string filter;
  std::vector<int> visible;           // indices into books
  std::vector<std::string> entries;   // what the menu shows
  int selected = 0;

  auto refilter = [&] {
    visible.clear();
    entries.clear();
    for (int i = 0; i < static_cast<int>(books.size()); ++i) {
      if (contains_nocase(books[i].title, filter)) {
        visible.push_back(i);
        entries.push_back(books[i].title);
      }
    }
    selected = std::clamp(selected, 0, std::max(0, static_cast<int>(entries.size()) - 1));
  };
  refilter();

  auto screen = ScreenInteractive::Fullscreen();

  auto menu = Menu(&entries, &selected);

  InputOption search_option;
  search_option.content = &filter;
  search_option.placeholder = "search title";
  search_option.multiline = false;          // Enter must not insert a newline
  search_option.on_change = refilter;
  auto search = Input(search_option);

  auto layout = Container::Vertical({search, menu});

  auto view = Renderer(layout, [&] {
    Element details = text("No book matches") | dim;
    if (!visible.empty()) {
      const Book& b = books[visible[selected]];
      details = vbox({
          text("Title:    " + b.title),
          text("Author:   " + b.author),
          text("Borrower: " + (b.borrower.empty() ? std::string("(on the shelf)") : b.borrower)),
          separator(),
          gauge(static_cast<float>(std::count_if(books.begin(), books.end(),
                                                 [](const Book& x) { return !x.borrower.empty(); })) /
                static_cast<float>(books.size())) | color(Color::Yellow),
          text("share of the catalogue on loan") | dim,
      });
    }
    return vbox({
        hbox({
            window(text(" Books "), vbox({search->Render() | border, menu->Render() | vscroll_indicator | frame | flex})) | flex,
            window(text(" Details "), details) | flex,
        }) | flex,
        text(" Tab switches pane   l loan/return   q quit ") | inverted,
    });
  });

  auto app = CatchEvent(view, [&](Event event) {
    if (event == Event::Character('q') && search->Focused() == false) {
      screen.Exit();
      return true;
    }
    if (event == Event::Character('l') && !search->Focused() && !visible.empty()) {
      Book& b = books[visible[selected]];
      b.borrower = b.borrower.empty() ? "you" : "";
      return true;
    }
    return false;
  });

  // A background thread can ask the UI thread for a redraw.
  std::thread ticker([&] {
    using namespace std::chrono_literals;
    for (int i = 0; i < 3; ++i) {
      std::this_thread::sleep_for(200ms);
      screen.PostEvent(Event::Custom);
    }
  });

  screen.Loop(app);
  ticker.join();
  return 0;
}

c++ -std=c++17 -Wall -Wextra -I<ftxui>/include shelf_ftxui.cpp libftxui.a -o shelf_ftxui