Update nix lock and make nix package follow the current version (#1164)

This is better ergonomic, as `std::string_view` is lightweight and accept more conversion than `const std::string&`.

Co-authored-by: ArthurSonzogni <sonzogniarthur@gmail.com>

.bazelignore

@@ -0,0 +1 @@
+bazel/test/

.bazelrc

@@ -0,0 +1,10 @@
+common --enable_bzlmod
+common --enable_workspace
+
+build --features=layering_check
+build --enable_bzlmod
+
+build --enable_platform_specific_config
+build:linux --cxxopt=-std=c++20
+build:macos --cxxopt=-std=c++20
+build:windows --cxxopt=/std:c++20

.bcr/presubmit.yml

@@ -1,24 +1,36 @@
-# Copyright 2025 Arthur Sonzogni. All rights reserved.
-# Use of this source code is governed by the MIT license that can be found in
-# the LICENSE file.
 matrix:
-  platform:
-  - centos7
-  - debian10
-  - ubuntu2004
-  - macos
-  - windows
-  bazel: [6.x, 7.x, 8.x]
+  bazel:
+    - 7.x
+    - 8.x
+    - rolling
+  unix_platform:
+    - debian11
+    - ubuntu2204
+    - macos
+    - macos_arm64
+  win_platform:
+    - windows
+
 tasks:
-  verify_targets:
-    name: Build and test.
-    platform: ${{ platform }}
+
+  unix_test:
+    name: Verify build targets on Unix
+    platform: ${{ unix_platform }}
     bazel: ${{ bazel }}
+    build_flags:
+    - --cxxopt=-std=c++20
     build_targets:
-    - '@ftxui//:ftxui'
-    - '@ftxui//:screen'
     - '@ftxui//:dom'
     - '@ftxui//:component'
-    test_targets:
-    - '@ftxui//:tests'
+    - '@ftxui//:screen'
 
+  windows_test:
+    name: Verify build targets
+    platform: ${{ win_platform }}
+    bazel: ${{ bazel }}
+    build_flags:
+    - --cxxopt=/std:c++20
+    build_targets:
+    - '@ftxui//:dom'
+    - '@ftxui//:component'
+    - '@ftxui//:screen'

.clang-format

@@ -2,3 +2,6 @@
 # http://clang.llvm.org/docs/ClangFormatStyleOptions.html
 BasedOnStyle: Chromium
 Standard: Cpp11
+
+InsertBraces: true
+InsertNewlineAtEOF: true

.github/copilot-instructions.md

@@ -0,0 +1,212 @@
+# FTXUI - Functional Terminal (X) User Interface
+
+FTXUI is a cross-platform C++ library for terminal-based user interfaces with a functional programming approach, inspired by React.
+
+**ALWAYS reference these instructions first and fallback to search or bash commands only when you encounter unexpected information that does not match the information here.**
+
+## Working Effectively
+
+### Build System Setup and Commands
+- Bootstrap and build the repository:
+  ```bash
+  # Basic build (library only) - fast
+  cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+  cmake --build build --parallel $(nproc)
+  # Build time: ~30 seconds. NEVER CANCEL. Set timeout to 120+ seconds.
+  
+  # Build with examples  
+  cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DFTXUI_BUILD_EXAMPLES=ON
+  cmake --build build --parallel $(nproc)
+  # Build time: ~70 seconds. NEVER CANCEL. Set timeout to 180+ seconds.
+  
+  # Build with examples and tests
+  cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DFTXUI_BUILD_EXAMPLES=ON -DFTXUI_BUILD_TESTS=ON
+  cmake --build build --parallel $(nproc)
+  # Build time: ~113 seconds (includes GoogleTest download). NEVER CANCEL. Set timeout to 300+ seconds.
+  ```
+
+- Alternative build with Ninja (faster):
+  ```bash
+  cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DFTXUI_BUILD_EXAMPLES=ON
+  ninja -C build
+  # Build time: ~62 seconds. NEVER CANCEL. Set timeout to 180+ seconds.
+  ```
+
+- Run unit tests:
+  ```bash
+  # Configure with tests enabled first, then:
+  cd build && ctest --output-on-failure
+  # Test time: ~4 seconds (302 tests). NEVER CANCEL. Set timeout to 60+ seconds.
+  ```
+
+### Bazel Support
+- FTXUI also supports Bazel build system
+- **WARNING**: Bazel may fail due to network connectivity issues in sandboxed environments
+- If Bazel is available:
+  ```bash
+  bazel build //...  # Build everything
+  bazel test //...   # Run tests
+  ```
+
+## Validation
+
+### Manual Testing After Changes
+- **ALWAYS manually validate changes by building and running examples after making code modifications**
+- Run example applications to verify functionality:
+  ```bash
+  # Build an example first
+  cmake --build build --target ftxui_example_border
+  
+  # Run examples (they are interactive, use timeout to terminate)
+  timeout 2s build/examples/dom/ftxui_example_border
+  timeout 2s build/examples/dom/ftxui_example_color_gallery
+  timeout 2s build/examples/component/ftxui_example_button
+  ```
+- Examples should produce visual terminal output with borders, colors, and UI components
+- **CRITICAL**: Always run at least one DOM example and one Component example to verify both modules work
+
+### Code Quality and Formatting
+- Always run formatting before committing:
+  ```bash
+  ./tools/format.sh
+  # Format time: ~7 seconds. NEVER CANCEL. Set timeout to 60+ seconds.
+  ```
+- The format script adds license headers and runs clang-format on all source files
+- **Required**: Run formatting or the CI (.github/workflows/build.yaml) will fail
+
+### Build Validation Requirements
+- ALWAYS build with both `-DFTXUI_BUILD_EXAMPLES=ON` and `-DFTXUI_BUILD_TESTS=ON` when making changes
+- Run the complete test suite with `ctest --output-on-failure`
+- All 302 tests must pass
+- **Scenario Testing**: Run at least these validation scenarios:
+  1. Build library only (basic validation)
+  2. Build with examples and run 2-3 different examples
+  3. Build with tests and run complete test suite
+  4. Run formatting tool to ensure code style compliance
+
+## Project Structure
+
+### Key Directories
+```
+/home/runner/work/FTXUI/FTXUI/
+├── include/ftxui/           # Public header files
+│   ├── component/           # Interactive component headers
+│   ├── dom/                 # DOM element headers  
+│   ├── screen/              # Screen and rendering headers
+│   └── util/                # Utility headers
+├── src/ftxui/               # Implementation files
+│   ├── component/           # Interactive components (buttons, menus, etc.)
+│   ├── dom/                 # DOM elements (layout, styling, text)
+│   ├── screen/              # Screen rendering and terminal handling
+│   └── util/                # Utilities
+├── examples/                # Example applications
+│   ├── component/           # Interactive component examples
+│   └── dom/                 # DOM element examples
+├── cmake/                   # CMake configuration files
+├── tools/                   # Development tools (formatting, etc.)
+└── .github/workflows/       # CI/CD configuration
+```
+
+### Core Library Modules
+FTXUI is organized into three main modules that depend on each other:
+```
+┌component──┐  (Interactive UI components)
+│┌dom──────┐│  (Layout and styling elements)  
+││┌screen─┐││  (Terminal rendering and input)
+└┴┴───────┴┴┘
+```
+
+1. **screen**: Low-level terminal handling, colors, pixels, input
+2. **dom**: Layout elements (hbox, vbox, text, borders, etc.)
+3. **component**: Interactive components (buttons, menus, input fields)
+
+### CMake Build Options
+| Option                            | Description                      | Default |
+|-----------------------------------|----------------------------------|---------|
+| FTXUI_BUILD_EXAMPLES              | Build example applications       | OFF     |
+| FTXUI_BUILD_DOCS                  | Build documentation             | OFF     |  
+| FTXUI_BUILD_TESTS                 | Build and enable tests          | OFF     |
+| FTXUI_BUILD_MODULES               | Build C++20 modules             | OFF     |
+| FTXUI_ENABLE_INSTALL              | Generate install targets        | ON      |
+| FTXUI_MICROSOFT_TERMINAL_FALLBACK | Windows terminal compatibility  | ON/OFF  |
+
+## Common Tasks
+
+### Building Examples
+```bash
+# Build specific examples
+cmake --build build --target ftxui_example_border
+cmake --build build --target ftxui_example_button
+cmake --build build --target ftxui_example_menu
+
+# List all available examples
+find build -name "ftxui_example_*" -type f
+```
+
+### Running Tests
+```bash
+# Run all tests
+cd build && ctest
+
+# Run tests with verbose output
+cd build && ctest --verbose
+
+# Run specific test pattern
+cd build && ctest -R "Button" --verbose
+```
+
+### Working with Source Code
+- **Component Development**: Modify files in `src/ftxui/component/` for interactive elements
+- **DOM Development**: Modify files in `src/ftxui/dom/` for layout and styling
+- **Screen Development**: Modify files in `src/ftxui/screen/` for terminal rendering
+- **Adding Examples**: Add new `.cpp` files in `examples/component/` or `examples/dom/`
+- **Header Files**: Public APIs are in `include/ftxui/[module]/`
+
+### Integration Patterns
+When adding FTXUI to a project, use CMake FetchContent (recommended):
+```cmake
+include(FetchContent)
+FetchContent_Declare(ftxui
+  GIT_REPOSITORY https://github.com/ArthurSonzogni/ftxui
+  GIT_TAG v6.1.9
+)
+FetchContent_MakeAvailable(ftxui)
+
+target_link_libraries(your_target PRIVATE
+    ftxui::component  # For interactive components
+    ftxui::dom        # For layout elements  
+    ftxui::screen     # For basic rendering
+)
+```
+
+## Troubleshooting
+
+### Build Issues
+- If CMake configuration fails, ensure C++20 support: `cmake --version` (need 3.12+)
+- If Ninja build fails, fall back to Make: `cmake -S . -B build` (without `-G Ninja`)
+- If tests fail to build, GoogleTest download might have failed - check network connectivity
+- Build artifacts are in `build/` directory - delete with `rm -rf build` to clean
+
+### Example Issues  
+- Examples are interactive terminal applications - use `timeout` to terminate them
+- If examples don't display correctly, terminal might not support colors/Unicode
+- Examples require terminal size of at least 80x24 for proper display
+
+### Formatting Issues
+- Format script requires clang-format to be installed
+- If format script fails, check that source files are not read-only
+- Format script modifies files in-place - commit changes afterwards
+
+## Critical Reminders
+
+- **NEVER CANCEL long-running builds** - they may take 2-3 minutes
+- **ALWAYS run the formatting tool** before committing changes  
+- **ALWAYS build and test examples** when making component/dom changes
+- **SET APPROPRIATE TIMEOUTS**: 300+ seconds for builds, 60+ seconds for tests
+- **BUILD TIMING EXPECTATIONS**:
+  - Basic library: ~30 seconds
+  - With examples: ~70 seconds  
+  - With examples + tests: ~113 seconds (first time, includes GoogleTest download)
+  - Subsequent builds: ~60-70 seconds
+  - Tests execution: ~4 seconds
+  - Formatting: ~7 seconds

.github/workflows/build.yaml

@@ -14,25 +14,30 @@ on:
 jobs:
 
   test_bazel:
-    name: "Bazel, ${{ matrix.compiler }}, ${{ matrix.os }}"
+    name: "Bazel, ${{ matrix.cxx }}, ${{ matrix.os }}"
     strategy:
       fail-fast: false
       matrix:
         include:
           - os: ubuntu-latest
-            compiler: gcc
+            cxx: g++
+            cc: gcc
 
           - os: ubuntu-latest
-            compiler: llvm
+            cxx: clang++
+            cc: clang
 
           - os: macos-latest
-            compiler: llvm
+            cxx: g++
+            cc: gcc
 
           - os: macos-latest
-            compiler: gcc
+            cxx: clang++
+            cc: clang
 
           - os: windows-latest
-            compiler: cl
+            cxx: cl
+            cc: cl
 
     runs-on: ${{ matrix.os }}
     steps:
@@ -40,10 +45,23 @@ jobs:
         uses: actions/checkout@v3
 
       - name: "Build with Bazel"
+        env:
+          CC: ${{ matrix.cc }}
+          CXX: ${{ matrix.cxx }}
         run: bazel build ...
 
       - name: "Tests with Bazel"
-        run: bazel run tests
+        env:
+          CC: ${{ matrix.cc }}
+          CXX: ${{ matrix.cxx }}
+        run: bazel test --test_output=all ...
+
+      - name: "Bazel Smoke test"
+        env:
+          CC: ${{ matrix.cc }}
+          CXX: ${{ matrix.cxx }}
+        run: bazel build //... --enable_bzlmod --override_module=ftxui=../..
+        working-directory: bazel/test
 
   test_cmake:
     name: "CMake, ${{ matrix.compiler }}, ${{ matrix.os }}"
@@ -154,3 +172,47 @@ jobs:
           flags: ${{ runner.os }}
           name: ${{ runner.os }}-coverage
           files: ./build/coverage.xml
+
+  test_modules:
+    name: "Test modules"
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            compiler: llvm
+          # TODO add gcc / msvc
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: "Checkout repository"
+        uses: actions/checkout@v3
+
+      - name: "Setup Cpp"
+        uses: aminya/setup-cpp@v1
+        with:
+          compiler: ${{ matrix.compiler }}
+          vcvarsall: ${{ contains(matrix.os, 'windows' )}}
+          cmake: true
+          ninja: true
+          clangtidy: false
+          cppcheck: false
+          opencppcoverage: false
+
+      - name: "Generate ./examples_modules"
+        run: >
+          ./tools/generate_examples_modules.sh
+
+      - name: "Build modules"
+        run: >
+          mkdir build;
+          cd build;
+          cmake ..
+          -DCMAKE_GENERATOR=Ninja
+          -DFTXUI_BUILD_MODULES=ON
+          -DFTXUI_BUILD_EXAMPLES=ON
+          -DCMAKE_BUILD_TYPE=Debug
+          -DFTXUI_BUILD_DOCS=OFF
+          -DFTXUI_BUILD_TESTS=OFF
+          -DFTXUI_BUILD_TESTS_FUZZER=OFF
+          -DFTXUI_ENABLE_INSTALL=ON
+          -DFTXUI_DEV_WARNINGS=ON ;
+          cmake --build .

.github/workflows/documentation.yaml

@@ -12,6 +12,10 @@ jobs:
     steps:
       - name: "Checkout repository"
         uses: actions/checkout@v3
+        with:
+          fetch-depth: 0   # Need full history.
+          fetch-tags: true # Need tags.
+
 
       - name: "Install cmake"
         uses: lukka/get-cmake@latest
@@ -19,13 +23,23 @@ jobs:
       - name: "Install emsdk"
         uses: mymindstorm/setup-emsdk@v7
 
-      - name: "Install Doxygen/Graphviz"
+      - name: "Install Doxygen"
+        uses: ssciwr/doxygen-install@v1
+        with:
+          version: '1.12.0'
+
+      - name: "Install Graphviz"
         run: >
           sudo apt-get update;
-          sudo apt-get install doxygen graphviz;
+          sudo apt-get install graphviz;
 
       - name: "Build documentation"
+        run: |
+          python3 ./tools/build_multiversion_doc.py
+
+      - name: "Build examples"
         run: >
+          mkdir -p multiversion_docs/main/examples;
           mkdir build;
           cd build;
           emcmake cmake ..
@@ -35,9 +49,8 @@ jobs:
           -DFTXUI_BUILD_TESTS=OFF
           -DFTXUI_BUILD_TESTS_FUZZER=OFF
           -DFTXUI_ENABLE_INSTALL=OFF
-          -DFTXUI_DEV_WARNINGS=ON ;
-          cmake --build . --target doc;
-          cmake --build . ;
+          -DFTXUI_DEV_WARNINGS=OFF;
+          cmake --build .;
           rsync -amv
           --include='*/'
           --include='*.html'
@@ -47,13 +60,13 @@ jobs:
           --include='*.wasm'
           --exclude='*'
           examples
-          doc/doxygen/html;
+          ../multiversion_docs/
 
       - name: "Deploy"
         uses: peaceiris/actions-gh-pages@v3
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: build/doc/doxygen/html/
+          publish_dir: multiversion_docs
           enable_jekyll: false
           allow_empty_commit: false
           force_orphan: true

.github/workflows/publish.yaml

@@ -9,29 +9,16 @@ on:
         required: true
         type: string
 
-  # Fire as soon as the Release workflow completes
-  workflow_run:
-    workflows:
-      - Release
-    types:
-      - completed
-
 permissions:
-
-  attestations: write
   contents:     write
-  id-token:     write
 
 jobs:
   publish:
     uses: bazel-contrib/publish-to-bcr/.github/workflows/publish.yaml@v0.0.4
-    # Only run on manual dispatch, or when Release finishes successfully
-    if: |
-      github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success')
     with:
-      tag_name: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag_name || github.event.workflow_run.head_branch }}
+      tag_name: ${{ github.event.inputs.tag_name }}
       registry_fork: ArthurSonzogni/bazel-central-registry
+      attest: false
 
     secrets:
       publish_token: ${{ secrets.PUBLISH_TOKEN }}

.github/workflows/release.yaml

@@ -98,19 +98,3 @@ jobs:
           upload_url: ${{ needs.release.outputs.upload_url }}
           asset_path: source.tar.gz
           overwrite: true
-
-      - name: Generate source attestation
-        id: attest_source
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-path: source.tar.gz
-
-      - name: Rename source attestation
-        run: mv ${{ steps.attest_source.outputs.bundle-path }} source.tar.gz.intoto.jsonl
-
-      - name: "Upload source attestation"
-        uses: shogo82148/actions-upload-release-asset@v1
-        with:
-          upload_url: ${{ needs.release.outputs.upload_url }}
-          asset_path: source.tar.gz.intoto.jsonl
-          overwrite: true

.gitignore

@@ -24,10 +24,12 @@ out/
 !BUILD.bazel
 !MODULE.bazel
 !.bazelrc
+!.bazelignore
 
 # .github directory:
 !.github/**/*.yaml
 !.github/**/*.yml
+!.github/**/*.md
 
 # cmake directory:
 !cmake/**/*.in
@@ -36,6 +38,10 @@ out/
 # bazel directory:
 !bazel/**/*.bzl
 !.bcr/*
+!bazel/test/*.bazel
+!bazel/test/*.bazelrc
+!bazel/test/*.cpp
+!bazel/test/*.md
 
 # doc directory:
 !doc/**/Doxyfile.in
@@ -44,6 +50,7 @@ out/
 !doc/**/*.html
 !doc/**/*.xml
 !doc/**/*.md
+!doc/*.md
 
 # examples directory:
 !examples/**/*.cpp
@@ -62,9 +69,13 @@ out/
 !include/ftxui/**/*.cpp
 
 # src directory:
+!src/ftxui/*.cppm
 !src/ftxui/**/*.hpp
 !src/ftxui/**/*.cpp
+!src/ftxui/**/*.cppm
 
 # tools directory:
 !tools/**/*.sh
+!tools/**/*.py
 !tools/**/*.cpp
+build/

BUILD.bazel

@@ -12,23 +12,21 @@
 load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library", "cc_test")
 load(":bazel/ftxui.bzl", "ftxui_cc_library")
 load(":bazel/ftxui.bzl", "generate_examples")
-load(":bazel/ftxui.bzl", "cpp20")
 load(":bazel/ftxui.bzl", "windows_copts")
-load(":bazel/ftxui.bzl", "pthread_linkopts")
 
-package(default_visibility = ["//visibility:public"])
-
-# A meta target that depends on all the ftxui sub modules.
-alias(
+# A meta target depending on all of the ftxui submodules.
+# Note that component depends on dom and screen, so ftxui re-exports all headers.
+# ┌component──┐
+# │┌dom──────┐│
+# ││┌screen─┐││
+# └┴┴───────┴┴┘
+ftxui_cc_library(
     name = "ftxui",
-    # Note that :component depends on :dom, which depends on :screen. Bazel
-    # doesn't really support "public" and "private" dependencies. They are all
-    # public. This is equivalent to depending on all the submodules.
-    actual = ":component",
-    visibility = ["//visibility:public"],
+    hdrs = glob(["include/ftxui/**/*.hpp"]),
+    deps = [":component"],
 )
 
-# ftxui:screen is a module that provides a screen buffer and color management
+# @ftxui:screen is a module that provides a screen buffer and color management
 # for terminal applications. A screen is a 2D array of cells, each cell can
 # contain a glyph, a color, and other attributes. The library also provides
 # functions to manipulate the screen.
@@ -60,7 +58,7 @@ ftxui_cc_library(
     ],
 )
 
-# ftxui:dom is a library that provides a way to create and manipulate a
+# @ftxui:dom is a library that provides a way to create and manipulate a
 # "document" that can be rendered to a screen. The document is a tree of nodes.
 # Nodes can be text, layouts, or various decorators. Users needs to compose
 # nodes to create a document. A document is responsive to the size of the
@@ -130,7 +128,7 @@ ftxui_cc_library(
     deps = [":screen"],
 )
 
-# ftxui:component is a library to create "dynamic" component renderering and
+# @ftxui:component is a library to create "dynamic" component renderering and
 # updating a ftxui::dom document on the screen. It is a higher level API than
 # ftxui:dom.
 #
@@ -163,10 +161,26 @@ ftxui_cc_library(
         "src/ftxui/component/resizable_split.cpp",
         "src/ftxui/component/screen_interactive.cpp",
         "src/ftxui/component/slider.cpp",
+        "src/ftxui/component/task.cpp",
+        "src/ftxui/component/task_internal.hpp",
+        "src/ftxui/component/task_queue.cpp",
+        "src/ftxui/component/task_queue.hpp",
+        "src/ftxui/component/task_runner.cpp",
+        "src/ftxui/component/task_runner.hpp",
         "src/ftxui/component/terminal_input_parser.cpp",
         "src/ftxui/component/terminal_input_parser.hpp",
         "src/ftxui/component/util.cpp",
         "src/ftxui/component/window.cpp",
+
+        # Private header from ftxui:dom.
+        "src/ftxui/dom/node_decorator.hpp",
+
+        # Private header from ftxui:screen.
+        "src/ftxui/screen/string_internal.hpp",
+        "src/ftxui/screen/util.hpp",
+
+        # Private header.
+        "include/ftxui/util/warn_windows_macro.hpp",
     ],
     hdrs = [
         "include/ftxui/component/animation.hpp",
@@ -181,8 +195,10 @@ ftxui_cc_library(
         "include/ftxui/component/screen_interactive.hpp",
         "include/ftxui/component/task.hpp",
     ],
-    linkopts = pthread_linkopts(),
-    deps = [":dom"],
+    deps = [
+        ":dom",
+        ":screen",
+    ],
 )
 
 # FTXUI's tests
@@ -201,11 +217,9 @@ cc_test(
         "src/ftxui/component/menu_test.cpp",
         "src/ftxui/component/modal_test.cpp",
         "src/ftxui/component/radiobox_test.cpp",
-        "src/ftxui/component/receiver_test.cpp",
         "src/ftxui/component/resizable_split_test.cpp",
         "src/ftxui/component/slider_test.cpp",
         "src/ftxui/component/terminal_input_parser_test.cpp",
-        "src/ftxui/component/terminal_input_parser_test_fuzzer.cpp",
         "src/ftxui/component/toggle_test.cpp",
         "src/ftxui/dom/blink_test.cpp",
         "src/ftxui/dom/bold_test.cpp",
@@ -233,6 +247,17 @@ cc_test(
         "src/ftxui/screen/string_test.cpp",
         "src/ftxui/util/ref_test.cpp",
 
+        # Private header from ftxui:screen for string_test.cpp.
+        "src/ftxui/screen/string_internal.hpp",
+
+        # Private header from ftxui::component for
+        # terminal_input_parser_test.cpp.
+        "src/ftxui/component/terminal_input_parser.hpp",
+
+        # Private header from ftxui::dom for
+        # flexbox_helper_test.cpp.
+        "src/ftxui/dom/flexbox_helper.hpp",
+
         # TODO: Enable the two tests timing out with Bazel:
         # - "src/ftxui/component/screen_interactive_test.cpp",
         # - "src/ftxui/dom/selection_test.cpp",
@@ -241,9 +266,12 @@ cc_test(
         "include",
         "src",
     ],
-    copts = cpp20() + windows_copts(),
+    copts = windows_copts(),
     deps = [
-        "//:ftxui",
+        ":screen",
+        ":dom",
+        ":component",
+        "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],
 )

CHANGELOG.md

@@ -1,22 +1,82 @@
 Changelog
 =========
 
-Future release
+Next
+====
+
+### Doc
+- Fix broken Doxygen output. See @markmandel in #1029.
+- Use Doxygen awesome. Add our own theme.
+- Break the documentation into several pages.
+
+### Build
+- Feature: Support C++20 modules. 
+  This requires:
+  - Using the Ninja or MSVC generator
+  - A recent Clang/GCC/MSVC compiler.
+  - Cmake 3.28 or higher.
+  Usage:
+  ```cpp
+  import ftxui;
+  import ftxui.component;
+  import ftxui.dom;
+  import ftxui.screen;
+  import ftxui.util;
+  ```
+  Thanks @mikomikotaishi for PR #1015.
+- Remove dependency on 'pthread'.
+- Bugfix: Bazel target @ftxui is now visible. Thanks @dskkato in #1157.
+
+### General
+- Breaking. Move to `std::string_view` instead of `const std::string&` where
+  applicable. This yields better interoperability with string literals and
+  avoids unnecessary copies. Thanks @mikomikotaishi for PR #1154
+
+### Component
+- Feature: POSIX Piped Input Handling.
+  - Allows FTXUI applications to read data from stdin (when piped) while still receiving keyboard input from the terminal.
+  - Enabled by default.
+  - Can be disabled using `ScreenInteractive::HandlePipedInput(false)`.
+  - Only available on Linux and macOS.
+  Thanks @HarryPehkonen for PR #1094.
+- Fix ScreenInteractive::FixedSize screen stomps on the preceding terminal
+  output. Thanks @zozowell in #1064.
+- Fix vertical `ftxui::Slider`. The "up" key was previously decreasing the
+  value. Thanks @its-pablo in #1093 for reporting the issue.
+- Fix Windows UTF-16 key input handling. Emoji and other code points outside the
+  Basic Multilingual Plane (BMP) are now correctly processed. Thanks @739C1AE2
+  in #1160 for fixing the issue.
+
+### Dom
+- Fix integer overflow in `ComputeShrinkHard`. Thanks @its-pablo in #1137 for
+  reporting and fixing the issue.
+- Add specialization for `vbox/hbox/dbox` to allow a container of Element as
+  as input. Thanks @nbusser in #1117.
+
+6.1.9 (2025-05-07)
 ------------
 
-6.1.7 (2025-05-01)
+### Build
+If all goes well (pending), ftxui should appear in the Bazel central repository.
+It can be imported into your project using the following lines:
+
+**MODULE.bazel**
+```bazel
+bazel_dep(name = "ftxui", version = "6.1.9")
+```
+
+Thanks @robinlinden and @kcc for the reviews.
+
+### dom
+- Bugfix: Restore the `dbox` behavior from ftxui 5.0.0. To apply bgcolor
+  blending between the two layers, a new `dboxBlend` will be added.
+
+6.1.8 (2025-05-01)
 ------------------
 
 ### Build
 - Feature: Support `bazel` build system. See #1032.
   Proposed by Kostya Serebryany @kcc
-  If all goes well (pending), it should appear in the Bazel central repository.
-  It can be imported into your project using the following lines:
-
-  **MODULE.bazel**
-  ```bazel
-  bazel_dep(name = "ftxui", version = "6.1.7")
-  ```
 
   **BUILD.bazel**
   ```bazel

CMakeLists.txt

@@ -1,20 +1,26 @@
-cmake_minimum_required(VERSION 3.12)
+option(FTXUI_BUILD_DOCS "Set to ON to build docs" OFF)
+option(FTXUI_BUILD_EXAMPLES "Set to ON to build examples" OFF)
+option(FTXUI_BUILD_MODULES "Build the C++20 modules" OFF)
+option(FTXUI_BUILD_TESTS "Set to ON to build tests" OFF)
+option(FTXUI_BUILD_TESTS_FUZZER "Set to ON to enable fuzzing" OFF)
+option(FTXUI_CLANG_TIDY "Execute clang-tidy" OFF)
+option(FTXUI_DEV_WARNINGS "Enable more compiler warnings and warnings as errors" OFF)
+option(FTXUI_ENABLE_COVERAGE "Execute code coverage" OFF)
+option(FTXUI_ENABLE_INSTALL "Generate the install target" ON)
+option(FTXUI_QUIET "Set to ON for FTXUI to be quiet" OFF)
+
+if (FTXUI_BUILD_MODULES)
+  cmake_minimum_required(VERSION 3.28.2)
+else()
+  cmake_minimum_required(VERSION 3.12)
+endif()
 
 project(ftxui
   LANGUAGES CXX
-  VERSION 6.1.7
+  VERSION 6.1.9
   DESCRIPTION "C++ Functional Terminal User Interface."
 )
 
-option(FTXUI_QUIET "Set to ON for FTXUI to be quiet" OFF)
-option(FTXUI_BUILD_EXAMPLES "Set to ON to build examples" OFF)
-option(FTXUI_BUILD_DOCS "Set to ON to build docs" OFF)
-option(FTXUI_BUILD_TESTS "Set to ON to build tests" OFF)
-option(FTXUI_BUILD_TESTS_FUZZER "Set to ON to enable fuzzing" OFF)
-option(FTXUI_ENABLE_INSTALL "Generate the install target" ON)
-option(FTXUI_CLANG_TIDY "Execute clang-tidy" OFF)
-option(FTXUI_ENABLE_COVERAGE "Execute code coverage" OFF)
-option(FTXUI_DEV_WARNINGS "Enable more compiler warnings and warnings as errors" OFF)
 
 set(FTXUI_MICROSOFT_TERMINAL_FALLBACK_HELP_TEXT "On windows, assume the \
 terminal used will be one of Microsoft and use a set of reasonnable fallback \
@@ -138,26 +144,20 @@ add_library(component
   src/ftxui/component/resizable_split.cpp
   src/ftxui/component/screen_interactive.cpp
   src/ftxui/component/slider.cpp
+  src/ftxui/component/task.cpp
+  src/ftxui/component/task_internal.hpp
+  src/ftxui/component/task_queue.cpp
+  src/ftxui/component/task_queue.hpp
+  src/ftxui/component/task_runner.cpp
+  src/ftxui/component/task_runner.hpp
   src/ftxui/component/terminal_input_parser.cpp
   src/ftxui/component/terminal_input_parser.hpp
   src/ftxui/component/util.cpp
   src/ftxui/component/window.cpp
 )
 
-target_link_libraries(dom
-  PUBLIC screen
-)
-
-target_link_libraries(component
-  PUBLIC dom
-)
-
-if (NOT EMSCRIPTEN)
-  find_package(Threads)
-  target_link_libraries(component
-    PUBLIC Threads::Threads
-  )
-endif()
+target_link_libraries(dom PUBLIC screen)
+target_link_libraries(component PUBLIC dom)
 
 include(cmake/ftxui_set_options.cmake)
 ftxui_set_options(screen)
@@ -176,6 +176,13 @@ include(cmake/iwyu.cmake)
 include(cmake/ftxui_export.cmake)
 include(cmake/ftxui_install.cmake)
 include(cmake/ftxui_package.cmake)
+include(cmake/ftxui_modules.cmake)
 
 add_subdirectory(examples)
 add_subdirectory(doc)
+
+# You can generate ./examples_modules/ by running
+# ./tools/generate_examples_modules.sh
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/examples_modules/CMakeLists.txt")
+  add_subdirectory(examples_modules)
+endif()

MODULE.bazel

@@ -1,13 +1,13 @@
-# Copyright 2025 Arthur Sonzogni. All rights reserved.
-# Use of this source code is governed by the MIT license that can be found in
-# the LICENSE file.
+# FTXUI module.
+module(
+    name = "ftxui",
+    version = "6.1.9",
+    compatibility_level = 6,
+)
 
-# FTXUI Module.
-module(name = "ftxui", version = "6.1.7")
-
-# Build deps.
+# Build dependencies.
 bazel_dep(name = "rules_cc", version = "0.1.1")
-bazel_dep(name = "platforms", version = "0.0.11")
+bazel_dep(name = "platforms", version = "0.0.10")
 
-# Test deps.
-bazel_dep(name = "googletest", version = "1.16.0.bcr.1")
+# Test dependencies.
+bazel_dep(name = "googletest", version = "1.14.0.bcr.1", dev_dependency = True)

README.md

@@ -1,3 +1,4 @@
+
 <p align="center">
   <img src="https://github.com/ArthurSonzogni/FTXUI/assets/4759106/6925b6da-0a7e-49d9-883c-c890e1f36007" alt="Demo image"></img>
   <br/>
@@ -18,10 +19,16 @@
   <br/>
   <a href="https://arthursonzogni.github.io/FTXUI/">Documentation</a> ·
   <a href="https://github.com/ArthurSonzogni/FTXUI/issues">Report a Bug</a> ·
-  <a href="https://arthursonzogni.github.io/FTXUI/examples.html">Examples</a> .
+  <a href="https://arthursonzogni.github.io/FTXUI/examples/">Examples</a> .
   <a href="https://github.com/ArthurSonzogni/FTXUI/issues">Request Feature</a> ·
   <a href="https://github.com/ArthurSonzogni/FTXUI/pulls">Send a Pull Request</a>
   
+  <br/>
+  <a href="https://github.com/ArthurSonzogni/">English</a> |
+  <a href="https://github.com/ArthurSonzogni/ftxui-translations/tree/zh-CH">中文翻译</a> |
+  <a href="https://github.com/ArthurSonzogni/ftxui-translations/tree/zh-CH">繁體中文</a> |
+  <a href="https://github.com/ArthurSonzogni/ftxui-translations/tree/ja">日本語</a>
+
 </p>
 
 # FTXUI
@@ -39,18 +46,30 @@ A simple cross-platform C++ library for terminal based user interfaces!
  * Support for [UTF8](https://en.wikipedia.org/wiki/UTF-8) and [fullwidth chars](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) (→ 测试)
  * Support for animations. [Demo 1](https://arthursonzogni.github.io/FTXUI/examples/?file=component/menu_underline_animated_gallery), [Demo 2](https://arthursonzogni.github.io/FTXUI/examples/?file=component/button_style)
  * Support for drawing. [Demo](https://arthursonzogni.github.io/FTXUI/examples/?file=component/canvas_animated)
- * No dependencies
+ * No dependencies.
+ * [C++20 Module support](https://arthursonzogni.github.io/FTXUI/cpp20-modules.html)
  * **Cross platform**: Linux/MacOS (main target), WebAssembly, Windows (Thanks to contributors!).
  * Learn by [examples](#documentation), and [tutorials](#documentation)
- * Multiple packages: CMake [FetchContent]([https://bewagner.net/programming/2020/05/02/cmake-fetchcontent/](https://cmake.org/cmake/help/latest/module/FetchContent.html)) (preferred),Bazel, vcpkg, pkgbuild, conan.
+ * Multiple packages:
+     - CMake [FetchContent]([https://bewagner.net/programming/2020/05/02/cmake-fetchcontent/](https://cmake.org/cmake/help/latest/module/FetchContent.html)) (preferred)
+     - [Bazel](https://registry.bazel.build/modules/ftxui)
+     - [vcpkg](https://vcpkg.link/ports/ftxui)
+     - [Conan](https://conan.io/center/recipes/ftxui) [Debian package](https://tracker.debian.org/pkg/ftxui)
+     - [Ubuntu package](https://launchpad.net/ubuntu/+source/ftxui)
+     - [Arch Linux](https://aur.archlinux.org/packages/ftxui/)
+    - [OpenSUSE](https://build.opensuse.org/package/show/devel:libraries:c_c++/ftxui)
+    - [XMake](https://xmake.io) repository [package](https://github.com/xmake-io/xmake-repo/blob/dev/packages/f/ftxui/xmake.lua)
+    - [Nix](https://github.com/ArthurSonzogni/FTXUI/blob/main/flake.nix)
  * Good practices: documentation, tests, fuzzers, performance tests, automated CI, automated packaging, etc...
 
 ## Documentation
 
-- [Starter example project](https://github.com/ArthurSonzogni/ftxui-starter)
+- [Starter CMake](https://github.com/ArthurSonzogni/ftxui-starter)
+- [Starter Bazel](https://github.com/ArthurSonzogni/ftxui-bazel)
 - [Documentation](https://arthursonzogni.github.io/FTXUI/)
 - [Examples (WebAssembly)](https://arthursonzogni.github.io/FTXUI/examples/)
 - [Build using CMake](https://arthursonzogni.github.io/FTXUI/#build-cmake)
+- [Build using Bazel](https://arthursonzogni.github.io/FTXUI/#build-bazel)
 
 ## Example
 ~~~cpp
@@ -86,7 +105,7 @@ Element can be arranged together:
   - inside a grid with `gridbox`
   - wrap along one direction using the `flexbox`.
   
-Element can become flexible using the the `flex` decorator.
+Element can become flexible using the `flex` decorator.
   
 [Example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2vbox_hbox_8cpp-example.html) using `hbox`, `vbox` and `filler`.
 
@@ -348,6 +367,11 @@ Feel free to add your projects here:
 - [terminal-rain](https://github.com/Oakamoore/terminal-rain)
 - [keywords](https://github.com/Oakamoore/keywords) ([Play web version :heart:](https://oakamoore.itch.io/keywords))
 - [FTB - tertminal file browser](https://github.com/Cyxuan0311/FTB)
+- [openJuice](https://github.com/mikomikotaishi/openJuice)
+- [SHOOT!](https://github.com/ShingZhanho/ENGG1340-Project-25Spring)
+- [VerifySN (Fast Hash Tool)](https://github.com/d06i/verifySN)
+- [tic-tac-toe](https://github.com/birland/tic-tac-toe)
+- [typing-speed-test](https://github.com/ymcx/typing-speed-test)
 
 ### [cpp-best-practices/game_jam](https://github.com/cpp-best-practices/game_jam)
 
@@ -364,38 +388,76 @@ Several games using the FTXUI have been made during the Game Jam:
 - [smoothlife](https://github.com/cpp-best-practices/game_jam/blob/main/Jam1_April_2022/smoothlife.md)
 - [Consu](https://github.com/cpp-best-practices/game_jam/blob/main/Jam1_April_2022/consu.md)
 
-## Utilization
+
+
+## Build using CMake
 
 It is **highly** recommended to use CMake FetchContent to depend on FTXUI so you may specify which commit you would like to depend on.
 ```cmake
 include(FetchContent)
-
 FetchContent_Declare(ftxui
   GIT_REPOSITORY https://github.com/ArthurSonzogni/ftxui
-  GIT_TAG v6.1.7
+  GIT_TAG v6.1.9
 )
+FetchContent_MakeAvailable(ftxui)
 
-FetchContent_GetProperties(ftxui)
-if(NOT ftxui_POPULATED)
-  FetchContent_Populate(ftxui)
-  add_subdirectory(${ftxui_SOURCE_DIR} ${ftxui_BINARY_DIR} EXCLUDE_FROM_ALL)
-endif()
+target_link_libraries(your_target PRIVATE
+    # Chose a submodule
+    ftxui::component
+    ftxui::dom
+    ftxui::screen
+)
 ```
 
+# Build using Bazel
+
+**MODULE.bazel**
+```starlark
+bazel_dep(
+    name = "ftxui",
+    version = "v6.1.9",
+)
+```
+
+**BUILD.bazel**
+```starlark
+cc_binary(
+    name = "your_target",
+    srcs = ["your_source.cc"],
+    deps = [
+        # Choose submodules
+        "@ftxui//:component",
+        "@ftxui//:dom",
+        "@ftxui//:screen",
+        
+        # Or use the single ftxui target (includes all modules)
+        # "@ftxui//:ftxui",
+    ],
+)
+```
+
+
+# Build with something else:
 If you don't, FTXUI may be used from the following packages:
-- [bazel](...)
-- [vcpkg](https://vcpkgx.com/details.html?package=ftxui)
-- [Arch Linux PKGBUILD](https://aur.archlinux.org/packages/ftxui-git/).
-- [conan.io](https://conan.io/center/ftxui)
-- [openSUSE](https://build.opensuse.org/package/show/devel:libraries:c_c++/ftxui)
-- 
+- CMake [FetchContent]([https://bewagner.net/programming/2020/05/02/cmake-fetchcontent/](https://cmake.org/cmake/help/latest/module/FetchContent.html)) (preferred),
+- [Bazel](https://registry.bazel.build/modules/ftxui),
+- [vcpkg](https://vcpkg.link/ports/ftxui),
+- [Conan](https://conan.io/center/recipes/ftxui)
+- [Debian package](https://tracker.debian.org/pkg/ftxui),
+- [Ubuntu package](https://launchpad.net/ubuntu/+source/ftxui),
+- [Arch Linux](https://aur.archlinux.org/packages/ftxui/),
+- [OpenSUSE](https://build.opensuse.org/package/show/devel:libraries:c_c++/ftxui),
+[Nix](https://github.com/ArthurSonzogni/FTXUI/blob/main/flake.nix),
 [![Packaging status](https://repology.org/badge/vertical-allrepos/libftxui.svg)](https://repology.org/project/libftxui/versions)
 
+
 If you choose to build and link FTXUI yourself, `ftxui-component` must be first in the linking order relative to the other FTXUI libraries, i.e.
 ```bash
 g++ . . . -lftxui-component -lftxui-dom -lftxui-screen . . .
 ```
 
+To build FTXUI with modules, check [documentation](https://arthursonzogni.github.io/FTXUI/cpp20-modules.html)
+
 ## Contributors
 
 <a href="https://github.com/ArthurSonzogni/FTXUI/graphs/contributors">

bazel/ftxui.bzl

@@ -1,24 +1,7 @@
 # ftxui_common.bzl
 
 load("@rules_cc//cc:defs.bzl", "cc_library")
-
-def cpp17():
-    return select({
-        "@rules_cc//cc/compiler:msvc-cl": ["/std:c++17"],
-        "@rules_cc//cc/compiler:clang-cl": ["/std:c++17"],
-        "@rules_cc//cc/compiler:clang": ["-std=c++17"],
-        "@rules_cc//cc/compiler:gcc": ["-std=c++17"],
-        "//conditions:default": ["-std=c++17"],
-    })
-
-def cpp20():
-    return select({
-        "@rules_cc//cc/compiler:msvc-cl": ["/std:c++20"],
-        "@rules_cc//cc/compiler:clang-cl": ["/std:c++20"],
-        "@rules_cc//cc/compiler:clang": ["-std=c++20"],
-        "@rules_cc//cc/compiler:gcc": ["-std=c++20"],
-        "//conditions:default": ["-std=c++20"],
-    })
+load("@rules_cc//cc:defs.bzl", "cc_binary")
 
 # Microsoft terminal is a bit buggy ¯\_(ツ)_/¯ and MSVC uses bad defaults.
 def windows_copts():
@@ -45,7 +28,8 @@ def windows_copts():
       # This
       # - Replace missing font symbols by others.
       # - Reduce screen position pooling frequency to deals against a Microsoft
-      #   race condition. This was fixed in 2020, but clients never not updated.
+      #   race condition. This was fixed in 2020, but clients are still using
+      #   old versions.
       #   - https://github.com/microsoft/terminal/pull/7583
       #   - https://github.com/ArthurSonzogni/FTXUI/issues/136
       "-DFTXUI_MICROSOFT_TERMINAL_FALLBACK",
@@ -59,20 +43,10 @@ def windows_copts():
         "//conditions:default": [],
     })
 
-def pthread_linkopts():
-    return select({
-        # With MSVC, threading is already built-in (you don't need -pthread.
-        "@rules_cc//cc/compiler:msvc-cl": [],
-        "@rules_cc//cc/compiler:clang-cl": [],
-        "@rules_cc//cc/compiler:clang": ["-pthread"],
-        "@rules_cc//cc/compiler:gcc": ["-pthread"],
-        "//conditions:default": ["-pthread"],
-    })
-
 def ftxui_cc_library(
         name,
-        srcs,
-        hdrs,
+        srcs = [],
+        hdrs = [],
         linkopts = [],
         deps = []):
 
@@ -88,12 +62,13 @@ def ftxui_cc_library(
             "include",
             "src",
         ],
-        copts = cpp17() + windows_copts(),
+        copts = windows_copts(),
         visibility = ["//visibility:public"],
     )
 
 # Compile all the examples in the examples/ directory.
-# This is useful to check the Bazel is synchronized with CMake definitions.
+# This is useful to check the Bazel is always synchronized against CMake
+# definitions.
 def generate_examples():
     cpp_files = native.glob(["examples/**/*.cpp"])
 
@@ -107,9 +82,13 @@ def generate_examples():
         # Turn "examples/component/button.cpp" → "example_component_button"
         name = src.replace("/", "_").replace(".cpp", "")
 
-        native.cc_binary(
+        cc_binary(
             name = name,
             srcs = [src],
-            deps = ["//:component"],
-            copts = cpp20() + windows_copts(),
+            deps = [
+              ":component",
+              ":dom",
+              ":screen",
+            ],
+            copts = windows_copts(),
         )

bazel/test/.bazelrc

@@ -0,0 +1 @@
+../../.bazelrc

bazel/test/BUILD.bazel

@@ -0,0 +1,23 @@
+# Copyright 2025 Arthur Sonzogni. All rights reserved.
+# Use of this source code is governed by the MIT license that can be found in
+# the LICENSE file.
+
+# Test using individual submodules
+cc_binary(
+    name = "smoke",
+    srcs = ["smoke.cpp"],
+    deps = [
+        "@ftxui//:component",
+        "@ftxui//:dom",
+        "@ftxui//:screen",
+    ],
+)
+
+# Test using the single ftxui target
+cc_binary(
+    name = "smoke_single_dependency",
+    srcs = ["smoke.cpp"],
+    deps = [
+        "@ftxui",
+    ],
+)

bazel/test/MODULE.bazel

@@ -0,0 +1,9 @@
+# Copyright 2025 Arthur Sonzogni. All rights reserved.
+# Use of this source code is governed by the MIT license that can be found in
+# the LICENSE file.
+module(
+    name = "ftxui_integration_test",
+    version = "0.0.1",
+)
+
+bazel_dep(name = "ftxui", version = "6.1.9")

bazel/test/README.md

@@ -0,0 +1,38 @@
+# FTXUI Bazel Integration Test
+
+This directory contains integration tests to verify that FTXUI can be properly consumed as an external dependency using Bazel with Bzlmod.
+
+## Purpose
+
+These tests ensure that:
+- FTXUI's public API is correctly exposed to external projects
+- Both single-target (`@ftxui//:ftxui`) and submodule-based dependencies work correctly
+- Headers are properly re-exported and accessible from downstream projects
+
+## Build Instructions
+
+To build all targets:
+
+```bash
+bazel build //... --enable_bzlmod --override_module=ftxui=../..
+```
+
+To build individual targets:
+
+```bash
+# Test using individual submodules
+bazel build //:smoke --enable_bzlmod --override_module=ftxui=../..
+
+# Test using the single ftxui target
+bazel build //:smoke_single_dependency --enable_bzlmod --override_module=ftxui=../..
+```
+
+## Run the Examples
+
+```bash
+# Run the submodules version
+./bazel-bin/smoke
+
+# Run the single-target version
+./bazel-bin/smoke_single_dependency
+```

bazel/test/WORKSPACE.bazel

@@ -0,0 +1,4 @@
+# Copyright 2025 Arthur Sonzogni. All rights reserved.
+# Use of this source code is governed by the MIT license that can be found in
+# the LICENSE file.
+workspace(name = "ftxui_smoke_test")

bazel/test/smoke.cpp

@@ -0,0 +1,16 @@
+// Copyright 2025 Arthur Sonzogni. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+#include <ftxui/dom/elements.hpp>
+#include <ftxui/screen/screen.hpp>
+#include <ftxui/component/component.hpp>
+#include <ftxui/component/screen_interactive.hpp>
+
+int main() {
+  using namespace ftxui;
+  auto screen = ScreenInteractive::TerminalOutput();
+  auto component = Button("Quit", screen.ExitLoopClosure());
+  screen.Loop(component);
+  return 0;
+}
+

cmake/ftxui_find_google_test.cmake

@@ -13,7 +13,7 @@ include(FetchContent)
 
 FetchContent_Declare(googletest
   GIT_REPOSITORY "https://github.com/google/googletest"
-  GIT_TAG        23ef29555ef4789f555f1ba8c51b4c52975f0907
+  GIT_TAG        52eb8108c5bdec04579160ae17225d66034bd723 # v1.17.0
   GIT_PROGRESS   TRUE
 )
 

cmake/ftxui_install.cmake

@@ -11,6 +11,9 @@ include(CMakePackageConfigHelpers)
 install(
   TARGETS screen dom component
   EXPORT ftxui-targets
+  ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
   )
 
 install(

cmake/ftxui_message.cmake

@@ -5,13 +5,14 @@ function(ftxui_message msg)
 endfunction()
 
 ftxui_message("┌─ FTXUI options ─────────────────────")
-ftxui_message("│ FTXUI_ENABLE_INSTALL     : ${FTXUI_ENABLE_INSTALL}")
-ftxui_message("│ FTXUI_BUILD_EXAMPLES     : ${FTXUI_BUILD_EXAMPLES}")
-ftxui_message("│ FTXUI_QUIET              : ${FTXUI_QUIET}")
 ftxui_message("│ FTXUI_BUILD_DOCS         : ${FTXUI_BUILD_DOCS}")
+ftxui_message("│ FTXUI_BUILD_EXAMPLES     : ${FTXUI_BUILD_EXAMPLES}")
+ftxui_message("│ FTXUI_BUILD_MODULES      : ${FTXUI_BUILD_MODULES}")
 ftxui_message("│ FTXUI_BUILD_TESTS        : ${FTXUI_BUILD_TESTS}")
 ftxui_message("│ FTXUI_BUILD_TESTS_FUZZER : ${FTXUI_BUILD_TESTS_FUZZER}")
-ftxui_message("│ FTXUI_ENABLE_COVERAGE    : ${FTXUI_ENABLE_COVERAGE}")
-ftxui_message("│ FTXUI_DEV_WARNINGS       : ${FTXUI_DEV_WARNINGS}")
 ftxui_message("│ FTXUI_CLANG_TIDY         : ${FTXUI_CLANG_TIDY}")
+ftxui_message("│ FTXUI_DEV_WARNINGS       : ${FTXUI_DEV_WARNINGS}")
+ftxui_message("│ FTXUI_ENABLE_COVERAGE    : ${FTXUI_ENABLE_COVERAGE}")
+ftxui_message("│ FTXUI_ENABLE_INSTALL     : ${FTXUI_ENABLE_INSTALL}")
+ftxui_message("│ FTXUI_QUIET              : ${FTXUI_QUIET}")
 ftxui_message("└─────────────────────────────────────")

cmake/ftxui_modules.cmake

@@ -0,0 +1,83 @@
+if (NOT FTXUI_BUILD_MODULES)
+  return()
+endif()
+
+add_library(ftxui-modules)
+
+target_sources(ftxui-modules
+  PUBLIC FILE_SET CXX_MODULES FILES
+  src/ftxui/ftxui.cppm
+  src/ftxui/component.cppm
+  src/ftxui/component/animation.cppm
+  src/ftxui/component/captured_mouse.cppm
+  src/ftxui/component/component.cppm
+  src/ftxui/component/component_base.cppm
+  src/ftxui/component/component_options.cppm
+  src/ftxui/component/event.cppm
+  src/ftxui/component/loop.cppm
+  src/ftxui/component/mouse.cppm
+  src/ftxui/component/receiver.cppm
+  src/ftxui/component/screen_interactive.cppm
+  src/ftxui/component/task.cppm
+  src/ftxui/dom.cppm
+  src/ftxui/dom/canvas.cppm
+  src/ftxui/dom/deprecated.cppm
+  src/ftxui/dom/direction.cppm
+  src/ftxui/dom/elements.cppm
+  src/ftxui/dom/flexbox_config.cppm
+  src/ftxui/dom/linear_gradient.cppm
+  src/ftxui/dom/node.cppm
+  src/ftxui/dom/requirement.cppm
+  src/ftxui/dom/selection.cppm
+  src/ftxui/dom/table.cppm
+  src/ftxui/screen.cppm
+  src/ftxui/screen/box.cppm
+  src/ftxui/screen/color.cppm
+  src/ftxui/screen/color_info.cppm
+  src/ftxui/screen/deprecated.cppm
+  src/ftxui/screen/image.cppm
+  src/ftxui/screen/pixel.cppm
+  src/ftxui/screen/screen.cppm
+  src/ftxui/screen/string.cppm
+  src/ftxui/screen/terminal.cppm
+  src/ftxui/util.cppm
+  src/ftxui/util/autoreset.cppm
+  src/ftxui/util/ref.cppm
+  )
+
+target_link_libraries(ftxui-modules
+  PUBLIC
+  ftxui::screen
+  ftxui::dom
+  ftxui::component
+  )
+
+target_compile_features(ftxui-modules PUBLIC cxx_std_20)
+# TODO: Explain why this is needed.
+if (CMAKE_COMPILER_IS_GNUCXX)
+  target_compile_options(ftxui-modules PUBLIC -fmodules-ts)
+endif ()
+
+add_library(ftxui::modules ALIAS ftxui-modules)
+
+if(FTXUI_ENABLE_INSTALL)
+
+  include(GNUInstallDirs)
+
+  install(TARGETS ftxui-modules
+    EXPORT ftxui-targets
+    FILE_SET CXX_MODULES
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/ftxui
+    FILE_SET HEADERS
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/ftxui
+    INCLUDES
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/ftxui
+    )
+  install(EXPORT ftxui-targets
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/ftxui
+    CXX_MODULES_DIRECTORY ${CMAKE_INSTALL_LIBDIR}/cmake/ftxui
+    )
+  install(FILES my_package-config.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/ftxui
+    )
+endif()

cmake/ftxui_set_options.cmake

@@ -101,6 +101,5 @@ endfunction()
 
 if (EMSCRIPTEN)
   string(APPEND CMAKE_CXX_FLAGS " -s USE_PTHREADS")
-  string(APPEND CMAKE_EXE_LINKER_FLAGS " -s ASYNCIFY")
   string(APPEND CMAKE_EXE_LINKER_FLAGS " -s PROXY_TO_PTHREAD")
 endif()

cmake/ftxui_test.cmake

@@ -19,11 +19,10 @@ add_executable(ftxui-tests
   src/ftxui/component/menu_test.cpp
   src/ftxui/component/modal_test.cpp
   src/ftxui/component/radiobox_test.cpp
-  src/ftxui/util/ref_test.cpp
-  src/ftxui/component/receiver_test.cpp
   src/ftxui/component/resizable_split_test.cpp
   src/ftxui/component/screen_interactive_test.cpp
   src/ftxui/component/slider_test.cpp
+  src/ftxui/component/task_test.cpp
   src/ftxui/component/terminal_input_parser_test.cpp
   src/ftxui/component/toggle_test.cpp
   src/ftxui/dom/blink_test.cpp
@@ -51,6 +50,7 @@ add_executable(ftxui-tests
   src/ftxui/dom/vbox_test.cpp
   src/ftxui/screen/color_test.cpp
   src/ftxui/screen/string_test.cpp
+  src/ftxui/util/ref_test.cpp
 )
 
 target_link_libraries(ftxui-tests

doc/CMakeLists.txt

@@ -8,13 +8,63 @@ if (NOT DOXYGEN_FOUND)
   return()
 endif()
 
+include(FetchContent)
+FetchContent_Declare(
+    doxygen-awesome-css
+    GIT_REPOSITORY https://github.com/jothepro/doxygen-awesome-css.git
+    GIT_TAG v2.3.4
+
+)
+FetchContent_MakeAvailable(doxygen-awesome-css)
+FetchContent_GetProperties(doxygen-awesome-css SOURCE_DIR AWESOME_CSS_DIR)
+
 # Generate example list for documentation
-set(EXAMPLE_LIST "${CMAKE_CURRENT_BINARY_DIR}/example_list.md")
-file(WRITE ${EXAMPLE_LIST} "# Examples")
+set(DOM_EXAMPLES "")
+set(COMPONENT_EXAMPLES "")
+
 get_property(EXAMPLES GLOBAL PROPERTY FTXUI::EXAMPLES)
-foreach(EXAMPLE IN LISTS EXAMPLES)
-  file(APPEND ${EXAMPLE_LIST} "\n@example examples/${EXAMPLE}.cpp")
-endforeach(EXAMPLE IN LISTS EXAMPLES)
+
+foreach(example IN LISTS EXAMPLES)
+  if(example MATCHES "^dom/.*")
+    list(APPEND DOM_EXAMPLES "${example}")
+  elseif(example MATCHES "^component/.*")
+    list(APPEND COMPONENT_EXAMPLES "${example}")
+  else()
+    message(ERROR "Unknown example '${example}'")
+  endif()
+endforeach()
+
+macro(write_example_list file title page examples)
+  file(WRITE "${file}" "@page ${page} ${title}\n")
+  file(APPEND "${file}" "@tableofcontents\n")
+
+  foreach(example IN LISTS ${examples})
+    get_filename_component(name "${example}" NAME_WE)
+    file(APPEND "${file}" "# ${name}\n")
+
+    # Add a markdown  to the demo. URL example:
+    # https://arthursonzogni.github.io/FTXUI/examples/?file=component/canvas_animated
+    file(APPEND "${file}" "[Demo](https://arthursonzogni.github.io/FTXUI/examples/?file=${example})\n")
+
+    file(APPEND "${file}" "@include examples/${example}.cpp\n")
+    file(APPEND "${file}" "\n")
+  endforeach()
+
+  # Reference to the examples
+  foreach(example IN LISTS ${examples})
+    get_filename_component(name "${example}" NAME_WE)
+    file(APPEND "${file}" "@example examples/${example}.cpp\n")
+  endforeach()
+endmacro()
+
+write_example_list("${CMAKE_CURRENT_BINARY_DIR}/dom_examples.md"
+  "Example"
+  module-dom-examples
+  DOM_EXAMPLES)
+write_example_list("${CMAKE_CURRENT_BINARY_DIR}/component_examples.md"
+  "Example"
+  module-component-examples
+  COMPONENT_EXAMPLES)
 
 configure_file(Doxyfile.in Doxyfile @ONLY)
 

doc/DoxygenLayout.xml

@@ -1,44 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
 <doxygenlayout version="1.0">
+  <!-- Generated by doxygen 1.12.0 -->
   <!-- Navigation index tabs for HTML output -->
   <navindex>
-    <tab type="mainpage" visible="yes" title="Tutorial"/>
-    <tab type="examples" visible="yes" title="" intro=""/>  
-    <tab type="filelist" visible="yes" title=""/>
-
-    <tab type="pages" visible="no" title="" intro=""/>
-    <tab type="modules" visible="yes" title="" intro=""/>
+    <tab type="mainpage" visible="no" title=""/>
+    <tab type="pages" visible="yes" title="Pages" intro=""/>
+    <tab type="topics" visible="yes" title="Reference" intro=""/>
+    <tab type="modules" visible="yes" title="" intro="">
+      <tab type="modulelist" visible="yes" title="" intro=""/>
+      <tab type="modulemembers" visible="yes" title="" intro=""/>
+    </tab>
     <tab type="namespaces" visible="yes" title="">
       <tab type="namespacelist" visible="yes" title="" intro=""/>
       <tab type="namespacemembers" visible="yes" title="" intro=""/>
     </tab>
-    <tab type="interfaces" visible="no" title="">
+    <tab type="concepts" visible="yes" title="">
+    </tab>
+    <tab type="interfaces" visible="yes" title="">
       <tab type="interfacelist" visible="yes" title="" intro=""/>
       <tab type="interfaceindex" visible="$ALPHABETICAL_INDEX" title=""/>
       <tab type="interfacehierarchy" visible="yes" title="" intro=""/>
     </tab>
-    <tab type="classes" visible="no" title="">
+    <tab type="classes" visible="yes" title="">
       <tab type="classlist" visible="yes" title="" intro=""/>
       <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
       <tab type="hierarchy" visible="yes" title="" intro=""/>
       <tab type="classmembers" visible="yes" title="" intro=""/>
     </tab>
-    <tab type="structs" visible="no" title="">
+    <tab type="structs" visible="yes" title="">
       <tab type="structlist" visible="yes" title="" intro=""/>
       <tab type="structindex" visible="$ALPHABETICAL_INDEX" title=""/>
     </tab>
-    <tab type="exceptions" visible="no" title="">
+    <tab type="exceptions" visible="yes" title="">
       <tab type="exceptionlist" visible="yes" title="" intro=""/>
       <tab type="exceptionindex" visible="$ALPHABETICAL_INDEX" title=""/>
       <tab type="exceptionhierarchy" visible="yes" title="" intro=""/>
     </tab>
+
+    <tab type="files" visible="yes" title="">
+      <tab type="filelist" visible="yes" title="" intro=""/>
+      <tab type="globals" visible="yes" title="" intro=""/>
+    </tab>
+
+    <tab type="examples" visible="yes" title="" intro=""/>
   </navindex>
 
   <!-- Layout definition for a class page -->
   <class>
     <briefdescription visible="yes"/>
-    <includes visible="$SHOW_INCLUDE_FILES"/>
-    <inheritancegraph visible="$CLASS_GRAPH"/>
-    <collaborationgraph visible="$COLLABORATION_GRAPH"/>
+    <includes visible="$SHOW_HEADERFILE"/>
+    <inheritancegraph visible="yes"/>
+    <collaborationgraph visible="yes"/>
     <memberdecl>
       <nestedclasses visible="yes" title=""/>
       <publictypes title=""/>
@@ -96,19 +108,20 @@
   <namespace>
     <briefdescription visible="yes"/>
     <memberdecl>
-      <functions title=""/>
-      <enums title=""/>
-      <typedefs title=""/>
-      <classes visible="yes" title=""/>
-      <structs visible="yes" title=""/>
-
       <nestednamespaces visible="yes" title=""/>
       <constantgroups visible="yes" title=""/>
       <interfaces visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <concepts visible="yes" title=""/>
+      <structs visible="yes" title=""/>
       <exceptions visible="yes" title=""/>
+      <typedefs title=""/>
       <sequences title=""/>
       <dictionaries title=""/>
+      <enums title=""/>
+      <functions title=""/>
       <variables title=""/>
+      <properties title=""/>
       <membergroups visible="yes"/>
     </memberdecl>
     <detaileddescription title=""/>
@@ -120,16 +133,26 @@
       <enums title=""/>
       <functions title=""/>
       <variables title=""/>
+      <properties title=""/>
     </memberdef>
     <authorsection visible="yes"/>
   </namespace>
 
+  <!-- Layout definition for a concept page -->
+  <concept>
+    <briefdescription visible="yes"/>
+    <includes visible="$SHOW_HEADERFILE"/>
+    <definition visible="yes" title=""/>
+    <detaileddescription title=""/>
+    <authorsection visible="yes"/>
+  </concept>
+
   <!-- Layout definition for a file page -->
   <file>
     <briefdescription visible="yes"/>
     <includes visible="$SHOW_INCLUDE_FILES"/>
-    <includegraph visible="$INCLUDE_GRAPH"/>
-    <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
+    <includegraph visible="yes"/>
+    <includedbygraph visible="yes"/>
     <sourcelink visible="yes"/>
     <memberdecl>
       <interfaces visible="yes" title=""/>
@@ -137,6 +160,7 @@
       <structs visible="yes" title=""/>
       <exceptions visible="yes" title=""/>
       <namespaces visible="yes" title=""/>
+      <concepts visible="yes" title=""/>
       <constantgroups visible="yes" title=""/>
       <defines title=""/>
       <typedefs title=""/>
@@ -145,6 +169,7 @@
       <enums title=""/>
       <functions title=""/>
       <variables title=""/>
+      <properties title=""/>
       <membergroups visible="yes"/>
     </memberdecl>
     <detaileddescription title=""/>
@@ -157,19 +182,24 @@
       <enums title=""/>
       <functions title=""/>
       <variables title=""/>
+      <properties title=""/>
     </memberdef>
     <authorsection/>
   </file>
 
   <!-- Layout definition for a group page -->
   <group>
-    <briefdescription visible="yes"/>
-    <groupgraph visible="$GROUP_GRAPHS"/>
+    <briefdescription visible="no"/>
+    <authorsection visible="no"/>
+    <detaileddescription title=""/>
+    <groupgraph visible="yes"/>
     <memberdecl>
       <nestedgroups visible="yes" title=""/>
+      <modules visible="yes" title=""/>
       <dirs visible="yes" title=""/>
       <files visible="yes" title=""/>
       <namespaces visible="yes" title=""/>
+      <concepts visible="yes" title=""/>
       <classes visible="yes" title=""/>
       <defines title=""/>
       <typedefs title=""/>
@@ -188,7 +218,6 @@
       <friends title=""/>
       <membergroups visible="yes"/>
     </memberdecl>
-    <detaileddescription title=""/>
     <memberdef>
       <pagedocs/>
       <inlineclasses title=""/>
@@ -208,9 +237,27 @@
       <properties title=""/>
       <friends title=""/>
     </memberdef>
-    <authorsection visible="yes"/>
   </group>
 
+  <!-- Layout definition for a C++20 module page -->
+  <module>
+    <briefdescription visible="yes"/>
+    <exportedmodules visible="yes"/>
+    <memberdecl>
+      <concepts visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <enums title=""/>
+      <typedefs title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <membergroups title=""/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdecl>
+      <files visible="yes"/>
+    </memberdecl>
+  </module>
+
   <!-- Layout definition for a directory page -->
   <directory>
     <briefdescription visible="yes"/>

doc/cpp20-modules.md

@@ -0,0 +1,78 @@
+@page cpp20-modules C++20 Modules
+
+
+> [!WARNING]
+> This feature is still in development, and the API may change in future releases.
+> Your contribution is needed to help us improve the compatibility and usability
+> of C++ modules in FTXUI. If you encounter any issues or have suggestions,
+> please open an issue.
+
+FTXUI experimentally supports
+[C++20 modules](https://en.cppreference.com/w/cpp/language/modules) to reduce
+compilation times and improve code organization. Each part of the library has a
+corresponding module, split into partitions per each header.
+
+Use the FTXUI_BUILD_MODULES option to build the FTXUI project itself to provide C++20 modules,
+for example with CMake and Ninja:
+
+```sh
+cmake \
+    -DCMAKE_GENERATOR=Ninja \
+    -DFTXUI_BUILD_MODULES=ON \
+    ..
+
+ninja
+```
+
+> [!NOTE]
+> To use modules, you need a C++≥20 compatible compiler, CMake version 3.20 or
+> higher, and use a compatible generator like Ninja. Note that Makefile
+> generators **do not support modules**.
+
+Then, in your own code you can consume the modules and code as normal:
+
+```cpp
+import ftxui;
+
+using ftxui::Button;
+using ftxui::ScreenInteractive;
+
+int main() {
+  auto screen = ScreenInteractive::TerminalOutput();
+  auto button = Button("Click me", screen.QuitClosure());
+  screen.Loop(button);
+  return 0;
+}
+```
+
+Note, the `ftxui` convenience module which simply pulls together all the modules:
+
+```cpp
+export import ftxui.component;
+export import ftxui.dom;
+export import ftxui.screen;
+export import ftxui.util;
+```
+You can instead import only the module(s) you need if desired.
+
+To properly find and link the modules with CMake, use `target_link_libraries` to get the right
+compiler, linker, etc. flags.
+
+```cmake
+target_link_libraries(my_executable
+    #...whatever...
+    PRIVATE ftxui::modules
+)
+```
+
+### Module list
+
+The modules directly reference the corresponding header, or a group of related
+headers to provide a more convenient interface. The following modules
+are available:
+
+- `ftxui`
+    - `ftxui.component`
+    - `ftxui.dom`
+    - `ftxui.screen`
+    - `ftxui.util`

doc/doxygen_extra.css

@@ -1,323 +0,0 @@
-/*
- *  GitHub Markdown style CSS for doxygen 1.8.14
- *  Source:  https://github.com/sindresorhus/github-markdown-css
- *  License: MIT <20> Sindre Sorhus
- */
-
-* {
-  box-sizing: border-box;
-}
-
-body, table, div, p, dl {
-  -ms-text-size-adjust: 100%;
-  -webkit-text-size-adjust: 100%;
-  line-height: 1.5;
-  color: #24292e;
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
-  font-size: 16px;
-  word-wrap: break-word;
-}
-
-b {
-  font-weight: 600;
-}
-
-/* @group Heading Levels */
-
-h1, h2, h3, h4, h5, h6 {
-  font-weight: 600;
-  line-height: 1.25;
-  margin-top: 24px;
-  margin-bottom: 16px;
-}
-
-h1 {
-  font-size: 2em;
-  padding-bottom: 0.3em;
-  border-bottom: 1px solid #eaecef;
-}
-
-h2 {
-  padding-bottom: 0.3em;
-  font-size: 1.5em;
-  border-bottom: 1px solid #eaecef;
-}
-
-h3 {
-  font-size: 1.25em;
-}
-
-h4 {
-  font-size: 1em;
-}
-
-h5 {
-  font-size: 0.875em;
-}
-
-h6 {
-  font-size: 0.85em;
-  color: #6a737d;
-}
-
-a {
-  background-color: transparent;
-  color: #0366d6;
-  text-decoration: none;
-  font-weight: normal;
-}
-
-.contents a:visited {
-  color: #0366d6;
-}
-
-a:active, a:hover {
-  outline-width: 0;
-}
-
-a:hover {
-  text-decoration: underline;
-}
-
-a:not([href]) {
-  color: inherit;
-  text-decoration: none;
-}
-
-a.el {
-  font-weight: normal;
-}
-
-.image {
-  text-align: left;
-}
-
-.tip {
-  background-image: url(tip.png);
-  background-position: left center;
-  background-repeat: no-repeat;
-  padding-left: 30px;
-  margin-top: 1em;
-  margin-bottom: 1em;
-  min-height: 31px;
-  display: block;
-  font-style:italic;
-}
-
-.warn {
-  background-image: url(warn.png);
-  background-position: left center;
-  background-repeat: no-repeat;
-  padding-left: 48px;
-  margin-top: 1em;
-  margin-bottom: 1em;
-  min-height: 31px;
-  display: block;
-  font-style:italic;
-}
-
-#projectname {
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
-  font-size: 2em;
-  font-weight: bold;
-}
-
-#projectbrief {
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
-  font-size: 0.8em;
-}
-
-#projectnumber {
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
-  font-size: 1em;
-}
-
-div.contents {
-  width: 980px;
-  padding: 40px;
-  margin-top: -1px;
-  margin-left: auto;
-  margin-right: auto;
-  margin-bottom: 10px;
-  border: 1px solid #d1d5da;
-  border-radius: 2px;
-}
-
-div.toc {
-  border: 0 none;
-  border-radius: 7px;
-}
-
-div.header {
-  width: 980px;
-  padding: 10px;
-  margin-top: 10px;
-  margin-left: auto;
-  margin-right: auto;
-  background-image: none;
-  background-repeat: none;
-  background-color: #f6f8fa;
-  border: 1px solid #d1d5da;
-}
-
-div.headertitle {
-  padding: 0;
-}
-
-.title ol {
-  margin: 0;
-}
-
-.title ol li {
-  list-style-type: none;
-}
-
-.ui-resizable-e {
-  background: none;
-  background-color: #E6E6E6;
-}
-
-div.fragment {
-  background-color: #f3f3f3;
-  border-radius:5px;
-  border: 0 solid;
-  border: none;
-  padding:16px;
-  transition: all 0.5s ease-in-out;
-}
-
-div.fragment:hover {
-  background-color: #e9e9e9;
-  box-shadow: 0 5px 10px -5px rgb(0,0,0,0.5) inset;
-}
-
-div.line {
-  font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace;
-  font-size: 90%;
-  font-variant-numeric: tabular-nums lining-nums;
-  font-kerning: none;
-  -webkit-transition-duration: 0;
-  -moz-transition-duration: 0;
-  -ms-transition-duration: 0;
-  -o-transition-duration: 0;
-  transition-duration: 0;
-}
-
-div.line.glow {
-  background-color: auto;
-  box-shadow: none;
-}
-
-/* @group Code Colorization */
-span.keyword {
-  color: #808000
-}
-
-span.keywordtype {
-  color: #808000
-}
-
-span.keywordflow {
-  color: #808000
-}
-
-span.comment {
-  color: #008000
-}
-
-span.preprocessor {
-  color: #800000
-}
-
-span.stringliteral {
-  color: #000080
-}
-
-span.charliteral {
-  color: #000080
-}
-
-blockquote {
-  background-color: #EEEEEE;
-  border-left: 2px solid #606060;
-  margin: 0 24px 0 4px;
-  padding: 0 12px 0 16px;
-}
-
-/* @end */
-
-.arrow {
-  box-sizing: content-box;
-}
-
-img {
-  max-width: 100%;
-  max-height: 100%;
-}
-
-#nav-tree {
-  background-image: none;
-  background-color: white;
-}
-
-#nav-tree .label {
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
-  font-size: 14px;
-}
-
-#side-nav {
-  width: 25%;
-  max-width: 50%;
-}
-
-.memtitle {
-  background-image: none;
-}
-
-.memproto {
-  text-shadow: none;
-  /* opera specific markup */
-  box-shadow: none;
-  /* firefox specific markup */
-  -moz-box-shadow: none;
-  -moz-border-radius-topright: 4px;
-  /* webkit specific markup */
-  -webkit-box-shadow: none;
-  -webkit-border-top-right-radius: 4px;
-}
-
-.memdoc {
-  background-image:none;
-  background-repeat:repeat-x;
-  background-color: #FFFFFF;
-  /* opera specific markup */
-  box-shadow: none;
-  /* firefox specific markup */
-  -moz-box-shadow: none;
-  /* webkit specific markup */
-  -webkit-box-shadow: none;
-}
-
-#main-menu {
-  background: none;
-  border-bottom: 1px solid black;
-}
-
-#main-menu li {
-  border: none !important;
-  transition: all 0.1s ease-in-out;
-}
-
-#main-menu li:hover {
-  color:black;
-  background-color:black;
-}
-
-.sm-dox a, .sm-dox a:focus, .sm-dox a:active, .sm-dox a:hover, .sm-dox a.highlighted {
-  background-image:none;
-}
-
-#titlearea {
-  margin: 8px;
-  border: none;
-}

doc/doxygen_header.html

@@ -1,59 +0,0 @@
-<!-- HTML header for doxygen 1.8.14-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="cache-control" content="max-age=86400"/>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen $doxygenversion"/>
-<meta name="viewport" content="width=device-width, initial-scale=1"/>
-<!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
-<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
-<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="$relpath^jquery.js"></script>
-<script type="text/javascript" src="$relpath^dynsections.js"></script>
-$treeview
-$search
-$mathjax
-<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
-$extrastylesheet
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-
-<!--BEGIN TITLEAREA-->
-<div id="titlearea">
-<table cellspacing="0" cellpadding="0">
- <tbody>
- <tr style="height: 56px;">
-  <!--BEGIN PROJECT_LOGO-->
-  <td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
-  <!--END PROJECT_LOGO-->
-  <!--BEGIN PROJECT_NAME-->
-  <td id="projectalign" style="padding-left: 0.5em;">
-   <div id="projectname">$projectname
-   <!--BEGIN PROJECT_NUMBER-->&#160;<span id="projectnumber">$projectnumber</span><!--END PROJECT_NUMBER-->
-   </div>
-   <!--BEGIN PROJECT_BRIEF--><div id="projectbrief">$projectbrief</div><!--END PROJECT_BRIEF-->
-  </td>
-  <!--END PROJECT_NAME-->
-  <!--BEGIN !PROJECT_NAME-->
-   <!--BEGIN PROJECT_BRIEF-->
-    <td style="padding-left: 0.5em;">
-    <div id="projectbrief">$projectbrief</div>
-    </td>
-   <!--END PROJECT_BRIEF-->
-  <!--END !PROJECT_NAME-->
-  <!--BEGIN DISABLE_INDEX-->
-   <!--BEGIN SEARCHENGINE-->
-   <td>$searchbox</td>
-   <!--END SEARCHENGINE-->
-  <!--END DISABLE_INDEX-->
- </tr>
- </tbody>
-</table>
-</div>
-<!--END TITLEAREA-->
-<!-- end header part -->
-
-

doc/footer.html

@@ -1,4 +1,4 @@
-<!-- HTML footer for doxygen 1.8.14-->
+<!-- HTML footer for doxygen 1.9.8-->
 <!-- start footer part -->
 <!--BEGIN GENERATE_TREEVIEW-->
 <div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->

doc/getting-started.md

@@ -0,0 +1,62 @@
+@page getting-started Getting Started
+@tableofcontents
+
+![title-img](https://nsm09.casimages.com/img/2025/05/30//2505300816063242518595256.jpg)
+
+# Install FTXUI
+
+To set up FTXUI in your project, follow the [installation guide](installation.html), which provides instructions for multiple build systems and package managers.
+
+# Minimal Example
+
+Save the following code as `main.cpp`:
+
+```cpp
+#include <ftxui/dom/elements.hpp>
+#include <ftxui/screen/screen.hpp>
+#include <iostream>
+
+int main() {
+  using namespace ftxui;
+
+  Element document = hbox({
+    text("left")   | border,
+    text("middle") | border | flex,
+    text("right")  | border,
+  });
+
+  auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+  Render(screen, document);
+  screen.Print();
+}
+```
+
+Build and run it using your preferred build system.  
+If unsure, start with one of the methods described in the [installation page](installation.html).
+
+Expected output:
+
+```
+┌────┐┌────────────────────────────────────┐┌─────┐
+│left││middle                              ││right│
+└────┘└────────────────────────────────────┘└─────┘
+```
+
+# Starter Template
+
+For a complete working project, clone the official starter repository:
+
+```bash
+git clone https://github.com/ArthurSonzogni/ftxui-starter
+```
+
+Follow the build instructions in the `README.md` of that repository.
+
+<div class="section_buttons">
+ 
+| Previous                          | Next                    |
+|:----------------------------------|------------------------:|
+| [Introduction](index.html) | [Modules](modules.html) |
+
+ 
+</div>

doc/header.html

@@ -0,0 +1,201 @@
+<!-- HTML header for doxygen 1.9.8-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="$langISO">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=11"/>
+<meta name="generator" content="Doxygen $doxygenversion"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
+<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
+<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
+<!--BEGIN DISABLE_INDEX-->
+  <!--BEGIN FULL_SIDEBAR-->
+<script type="text/javascript">var page_layout=1;</script>
+  <!--END FULL_SIDEBAR-->
+<!--END DISABLE_INDEX-->
+<script type="text/javascript" src="$relpath^jquery.js"></script>
+<script type="text/javascript" src="$relpath^dynsections.js"></script>
+<script type="text/javascript" src="$relpath^doxygen-awesome-fragment-copy-button.js"></script>
+<script type="text/javascript" src="$relpath^doxygen-awesome-paragraph-link.js"></script>
+<script type="text/javascript" src="$relpath^doxygen-awesome-interactive-toc.js"></script>
+<script type="text/javascript" src="$relpath^doxygen-awesome-tabs.js"></script>
+<script type="module">
+    DoxygenAwesomeFragmentCopyButton.init()
+    DoxygenAwesomeParagraphLink.init()
+    DoxygenAwesomeInteractiveToc.init()
+    DoxygenAwesomeTabs.init()
+
+    await new Promise(r => window.addEventListener('DOMContentLoaded', r));
+
+    // Remove title when a img[alt='title-img'] is present.
+    // Find an image with the alt "img-title".
+    const img = document.querySelector("img[alt='title-img']");
+    const header = document.querySelector(".headertitle");
+
+    if (img && header) {
+      // Hide the header title progressively.
+      header.style.display = "none";
+
+      // Show progressively the image.
+      img.style.maxHeight = "40vh";
+      img.style.maxWidth = "100%";
+      img.style.objectFit = "contain";
+    }
+
+    // In the "examples.html" page. Turn every link with text
+    // "examples/<...>
+    //
+    // Add a "demo" link toward.
+    // https://arthursonzogni.github.io/FTXUI/examples/?file=<...>
+    const examples = document.querySelectorAll("a")
+    examples.forEach((example) => {
+      if (!example.textContent.startsWith("examples/")) {
+        return;
+      }
+
+      // Remove the ".cpp" extension from the example name.
+      const exampleName = example.textContent.replace("examples/", "").replace(".cpp", "");
+
+      const a = document.createElement("a");
+      a.textContent = "[demo]";
+      a.href = "https://arthursonzogni.github.io/FTXUI/examples/?file=" + exampleName;
+      a.style.marginRight= "1em";
+      a.style.fontWeight = "bold";
+
+      example.parentElement.insertBefore(a, example)
+    });
+
+    // If the current URL ends with -example.html, we can add a link to the demo
+    // as well using the div.title textContent.
+    const url = new URL(window.location.href);
+    if (url.pathname.endsWith("-example.html")) {
+      // Get the title text.
+      const title = document.querySelector("div.title").textContent;
+      const example = title.replace("examples/", "").replace(".cpp", "");
+
+      // Create a link to the demo.
+      const a = document.createElement("a");
+      a.textContent = "[demo]";
+      a.href = "https://arthursonzogni.github.io/FTXUI/examples/?file=" + example;
+      a.style.marginLeft = "1em";
+      a.style.fontWeight = "bold";
+      a.style.display = "inline-block";
+
+      // Insert the link after the title.
+      const titleDiv = document.querySelector("div.title");
+      if (titleDiv) {
+        titleDiv.insertBefore(a, titleDiv.nextSibling);
+      }
+
+    }
+
+</script>
+<script type="module">
+  // Ignore non english pages and/or the main page.
+  const excluded_lang = [
+    "/de",
+    "/es",
+    "/fr",
+    "/it",
+    "/ja",
+    "/ja",
+    "/ko"
+    "/ru",
+    "/zh-CH",
+    "/zh-TW",
+  ]
+  if (excluded_lang.some(lang => window.location.pathname.startsWith(lang)) ||
+      window.location.pathname.endsWith("index.html")) {
+    return;
+  }
+
+  // Click on the navtree, except for the main page where this is already done
+  // automatically.
+  let delay = 0;
+  while(true) {
+    const navtree = document.querySelector("div.item.selected");
+    if (!navtree) {
+      delay *= 2;
+      delay += 1;
+      await new Promise(resolve => setTimeout(resolve, delay));
+      continue;
+    }
+
+    // Include only selected navtree items.
+    console.log("navtree.textContent", navtree.textContent);
+    if (!navtree.textContent.includes("Getting Started") &&
+        !navtree.textContent.includes("Installation") &&
+        !navtree.textContent.includes("ftxui / screen") &&
+        !navtree.textContent.includes("ftxui / dom") &&
+        !navtree.textContent.includes("ftxui / component") &&
+        !navtree.textContent.includes("Reference")) {
+      break;
+    }
+
+    // Find the first link inside the navtree.
+    const link = navtree.querySelector("a");
+    if (link) {
+      // Simulate a click on the link.
+      link.click();
+      break;
+    }
+  }
+</script>
+
+$treeview
+$search
+$mathjax
+$darkmode
+<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
+$extrastylesheet
+</head>
+<body>
+<!--BEGIN DISABLE_INDEX-->
+  <!--BEGIN FULL_SIDEBAR-->
+<div id="side-nav" class="ui-resizable side-nav-resizable"><!-- do not remove this div, it is closed by doxygen! -->
+  <!--END FULL_SIDEBAR-->
+<!--END DISABLE_INDEX-->
+
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+
+<!--BEGIN TITLEAREA-->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr id="projectrow">
+  <!--BEGIN PROJECT_LOGO-->
+  <td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
+  <!--END PROJECT_LOGO-->
+  <!--BEGIN PROJECT_NAME-->
+  <td id="projectalign">
+   <div id="projectname">$projectname<!--BEGIN PROJECT_NUMBER--><span id="projectnumber">&#160;$projectnumber</span><!--END PROJECT_NUMBER-->
+   </div>
+   <!--BEGIN PROJECT_BRIEF--><div id="projectbrief">$projectbrief</div><!--END PROJECT_BRIEF-->
+  </td>
+  <!--END PROJECT_NAME-->
+  <!--BEGIN !PROJECT_NAME-->
+   <!--BEGIN PROJECT_BRIEF-->
+    <td>
+    <div id="projectbrief">$projectbrief</div>
+    </td>
+   <!--END PROJECT_BRIEF-->
+  <!--END !PROJECT_NAME-->
+  <!--BEGIN DISABLE_INDEX-->
+   <!--BEGIN SEARCHENGINE-->
+     <!--BEGIN !FULL_SIDEBAR-->
+    <td>$searchbox</td>
+     <!--END !FULL_SIDEBAR-->
+   <!--END SEARCHENGINE-->
+  <!--END DISABLE_INDEX-->
+ </tr>
+  <!--BEGIN SEARCHENGINE-->
+   <!--BEGIN FULL_SIDEBAR-->
+   <tr><td colspan="2">$searchbox</td></tr>
+   <!--END FULL_SIDEBAR-->
+  <!--END SEARCHENGINE-->
+ </tbody>
+</table>
+</div>
+<!--END TITLEAREA-->
+<!-- end header part -->

doc/installation.md

@@ -0,0 +1,47 @@
+
+@page installation Installation
+@tableofcontents
+
+![title-img](https://nsm09.casimages.com/img/2025/05/30//2505300816063242518595255.jpg)
+
+## Overview
+
+FTXUI can be integrated into your project using several build systems and package managers.  
+This page serves as an entry point for the available integration methods.
+
+## Supported Methods
+
+- @subpage installation_cmake
+- @subpage installation_bazel
+- @subpage installation_vcpkg
+- @subpage installation_conan
+- @subpage installation_manual
+- @subpage installation_nix
+- @subpage installation_debian
+- @subpage installation_arch
+- @subpage installation_opensuse
+- @subpage installation_xmake
+
+## Next Steps
+
+Once FTXUI is installed:
+
+- [Getting Started](getting-started.html): Write and run your first program
+- [Examples](examples.html): See what FTXUI can do
+- Modules:
+  - [DOM](module-dom.html)
+  - [Component](module-component.html)
+  - [Screen](module-screen.html)
+
+## Contributions
+
+If you use another build system or package manager, feel free to contribute a guide.  
+You can also open a feature request on the [GitHub issue tracker](https://github.com/ArthurSonzogni/FTXUI/issues).
+
+<div class="section_buttons">
+ 
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+ 
+</div>

doc/installation_arch.md

@@ -0,0 +1,34 @@
+@page installation_arch Arch Linux
+
+FTXUI is packaged on the AUR. Install using an AUR helper:
+
+```bash
+yay -S ftxui
+```
+
+You can also manually download the PKGBUILD from <https://aur.archlinux.org/packages/ftxui>.
+
+Once installed, you can use it in your CMake projects by adding the following to your `CMakeLists.txt`:
+
+```cmake
+find_package(ftxui REQUIRED)
+add_executable(main main.cpp)
+target_link_libraries(main
+  PRIVATE ftxui::screen
+  PRIVATE ftxui::dom
+  PRIVATE ftxui::component
+)
+```
+
+> [!note]
+> This is an unofficial package. That means it is not maintained by the FTXUI
+> team, but by the community. The package maintainers seems to actively update
+> the package to the latest version. Thanks to the maintainers for their work!
+
+<div class="section_buttons">
+
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+
+</div>

doc/installation_bazel.md

@@ -0,0 +1,38 @@
+@page installation_bazel Bazel
+
+FTXUI can be integrated into your project using [Bazel](https://bazel.build)
+with Bzlmod (Bazel modules).
+
+The library is registered in the [Bazel Central Registry](https://registry.bazel.build/modules/ftxui)
+
+**MODULE.bazel**
+```starlark
+bazel_dep(name = "ftxui", version = "6.1.9")
+```
+
+**BUILD.bazel**
+```starlark
+cc_binary(
+    name = "main",
+    srcs = ["main.cpp"],
+    deps = [
+        "@ftxui//:component",
+        "@ftxui//:dom",
+        "@ftxui//:screen",
+    ],
+)
+```
+
+## Starter Project
+
+You can use the official Bazel starter project for a minimal working setup:
+
+- [ftxui-bazel (starter)](https://github.com/ArthurSonzogni/ftxui-bazel)
+ 
+<div class="section_buttons">
+ 
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+ 
+</div>

doc/installation_cmake.md

@@ -0,0 +1,111 @@
+@page installation_cmake CMake
+
+@tableofcontents
+
+This page explains how to depend on FTXUI using [CMake](https://cmake.org).  
+
+# Methods of Integration
+
+## Using FetchContent
+
+This approach downloads FTXUI at configure time and doesn't require a system-wide install.
+
+```cmake 
+include(FetchContent)
+
+FetchContent_Declare(ftxui
+  GIT_REPOSITORY https://github.com/ArthurSonzogni/FTXUI
+  GIT_TAG v6.1.9  # Replace with a version, tag, or commit hash
+)
+
+FetchContent_MakeAvailable(ftxui)
+
+add_executable(main main.cpp)
+target_link_libraries(main
+  PRIVATE ftxui::screen
+  PRIVATE ftxui::dom
+  PRIVATE ftxui::component
+)
+```
+
+This ensures reproducible builds and easy dependency management.
+
+## Using find_package
+
+If FTXUI is installed system-wide or via a package manager (e.g. vcpkg or Conan), you can use:
+
+```cmake 
+find_package(ftxui REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main
+  PRIVATE ftxui::screen
+  PRIVATE ftxui::dom
+  PRIVATE ftxui::component
+)
+```
+
+Make sure the package is visible in your `CMAKE_PREFIX_PATH`.
+
+## Using git submodule
+
+You can also add FTXUI as a [Git submodule](https://git-scm.com/book/en/v2/Git-Tools-Submodules), keeping it as part of your repository:
+
+```cmake
+git submodule add https://github.com/ArthurSonzogni/FTXUI external/ftxui
+git submodule update --init --recursive
+```
+
+When cloning a repository that already includes FTXUI as a submodule, make sure to fetch submodules with:
+
+```
+git clone --recurse-submodules <your-repo>
+# Or, if already cloned:
+git submodule update --init --recursive
+```
+
+Then in your `CMakeLists.txt`:
+
+```cmake
+add_subdirectory(external/ftxui)
+
+add_executable(main main.cpp)
+target_link_libraries(main
+  PRIVATE ftxui::screen
+  PRIVATE ftxui::dom
+  PRIVATE ftxui::component
+)
+```
+
+This approach works well if you want to vendor FTXUI in your own repository.
+
+# Optional CMake Flags
+
+FTXUI supports the following CMake options:
+
+| Option                            | Description                   | Default |
+| --------------------------------- | ----------------------------- | ------- |
+| FTXUI_BUILD_EXAMPLES              | Build bundled examples        | OFF     |
+| FTXUI_BUILD_DOCS                  | Build the documentation       | OFF     |
+| FTXUI_BUILD_TESTS                 | Enable tests                  | OFF     |
+| FTXUI_ENABLE_INSTALL              | Generate install targets      | ON      |
+| FTXUI_MICROSOFT_TERMINAL_FALLBACK | Improve Windows compatibility | ON/OFF  |
+
+To enable an option:
+
+```
+cmake -DFTXUI_BUILD_EXAMPLES=ON ..
+```
+
+# Verifying Integration
+
+To confirm the setup is working, build and run a minimal example.
+If you need a complete template, see: [ftxui-starter](https://github.com/ArthurSonzogni/ftxui-starter)
+
+<div class="section_buttons">
+ 
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+ 
+</div>

doc/installation_conan.md

@@ -0,0 +1,104 @@
+@page installation_conan Conan
+@tableofcontents
+
+FTXUI can be easily obtained and integrated into your project using the Conan package manager.
+
+## Prerequisites
+
+First, ensure that Conan is installed on your system. If not, you can install it via pip:
+
+```powershell
+pip install conan
+```
+Conan often works in tandem with CMake, so you will need to have CMake installed as well. Once you have confirmed both Conan and CMake are installed, create a project directory, for example, `ftxui-demo`:
+
+```powershell
+mkdir C:\ftxui-demo
+cd C:\ftxui-demo
+```
+
+## Configuration
+
+After ensuring your environment is set up correctly, create a Conan configuration file `conanfile.txt`. This file is used to declare your project's dependencies. The community-maintained package for FTXUI can be found on [Conan Center](https://conan.io/center/recipes/ftxui).
+
+> [!note]
+> This is an unofficial build script. This means it is not maintained by the FTXUI
+> team but by the community. The package maintainer appears to actively update it
+> to the latest releases. Many thanks to the maintainer for their work!
+
+@todo If you are familiar with the process, please consider adding an "official" build script to Conan Center.
+This could be a GitHub Action that automatically updates Conan Center upon new releases.
+
+```ini
+[requires]
+ftxui/6.0.2
+
+[generators]
+CMakeDeps
+CMakeToolchain
+
+[layout]
+cmake_layout
+```
+
+## Install Dependencies and Build
+
+Once configured, run the following command to install FTXUI and its dependencies:
+
+```powershell
+conan install . --output-folder=build --build=missing
+```
+
+This will download and install `ftxui/6.0.2` along with all its dependencies from Conan's remote repositories.
+
+After the installation completes, you can test it by creating a `demo.cpp` file in your project directory:
+
+```cpp
+#include <ftxui/screen/screen.hpp>
+#include <ftxui/dom/elements.hpp>
+#include <iostream>
+
+int main() {
+    using namespace ftxui;
+    auto document = hbox({
+        text(" Hello "),
+        text("FTXUI ") | bold | color(Color::Red),
+        text(" world! ")
+    });
+    auto screen = Screen::Create(Dimension::Full(), Dimension::Fit(document));
+    Render(screen, document);
+    std::cout << screen.ToString() << std::endl;
+    return 0;
+}
+```
+
+If the test is successful, you can then create a `CMakeLists.txt` file in the project directory:
+
+```cmake
+cmake_minimum_required(VERSION 3.20)
+project(ftxui-demo)
+
+# Set the C++ standard
+set(CMAKE_CXX_STANDARD 20)
+
+# Find the FTXUI package installed via Conan
+find_package(ftxui CONFIG REQUIRED)
+
+# Create the executable
+add_executable(demo demo.cpp)
+
+# Link the executable to the FTXUI library
+target_link_libraries(demo PRIVATE ftxui::component)
+```
+
+@todo 中国大陆在这方面的下载可能会受限制，需要一个替代的方案
+
+---
+
+<div class="section_buttons">
+
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+
+</div>

doc/installation_debian.md

@@ -0,0 +1,42 @@
+@page installation_debian Debian/Ubuntu
+
+## Debian and Ubuntu Packages (Unofficial)
+
+Pre-built packages are provided by the distributions. Install with:
+
+```bash
+sudo apt install libftxui-dev
+```
+
+The following packages are available:
+- `ftxui-doc`
+- `ftxui-examples`
+- `libftxui-component<version>`
+- `libftxui-dev`
+- `libftxui-dom<version>`
+- `libftxui-screen<version>`
+
+Once installed, you can use it in your CMake projects by adding the following to
+your `CMakeLists.txt`:
+
+```cmake
+find_package(ftxui REQUIRED)
+add_executable(main main.cpp)
+target_link_libraries(main
+  PRIVATE ftxui::screen
+  PRIVATE ftxui::dom
+  PRIVATE ftxui::component
+)
+```
+
+> [!note]
+> This is an **unofficial** package. That means it is not maintained by the FTXUI
+> team, but by the community. 
+
+<div class="section_buttons">
+
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+
+</div>

doc/installation_manual.md

@@ -0,0 +1,35 @@
+@page installation_manual Manual
+@tableofcontents
+
+## Building from Source (Official)
+
+Clone and build the project using CMake:
+
+```bash
+git clone https://github.com/ArthurSonzogni/FTXUI.git
+cd FTXUI
+cmake -S . -B build -D FTXUI_ENABLE_INSTALL=ON
+cmake --build build -j
+sudo cmake --install build
+```
+
+Once installed you can use it in your CMake projects by adding the following to your `CMakeLists.txt`:
+
+```cmake
+find_package(ftxui REQUIRED)
+add_executable(main main.cpp)
+target_link_libraries(main
+  PRIVATE ftxui::screen
+  PRIVATE ftxui::dom
+  PRIVATE ftxui::component
+)
+```
+
+
+<div class="section_buttons">
+
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+
+</div>

doc/installation_nix.md

@@ -0,0 +1,38 @@
+@page installation_nix Nix
+
+> [!note]
+> FTXUI author is not very knowledgeable about Nix. This page has been mostly
+> generated by AI. If you have any suggestions to improve it, please open a
+> PR.
+
+## Nix Flake
+
+FTXUI ships with a `flake.nix` providing both packages and a development shell.
+
+### Build the Library
+
+```bash
+nix build github:ArthurSonzogni/FTXUI
+```
+
+The resulting package is accessible via the `result` link.
+
+### Use as a Dependency
+
+Add FTXUI to your flake inputs:
+
+```nix
+{
+  inputs.ftxui.url = "github:ArthurSonzogni/FTXUI";
+}
+```
+
+Then reference `ftxui.packages.<system>.ftxui` in your outputs.
+
+<div class="section_buttons">
+
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+
+</div>

doc/installation_opensuse.md

@@ -0,0 +1,32 @@
+@page installation_opensuse openSUSE
+
+## openSUSE Package (Unofficial)
+
+FTXUI seems to be available from the `devel:libraries:c_c++` repository.
+
+```bash
+sudo zypper addrepo https://download.opensuse.org/repositories/devel:libraries:c_c++/openSUSE_Leap_$releasever/devel:libraries:c_c++.repo
+sudo zypper install ftxui
+```
+
+See <https://build.opensuse.org/package/show/devel:libraries:c_c++/ftxui> for details.
+
+> [!note]
+> This is an **unofficial** package. That means it is not maintained by the FTXUI
+> team, but by the community. 
+
+--
+
+> [!note]
+> The FTXUI author is not very knowledgeable about openSUSE. This page has been
+> mostly generated by AI. If you have any suggestions to improve it, please open
+> a PR.
+
+
+<div class="section_buttons">
+
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+
+</div>

doc/installation_vcpkg.md

@@ -0,0 +1,79 @@
+@page installation_vcpkg Vcpkg
+@tableofcontents
+
+# Vcpkg Package
+
+FTXUI is available in the [Vcpkg registry](https://vcpkg.link/ports/ftxui)
+
+To use it, you can add the following to your `vcpkg.json`:
+
+```json
+{
+  "name": "your-project",
+  "version-string": "0.1.0",
+  "dependencies": [
+    {
+        "name": "ftxui",
+        "version>=": "6.1.9"
+    }
+  ]
+}
+```
+
+# Install FTXUI using Vcpkg
+```bash
+vcpkg install --triplet x64-linux  # or x64-windows / arm64-osx etc.
+```
+
+# Configure your build system.
+If you are using CMake, you can use the following in your `CMakeLists.txt`:
+
+**CMakeLists.txt**
+```cmake
+cmake_minimum_required(VERSION 3.15)
+project(my_project)
+
+# Make sure vcpkg toolchain file is passed at configure time
+find_package(ftxui CONFIG REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main
+    PRIVATE ftxui::screen
+    PRIVATE ftxui::dom
+    PRIVATE ftxui::component
+)
+```
+
+**main.cpp**
+```cpp
+#include <ftxui/component/screen_interactive.hpp>
+#include <ftxui/component/component.hpp>
+#include <ftxui/component/component_options.hpp>
+
+int main() {
+  using namespace ftxui;
+
+  auto screen = ScreenInteractive::TerminalOutput();
+  auto button = Button("Click me", [] { std::cout << "Clicked!\n"; });
+
+  screen.Loop(button);
+}
+```
+
+**Configure and build the project**
+```bash
+cmake -B build -S . -DCMAKE_TOOLCHAIN_FILE=/path/to/vcpkg/scripts/buildsystems/vcpkg.cmake
+cmake --build build
+./build/main
+```
+
+
+
+
+<div class="section_buttons">
+ 
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+ 
+</div>

doc/installation_xmake.md

@@ -0,0 +1,40 @@
+@page installation_xmake XMake
+@tableofcontents
+
+## XMake Package (Unofficial)
+
+FTXUI is available in the [xmake-repo](https://github.com/xmake-io/xmake-repo/blob/dev/packages/f/ftxui/xmake.lua)
+
+Example `xmake.lua` snippet:
+
+```lua
+add_requires("ftxui", {system = false})
+
+target("demo")
+    set_kind("binary")
+    add_files("src/*.cpp")
+    add_packages("ftxui")
+```
+
+Refer to the [XMake documentation](https://xmake.io) for further options.
+
+> [!note]
+> This is an **unofficial** package. That means it is not maintained by the FTXUI
+> team, but by the community. 
+
+---
+
+> [!note]
+> The FTXUI author is not very knowledgeable about openSUSE. This page has been
+> mostly generated by AI. If you have any suggestions to improve it, please open
+> a PR.
+
+---
+
+<div class="section_buttons">
+
+| Previous          |
+|:------------------|
+| [Getting Started](getting-started.html) |
+
+</div>

doc/introduction.md

@@ -0,0 +1,88 @@
+@mainpage Introduction
+@tableofcontents
+
+<img src="https://github.com/ArthurSonzogni/FTXUI/assets/4759106/6925b6da-0a7e-49d9-883c-c890e1f36007" alt="Demo image"></img>
+
+**FTXUI** is simple cross-platform C++ library for terminal based user interfaces!
+
+# Feature
+ * Functional style. Inspired by
+   [1](https://hackernoon.com/building-reactive-terminal-interfaces-in-c-d392ce34e649?gi=d9fb9ce35901)
+   and [React](https://reactjs.org/)
+ * No dependencies
+ * **Cross platform**.
+ * Simple and elegant syntax (in my opinion)
+ * Keyboard & mouse navigation.
+ * Support for [UTF8](https://en.wikipedia.org/wiki/UTF-8) and [fullwidth chars](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) (→ 测试)
+ * Support for animations. [Demo 1](https://arthursonzogni.github.io/FTXUI/examples/?file=component/menu_underline_animated_gallery), [Demo 2](https://arthursonzogni.github.io/FTXUI/examples/?file=component/button_style)
+ * Support for drawing. [Demo](https://arthursonzogni.github.io/FTXUI/examples/?file=component/canvas_animated)
+ * Learn by [examples](#documentation), and [tutorials](#documentation)
+ * Multiple build system and packages: 
+ * Good practices: documentation, tests, fuzzers, performance tests, automated CI, automated packaging, etc...
+
+# Example
+
+```cpp
+#include <ftxui/dom/elements.hpp>
+#include <ftxui/screen/screen.hpp>
+#include <iostream>
+
+int main() {
+  using namespace ftxui;
+
+  // Create a simple document with three text elements.
+  Element document = hbox({
+    text("left")   | border,
+    text("middle") | border | flex,
+    text("right")  | border,
+  });
+
+  // Create a screen with full width and height fitting the document.
+  auto screen = Screen::Create(
+    Dimension::Full(),       // Width
+    Dimension::Fit(document) // Height
+  );
+
+  // Render the document onto the screen.
+  Render(screen, document);
+
+  // Print the screen to the console.
+  screen.Print();
+}
+```
+
+Expected output:
+
+```
+┌────┐┌────────────────────────────────────┐┌─────┐
+│left││middle                              ││right│
+└────┘└────────────────────────────────────┘└─────┘
+```
+
+# Supported Platforms
+
+- Linux
+- MacOS
+- Windows
+- WebAssembly
+
+<div class="section_buttons">
+ 
+|                                  Next |
+|--------------------------------------:|
+| [Getting Started](getting-started.html) |
+ 
+</div>
+
+@defgroup screen ftxui/screen
+
+Please check the [tutorial](module-screen.html) of the `ftxui/screen` module.
+
+@defgroup dom ftxui/dom
+
+Please check the [tutorial](module-dom.html) of the `ftxui/dom` module.
+
+@defgroup component ftxui/component
+
+Please check the [tutorial](module-component.html) of the `ftxui/component`
+module.

doc/mainpage.md

@@ -1,895 +0,0 @@
-\mainpage
-
-# Introduction {#introduction}
-
-Welcome to the FTXUI documentation!
-
-This is a brief tutorial. You are also encouraged to self-learn by reading the
-[examples](./examples.html).
-
-@tableofcontents 
-
-**Short example**
-
-To build a single frame, you need create an `ftxui::Element`, and display it on
-a `ftxui::Screen`.
-
-**main.cpp**
-```cpp
-#include <ftxui/dom/elements.hpp>
-#include <ftxui/screen/screen.hpp>
-#include <iostream>
-
-int main(void) {
-  using namespace ftxui;
-
-  // Define the document
-  Element document =
-    hbox({
-      text("left")   | border,
-      text("middle") | border | flex,
-      text("right")  | border,
-    });
-
-  auto screen = Screen::Create(
-    Dimension::Full(),       // Width
-    Dimension::Fit(document) // Height
-  );
-  Render(screen, document);
-  screen.Print();
-
-  return EXIT_SUCCESS;
-}
-```
-
-
-**output**
-```bash
-┌────┐┌────────────────────────────────────┐┌─────┐
-│left││middle                              ││right│
-└────┘└────────────────────────────────────┘└─────┘
-```
-
-## Configure {#configure}
-### Using CMake and find_package {#build-cmake-find-package}
-
-Assuming FTXUI is available or installed on the system.
-
-**CMakeLists.txt**
-```cmake
-cmake_minimum_required (VERSION 3.11)
-find_package(ftxui 5 REQUIRED)
-project(ftxui-starter LANGUAGES CXX VERSION 1.0.0)
-add_executable(ftxui-starter src/main.cpp)
-target_link_libraries(ftxui-starter
-  PRIVATE ftxui::screen
-  PRIVATE ftxui::dom
-  PRIVATE ftxui::component # Not needed for this example.
-)
-
-```
-
-### Using CMake and FetchContent {#build-cmake}
-
-If you want to fetch FTXUI using cmake:
-
-**CMakeLists.txt**
-```cmake
-cmake_minimum_required (VERSION 3.11)
-
-include(FetchContent)
-set(FETCHCONTENT_UPDATES_DISCONNECTED TRUE)
-FetchContent_Declare(ftxui
-  GIT_REPOSITORY https://github.com/ArthurSonzogni/ftxui
-  GIT_TAG main # Important: Specify a version or a commit hash here.
-)
-FetchContent_MakeAvailable(ftxui)
-
-project(ftxui-starter LANGUAGES CXX VERSION 1.0.0)
-add_executable(ftxui-starter src/main.cpp)
-target_link_libraries(ftxui-starter
-  PRIVATE ftxui::screen
-  PRIVATE ftxui::dom
-  PRIVATE ftxui::component # Not needed for this example.
-)
-```
-
-## Build
-
-```bash
-mkdir build && cd build
-cmake ..
-make
-./main
-```
-
-# List of modules. {#modules}
-
-The project is comprised of 3 modules:
-
-1. **ftxui/screen** defines a `ftxui::Screen`, a grid of `ftxui::Pixel`.
-
-2. **ftxui/dom** is the main module. It defines a hierarchical set of
-   `ftxui::Element`.  An element draws something on the `ftxui::Screen`. It is
-   responsive to the size of its container.
-
-3. **ftxui/component** The module is required if your program needs to respond
-   to user input. It defines a set of `ftxui::Component`. These components can
-   be utilized to navigate using the arrow keys *and/or* cursor. There are 
-   several builtin widgets like checkbox/inputbox/etc to interact with. You can
-   combine them, or even define your own custom components.
-
-# screen {#module-screen}
-
-This is the visual element of the program. It defines a `ftxui::Screen`, which
-is a grid of `ftxui::Pixel`. A Pixel represents a Unicode character and its
-associated style (bold, italic, colors, etc.). The screen can be printed as a
-string using `ftxui::Screen::ToString()`. The following example highlights this
-process:
-
-```cpp
-  #include <ftxui/screen/screen.hpp>
-  #include <iostream>
-
-  int main(void) {
-    using namespace ftxui;
-    auto screen = Screen::Create(Dimension::Fixed(32), Dimension::Fixed(10));
-
-    auto& pixel = screen.PixelAt(9,9);
-    pixel.character = U'A';
-    pixel.bold = true;
-    pixel.foreground_color = Color::Blue;
-
-    std::cout << screen.ToString();
-    return EXIT_SUCCESS;
-  }
-```
-
-# dom {#module-dom}
-
-This module defines a hierarchical set of `ftxui::Element`. An element manages
-the layout and can be responsive to the terminal dimension changes. Note the
-following example where this module is used to create a simple layout with a
-number of operators:
-
-**Example:**
-```cpp
-// Define the document
-Element document = vbox({
-  text("The window") | bold | color(Color::Blue),
-  gauge(0.5)
-  text("The footer")
-});
-
-// Add a border, by calling the `ftxui::border` decorator function.
-document = border(document);
-
-// Add another border, using the pipe operator.
-document = document | border.
-
-// Add another border, using the |= operator.
-document |= border
-
-```
-
-**List of elements**
-
-The list of all elements are included and can be accessed by including the
-corresponding header file:
-```cpp
-#include <ftxui/dom/elements.hpp>
-```
-
-\include ftxui/dom/elements.hpp
-
-## text ## {#dom-text}
-
-The most simple widget. It displays a text.
-```cpp
-text("I am a piece of text");
-```
-```bash
-I am a piece of text.
-```
-
-## vtext {#dom-vtext}
-
-Identical to `ftxui::text`, but displayed vertically.
-
-Code:
-```cpp
-vtext("HELLO");
-```
-
-Terminal output:
-```bash
-H
-E
-L
-L
-O
-```
-
-## paragraph {#dom-paragraph}
-
-Similar to `ftxui::text`, but the individual word are wrapped along multiple
-lines, depending on the width of its container.
-
-Sample Code:
-```cpp
-paragraph("A very long text")
-```
-
-![ezgif com-gif-maker (4)](https://user-images.githubusercontent.com/4759106/147251370-983a06e7-6f41-4113-92b8-942f43d34d06.gif)
-
-For a more detailed example refer to [detailed example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2paragraph_8cpp-example.html). Paragraph also includes a number of other variants as shown below:
-```cpp
-Element paragraph(std::string text);
-Element paragraphAlignLeft(std::string text);
-Element paragraphAlignRight(std::string text);
-Element paragraphAlignCenter(std::string text);
-Element paragraphAlignJustify(std::string text);
-```
-
-
-## border {#dom-border}
-
-Adds a border around an element.
-
-Code:
-```cpp
-border(text("The element"))
-```
-
-Terminal output:
-```bash
-┌───────────┐
-│The element│
-└───────────┘
-```
-
-You can achieve the same behavior by using the pipe operator.
-
-Code:
-```cpp
-text("The element") | border
-```
-
-Border also comes in a variety of styles as shown below:
-```cpp
-Element border(Element);
-Element borderLight(Element);
-Element borderHeavy(Element);
-Element borderDouble(Element);
-Element borderRounded(Element);
-Element borderEmpty(Element);
-Decorator borderStyled(BorderStyle);
-Decorator borderWith(Pixel);
-```
-
-
-## window ## {#dom-window}
-
-A `ftxui::window` is a `ftxui::border`, but with an additional header. To add a
-window around an element, wrap it and specify a string as the header.
-Code:
-```cpp
-window("The window", text("The element"))
-```
-
-Terminal output:
-```bash
-┌The window─┐
-│The element│
-└───────────┘
-```
-
-## separator {#dom-separator}
-
-Displays a vertical/horizontal line to visually split the content of a
-container in two.
-
-Code:
-```cpp
-border(
-  hbox({
-    text("Left"), 
-    separator(),
-    text("Right")
-  })
-)
-```
-
-Terminal output:
-```bash
-┌────┬─────┐
-│left│right│
-└────┴─────┘
-```
-
-
-Separators come in a variety of flavors as shown below:
-```cpp
-Element separator(void);
-Element separatorLight();
-Element separatorHeavy();
-Element separatorDouble();
-Element separatorEmpty();
-Element separatorStyled(BorderStyle);
-Element separator(Pixel);
-Element separatorCharacter(std::string);
-Element separatorHSelector(float left,
-                           float right,
-                           Color background,
-                           Color foreground);
-Element separatorVSelector(float up,
-                           float down,
-                           Color background,
-                           Color foreground);
-```
-
-## gauge {#dom-gauge}
-
-It constitutes a gauge. It can be used to represent a progress bar.
-
-Code:
-```cpp
-border(gauge(0.5))
-```
-
-Teminal output:
-```bash
-┌────────────────────────────────────────────────────────────────────────────┐
-│██████████████████████████████████████                                      │
-└────────────────────────────────────────────────────────────────────────────┘
-```
-
-Gauges can be displayed in many orientations as shown below:
-```cpp
-Element gauge(float ratio);
-Element gaugeLeft(float ratio);
-Element gaugeRight(float ratio);
-Element gaugeUp(float ratio);
-Element gaugeDown(float ratio);
-Element gaugeDirection(float ratio, GaugeDirection);
-```
-
-## graph {#dom-graph}
-
-@htmlonly
-<script id="asciicast-223726" src="https://asciinema.org/a/223726.js" async></script>
-@endhtmlonly
-
-See:
-```cpp
-Element graph(GraphFunction);
-```
-
-## Colors {#dom-colors}
-
-Most terminal consoles can display colored text and colored backgrounds. FTXUI
-supports every color palette:
-```cpp
-Decorator color(Color);
-Decorator bgcolor(Color);
-```
-
-
-Color [gallery](https://arthursonzogni.github.io/FTXUI/examples_2dom_2color_gallery_8cpp-example.html):
-![image](https://user-images.githubusercontent.com/4759106/147248595-04c7245a-5b85-4544-809d-a5984fc6f9e7.png)
-
-### Palette16 #{#dom-colors-palette-16}
-
-On most terminals the following colors are supported:
-- Default
-
-- Black
-- GrayDark
-- GrayLight
-
-- White
-
-- Blue
-- BlueLight
-
-- Cyan
-- CyanLight
-
-- Green
-- GreenLight
-
-- Magenta
-- MagentaLight
-
-- Red
-- RedLight
-
-- Yellow
-- YellowLight
-
-Example use of the above colors using the pipe operator:
-```cpp
-text("Blue foreground") | color(Color::Blue);
-text("Blue background") | bgcolor(Color::Blue);
-text("Black on white") | color(Color::Black) | bgcolor(Color::White);
-```
-
-### Palette256 #{#dom-colors-palette-256}
-
-On terminal supporting 256 colors. 
-@htmlonly
-<script id="asciicast-OAUc3n6QrkmrLt7XEEb8AzbLt" src="https://asciinema.org/a/OAUc3n6QrkmrLt7XEEb8AzbLt.js" async></script>
-@endhtmlonly
-
-```cpp
-text("HotPink") | color(Color::HotPink);
-```
-
-### TrueColor #{#dom-colors-true-color}
-
-On terminal supporting trueColor, you can directly use the 24bit RGB color
-space:
-
-Use the constructors below to specify the **RGB** or **HSV** values for your
-color:
-
-There are two constructors:
-```cpp
-ftxui::Color::RGB(uint8_t red, uint8_t green, uint8_t blue);
-ftxui::Color::HSV(uint8_t hue, uint8_t saturation, uint8_t value);
-```
-
-@htmlonly
-<script id="asciicast-dk5r8IcCH0aFIIgWG0keSEHMG" src="https://asciinema.org/a/dk5r8IcCH0aFIIgWG0keSEHMG.js" async></script>
-<script id="asciicast-xwzzghmqcqzIuyLwCpQFEqbEu" src="https://asciinema.org/a/xwzzghmqcqzIuyLwCpQFEqbEu.js" async></script>
-@endhtmlonly
-
-## LinearGradient #{#dom-linear-gradient}
-
-FTXUI supports linear gradient. Either on the foreground or the background.
-
-```cpp
-Decorator color(const LinearGradient&);
-Decorator bgcolor(const LinearGradient&);
-```
-
-A `ftxui::LinearGradient` is defined by an angle in degree, and a list of color
-stops.
-```cpp
-auto gradient = LinearGradient()
-  .Angle(45)
-  .AddStop(0.0, Color::Red)
-  .AddStop(0.5, Color::Green)
-  .AddStop(1.0, Color::Blue);
-```
-
-You can also use simplified constructors:
-```cpp
-LinearGradient(Color::Red, Color::Blue);
-```
-```cpp
-LinearGradient(45, Color::Red, Color::Blue);
-```
-
-See [demo](https://arthursonzogni.github.io/FTXUI/examples/?file=component/linear_gradient_gallery).
-
-
-## Style {#dom-style}
-In addition to colored text and colored backgrounds. Many terminals support text
-effects such as: `bold`, `italic`, `dim`, `underlined`, `inverted`, `blink`.
-
-```cpp
-Element bold(Element);
-Element italic(Element);
-Element dim(Element);
-Element inverted(Element);
-Element underlined(Element);
-Element underlinedDouble(Element);
-Element strikethrough(Element);
-Element blink(Element);
-Decorator color(Color);
-Decorator bgcolor(Color);
-Decorator colorgrad(LinearGradient);
-Decorator bgcolorgrad(LinearGradient);
-```
-
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2style_gallery_8cpp-example.html)
-
-![image](https://user-images.githubusercontent.com/4759106/147244118-380bf834-9e33-40df-9ff0-07c10f2598ef.png)
-
-To use these effects, simply wrap your elements with your desired effect:
-```cpp
-underlined(bold(text("This text is bold and underlined")))
-```
-
-Alternatively, use the pipe operator to chain it on your element:
-```cpp
-text("This text is bold") | bold | underlined
-```
-
-## Layout {#dom-layout}
-
-Enables elements to be arranged in the following ways:
-  - **Horizontally** with `ftxui::hbox`
-  - **Vertically** with `ftxui::vbox`
-  - **Inside a grid** with `ftxui::gridbox`
-  - **Wrapped along one direction** using the `ftxui::flexbox`.
-  
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2vbox_hbox_8cpp-example.html) using `ftxui::hbox`, `ftxui::vbox` and `ftxui::filler`.
-
-![image](https://user-images.githubusercontent.com/4759106/147242524-7103b5d9-1a92-4e2d-ac70-b3d6740061e3.png)
-  
-  
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2gridbox_8cpp-example.htmlp)
-using `ftxui::gridbox`:
-
-![image](https://user-images.githubusercontent.com/4759106/147242972-0db1f2e9-0790-496f-86e6-ed2c604f7a73.png)
-
-[Example](https://github.com/ArthurSonzogni/FTXUI/blob/master/examples/dom/hflow.cpp)
-using flexbox:
-
-![image](https://user-images.githubusercontent.com/4759106/147243064-780ac7cc-605b-475f-94b8-cf7c4aed03a5.png)
-
-Checkout this
-[example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2hflow_8cpp-example.html)
-and the associated
-[demo](https://arthursonzogni.github.io/FTXUI/examples/?file=component/flexbox).
-
-Element can also become flexible using the the `ftxui::flex` decorator.
-
-Code:
-```cpp
-  hbox({
-    text("left") | border ,
-    text("middle") | border | flex,
-    text("right") | border,
-  });
-```
-Terminal output:
-```bash
-┌────┐┌─────────────────────────────────────────────────────┐┌─────┐
-│left││middle                                               ││right│
-└────┘└─────────────────────────────────────────────────────┘└─────┘
-```
-
-Code:
-```cpp
-  hbox({
-    text("left") | border ,
-    text("middle") | border | flex,
-    text("right") | border | flex,
-  });
-```
-
-Terminal output:
-```bash
-┌────┐┌───────────────────────────────┐┌───────────────────────────────┐
-│left││middle                         ││right                          │
-└────┘└───────────────────────────────┘└───────────────────────────────┘
-```
-
-## Table {#dom-table}
-
-Enables easy formatting of data into a neat table like visual form.
-
-[Code example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2table_8cpp-example.html):
-  
-![image](https://user-images.githubusercontent.com/4759106/147250766-77d8ec9e-cf2b-486d-9866-1fd9f1bd2e6b.png)
-
-## Canvas {#dom-canvas}
-
-See the API [<ftxui/dom/canvas.hpp>](./canvas_8hpp_source.html)
-
-```cpp
-  auto c = Canvas(100, 100);
-  c.DrawPointLine(10, 10, 80, 10, Color::Red);
-  auto element = canvas(c);
-```
-
-Drawing can be performed on a `ftxui::Canvas`, using braille, block, or simple
-characters:
-  
-Simple [example](https://github.com/ArthurSonzogni/FTXUI/blob/master/examples/dom/canvas.cpp):
-  
-![image](https://user-images.githubusercontent.com/4759106/147245843-76cc62fb-ccb4-421b-aacf-939f9afb42fe.png)
-
-Complex [example](https://github.com/ArthurSonzogni/FTXUI/blob/master/examples/component/canvas_animated.cpp):
-  
-![ezgif com-gif-maker (3)](https://user-images.githubusercontent.com/4759106/147250538-783a8246-98e0-4a25-b032-3bd3710549d1.gif)
-# component {#module-component}
-
-The `ftxui::component` module defines the logic that produces interactive
-components that respond to user events (keyboard, mouse, etc.).
-
-A `ftxui::ScreenInteractive` defines a main loop that renders a component.
-
-A `ftxui::Component` is a shared pointer to a `ftxui::ComponentBase`. The latter defines:
-  - `ftxui::ComponentBase::Render()`: How to render the interface.
-  - `ftxui::ComponentBase::OnEvent()`: How to react to events.
-  - `ftxui::ComponentBase::Add()`: Construct a parent/child relationship
-    between two components. The tree of component is used to define how to
-    navigate using the keyboard.
-
-`ftxui::Element` are used to render a single frame.
-
-`ftxui::Component` are used to render dynamic user interface, producing multiple
-frame, and updating its state on events.
-
-[Gallery](https://arthursonzogni.github.io/FTXUI/examples_2component_2gallery_8cpp-example.html) of multiple components. ([demo](https://arthursonzogni.github.io/FTXUI/examples/?file=component/gallery))
-
-![image](https://user-images.githubusercontent.com/4759106/147247330-b60beb9f-e665-48b4-81c0-4b01ee95bc66.png)
-
-All predefined components are available in
-["ftxui/dom/component.hpp"](./component_8hpp.html)
-
-\include ftxui/component/component.hpp
-
-## Input {#component-input}
-
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2input_8cpp-example.html):
-
-![image](https://user-images.githubusercontent.com/4759106/147247671-f1d6f606-1845-4e94-a4a0-d4273e9ae6bd.png)
-
-Produced by: `ftxui::Input()` from "ftxui/component/component.hpp"
-
-@htmlonly
-<script id="asciicast-223719" src="https://asciinema.org/a/223719.js" async></script>
-@endhtmlonly
-
-### Filtered input
-
-On can filter out the characters received by the input component, using
-`ftxui::CatchEvent`.
-
-```cpp
-std::string phone_number;
-Component input = Input(&phone_number, "phone number");
-
-// Filter out non-digit characters.
-input |= CatchEvent([&](Event event) {
-  return event.is_character() && !std::isdigit(event.character()[0]);
-});
-
-// Filter out characters past the 10th one.
-input |= CatchEvent([&](Event event) {
-  return event.is_character() && phone_number.size() >= 10;
-});
-```
-
-## Menu {#component-menu}
-
-Defines a menu object. It contains a list of entries, one of them is selected.
-
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2menu_8cpp-example.html):
-
-![image](https://user-images.githubusercontent.com/4759106/147247822-0035fd6f-bb13-4b3a-b057-77eb9291582f.png)
-
-
-Produced by: `ftxui::Menu()` from "ftxui/component/component.hpp"
-
-@htmlonly
-<script id="asciicast-223720" src="https://asciinema.org/a/223720.js" async></script>
-@endhtmlonly
-
-## Toggle {#component-toggle}
-
-A special kind of menu. The entries are displayed horizontally.
-
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2toggle_8cpp-example.html):
-
-![image](https://user-images.githubusercontent.com/4759106/147249383-e2201cf1-b7b8-4a5a-916f-d761e3e7ae40.png)
-
-Produced by: `ftxui::Toggle()` from "ftxui/component/component.hpp"
-
-@htmlonly
-<script id="asciicast-223722" src="https://asciinema.org/a/223722.js" async></script>
-@endhtmlonly
-
-## CheckBox {#component-checkbox}
-
-This component defines a checkbox. It is a single entry that can be turned
-on/off.
-
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2checkbox_8cpp-example.html):
-
-![image](https://user-images.githubusercontent.com/4759106/147246646-b86926a9-1ef9-4efb-af98-48a9b62acd81.png)
-
-Produced by: `ftxui::Checkbox()` from "ftxui/component/component.hpp"
-
-@htmlonly
-<script id="asciicast-223724" src="https://asciinema.org/a/223724.js" async></script>
-@endhtmlonly
-
-## RadioBox {#component-radiobox}
-
-A radiobutton component. This is a list of entries, where one can be turned on.
-
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2radiobox_8cpp-example.html):
-  
-![image](https://user-images.githubusercontent.com/4759106/147246401-809d14a5-6621-4e36-8dd9-a2d75ef2a94e.png)
-
-Produced by: `ftxui::Radiobox()` from "ftxui/component/component.hpp"
-
-@htmlonly
-<script id="asciicast-223725" src="https://asciinema.org/a/223725.js" async></script>
-@endhtmlonly
-
-## Dropdown {#component-dropdown}
-
-A drop down menu is a component that when checked display a list of element for
-the user to select one.
-
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2dropdown_8cpp-example.html):
-
-![youtube-video-gif (3)](https://user-images.githubusercontent.com/4759106/147246982-1e821751-531c-4e1f-bc37-2fa290e143cd.gif)
-
-Produced by: `ftxui::Dropdown()` from "ftxui/component/component.hpp"
-
-## Slider {#component-slider}
-
-Represents a slider object that consists of a range with binned intermediate
-intervals. It can be created by `ftxui::Slider()`.
-
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2slider_8cpp-example.html):
-
-![image](https://user-images.githubusercontent.com/4759106/147249265-7e2cad75-082c-436e-affe-44a550c480ab.png)
-
-Produced by: `ftxui::Slider()` from "ftxui/component/component.hpp"
-
-## Renderer {#component-renderer}
-
-Produced by: `ftxui::Renderer()` from \ref ftxui/component/component.hpp. This
-component decorate another one by using a different function to render an
-interface.
-
-Example:
-```cpp
-auto inner = [...]
-
-auto renderer = Renderer(inner, [&] {
-  return inner->Render() | border
-});
-```
-
-`ftxui::Renderer` also supports the component decorator pattern:
-```cpp
-auto component = [...]
-component = component
-  | Renderer([](Element e) { return e | border))
-  | Renderer(bold)
-```
-
-As a short hand, you can also compose a component with an element decorator:
-```cpp
-auto component = [...]
-component = component | border | bold;
-```
-
-## CatchEvent {#component-catchevent}
-
-Produced by: `ftxui::CatchEvent()` from \ref ftxui/component/component.hpp.
-This component decorate others, catching events before the underlying component.
-
-Examples:
-```cpp
-auto screen = ScreenInteractive::TerminalOutput();
-auto renderer = Renderer([] {
-  return text("My interface");
-});
-auto component = CatchEvent(renderer, [&](Event event) {
-  if (event == Event::Character('q')) {
-    screen.ExitLoopClosure()();
-    return true;
-  }
-  return false;
-});
-screen.Loop(component);
-```
-
-The `ftxui::CatchEvent` can also be used as a decorator:
-```cpp
-component = component
-  | CatchEvent(handler_1)
-  | CatchEvent(handler_2)
-  | CatchEvent(handler_3)
-  ;
-```
-
-## Collapsible {#component-collapsible}
-
-Useful for visual elements whose visibility can be toggle on/off by the user.
-Essentially, this the combination of the `ftxui::Checkbox()` and
-`ftxui::Maybe()` components.
-
-```cpp
-auto collabsible = Collapsible("Show more", inner_element);
-```
-
-## Maybe {#component-maybe}
-
-Produced by: `ftxui::Maybe()` from \ref ftxui/component/component.hpp.
-This component can be utilized to show/hide any other component via a boolean or
-a predicate.
-
-Example with a boolean:
-```cpp
-bool show = true;
-auto component = Renderer([]{ return "Hello World!"; });
-auto maybe_component = Maybe(component, &show)
-```
-
-Example with a predicate:
-```cpp
-auto component = Renderer([]{ return "Hello World!"; });
-auto maybe_component = Maybe(component, [&] { return time > 10; })
-```
-
-As usual, `ftxui::Maybe` can also be used as a decorator:
-```cpp
-component = component
-  | Maybe(&a_boolean)
-  | Maybe([&] { return time > 10; })
-  ;
-```
-
-## Container {#component-container}
-
-### Horizontal {#component-horizontal}
-
-Produced by: `ftxui::Container::Horizontal()` from
-"ftxui/component/component.hpp". It displays a list of components horizontally
-and handle keyboard/mouse navigation.
-
-### Vertical {#component-vertical}
-
-Produced by: `ftxui::Container::Vertical()` from
-"ftxui/component/component.hpp". It displays a list of components vertically 
-and handles keyboard/mouse navigation.
-
-### Tab {#component-tab}
-
-Produced by: `ftxui::Container::Tab()` from
-"ftxui/component/component.hpp". It take a list of component and display only
-one of them. This is useful for implementing a tab bar.
-
-[Vertical](https://arthursonzogni.github.io/FTXUI/examples_2component_2tab_vertical_8cpp-example.html):
-  
-![ezgif com-gif-maker (1)](https://user-images.githubusercontent.com/4759106/147250144-22ff044a-4773-4ff7-a49c-12ba4034acb4.gif)
-
-[Horizontal](https://arthursonzogni.github.io/FTXUI/examples_2component_2tab_horizontal_8cpp-example.html):
-  
-  ![ezgif com-gif-maker (2)](https://user-images.githubusercontent.com/4759106/147250217-fe447e0f-7a99-4e08-948a-995087d9b40e.gif)
-
-
-## ResizableSplit  {#component-resizable-split}
-
-It defines a horizontal or vertical separation between two children components.
-The position of the split is variable and controllable using the mouse. 
-There are four possible splits:
-- `ftxui::ResizableSplitLeft()`
-- `ftxui::ResizableSplitRight()`
-- `ftxui::ResizableSplitTop()`
-- `ftxui::ResizableSplitBottom()`
-from "ftxui/component/component.hpp"
-
-[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2resizable_split_8cpp-example.html):
-
-![ezgif com-gif-maker](https://user-images.githubusercontent.com/4759106/147248372-c55512fe-9b96-4b08-a1df-d05cf2cae431.gif)  
-
-@htmlonly
-<script id="asciicast-tprMH2EdkUoMb7D2YxgMGgpzx" src="https://asciinema.org/a/tprMH2EdkUoMb7D2YxgMGgpzx.js" async></script>
-@endhtmlonly
-
-## Force a frame redraw. {#component-force-redraw}
-
-Typically, `ftxui::ScreenInteractive::Loop()` is responsible for drawing a new
-frame whenever a new group of events (e.g keyboard, mouse, window resize, etc.)
-has been processed. However, you might want to react to arbitrary events that
-are unknown to FTXUI. To accomplish this, you must post events using
-`ftxui::ScreenInteractive::PostEvent` (**this is thread safe**) via a thread.
-You will have to post the event `ftxui::Event::Custom`.
-
-Example:
-```cpp
-screen->PostEvent(Event::Custom);
-```

doc/module-component.md

@@ -0,0 +1,308 @@
+@page module-component ftxui / component
+@tableofcontents
+
+![title-img](https://nsm09.casimages.com/img/2025/05/31//2505310207423242518595349.png)
+
+The `ftxui::component` module defines the logic that produces interactive
+components that respond to user events (keyboard, mouse, etc.).
+
+The @subpage module-component-examples section provides a collection of examples.
+
+A `ftxui::ScreenInteractive` defines a main loop that renders a component.
+
+A `ftxui::Component` is a shared pointer to a `ftxui::ComponentBase`. The latter defines:
+  - `ftxui::ComponentBase::Render()`: How to render the interface.
+  - `ftxui::ComponentBase::OnEvent()`: How to react to events.
+  - `ftxui::ComponentBase::Add()`: Construct a parent/child relationship
+    between two components. The tree of components is used to define how to
+    navigate using the keyboard.
+
+`ftxui::Element` are used to render a single frame.
+
+`ftxui::Component` are used to render dynamic user interface, producing multiple
+frame, and updating its state on events.
+
+[Gallery](https://arthursonzogni.github.io/FTXUI/examples_2component_2gallery_8cpp-example.html) of multiple components. ([demo](https://arthursonzogni.github.io/FTXUI/examples/?file=component/gallery))
+
+![image](https://user-images.githubusercontent.com/4759106/147247330-b60beb9f-e665-48b4-81c0-4b01ee95bc66.png)
+
+All predefined components are available in
+["ftxui/dom/component.hpp"](./component_8hpp.html)
+
+\include ftxui/component/component.hpp
+
+# Input {#component-input}
+
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2input_8cpp-example.html):
+
+![image](https://user-images.githubusercontent.com/4759106/147247671-f1d6f606-1845-4e94-a4a0-d4273e9ae6bd.png)
+
+Produced by: `ftxui::Input()` from "ftxui/component/component.hpp"
+
+@htmlonly
+<script id="asciicast-223719" src="https://asciinema.org/a/223719.js" async></script>
+@endhtmlonly
+
+## Filtered input
+
+One can filter out the characters received by the input component, using
+`ftxui::CatchEvent`.
+
+```cpp
+std::string phone_number;
+Component input = Input(&phone_number, "phone number");
+
+// Filter out non-digit characters.
+input |= CatchEvent([&](Event event) {
+  return event.is_character() && !std::isdigit(event.character()[0]);
+});
+
+// Filter out characters past the 10th one.
+input |= CatchEvent([&](Event event) {
+  return event.is_character() && phone_number.size() >= 10;
+});
+```
+
+# Menu {#component-menu}
+
+Defines a menu object. It contains a list of entries, one of them is selected.
+
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2menu_8cpp-example.html):
+
+![image](https://user-images.githubusercontent.com/4759106/147247822-0035fd6f-bb13-4b3a-b057-77eb9291582f.png)
+
+
+Produced by: `ftxui::Menu()` from "ftxui/component/component.hpp"
+
+@htmlonly
+<script id="asciicast-223720" src="https://asciinema.org/a/223720.js" async></script>
+@endhtmlonly
+
+# Toggle {#component-toggle}
+
+A special kind of menu. The entries are displayed horizontally.
+
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2toggle_8cpp-example.html):
+
+![image](https://user-images.githubusercontent.com/4759106/147249383-e2201cf1-b7b8-4a5a-916f-d761e3e7ae40.png)
+
+Produced by: `ftxui::Toggle()` from "ftxui/component/component.hpp"
+
+@htmlonly
+<script id="asciicast-223722" src="https://asciinema.org/a/223722.js" async></script>
+@endhtmlonly
+
+# CheckBox {#component-checkbox}
+
+This component defines a checkbox. It is a single entry that can be turned
+on/off.
+
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2checkbox_8cpp-example.html):
+
+![image](https://user-images.githubusercontent.com/4759106/147246646-b86926a9-1ef9-4efb-af98-48a9b62acd81.png)
+
+Produced by: `ftxui::Checkbox()` from "ftxui/component/component.hpp"
+
+@htmlonly
+<script id="asciicast-223724" src="https://asciinema.org/a/223724.js" async></script>
+@endhtmlonly
+
+# RadioBox {#component-radiobox}
+
+A radiobutton component. This is a list of entries, where one can be turned on.
+
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2radiobox_8cpp-example.html):
+  
+![image](https://user-images.githubusercontent.com/4759106/147246401-809d14a5-6621-4e36-8dd9-a2d75ef2a94e.png)
+
+Produced by: `ftxui::Radiobox()` from "ftxui/component/component.hpp"
+
+@htmlonly
+<script id="asciicast-223725" src="https://asciinema.org/a/223725.js" async></script>
+@endhtmlonly
+
+# Dropdown {#component-dropdown}
+
+A drop-down menu is a component that, when opened, displays a list of elements
+for the user to select from.
+
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2dropdown_8cpp-example.html):
+
+![youtube-video-gif (3)](https://user-images.githubusercontent.com/4759106/147246982-1e821751-531c-4e1f-bc37-2fa290e143cd.gif)
+
+Produced by: `ftxui::Dropdown()` from "ftxui/component/component.hpp"
+
+# Slider {#component-slider}
+
+Represents a slider object that consists of a range with binned intermediate
+intervals. It can be created by `ftxui::Slider()`.
+
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2slider_8cpp-example.html):
+
+![image](https://user-images.githubusercontent.com/4759106/147249265-7e2cad75-082c-436e-affe-44a550c480ab.png)
+
+Produced by: `ftxui::Slider()` from "ftxui/component/component.hpp"
+
+# Renderer {#component-renderer}
+
+Produced by: `ftxui::Renderer()` from \ref ftxui/component/component.hpp. This
+component decorate another one by using a different function to render an
+interface.
+
+Example:
+```cpp
+auto inner = [...]
+
+auto renderer = Renderer(inner, [&] {
+  return inner->Render() | border
+});
+```
+
+`ftxui::Renderer` also supports the component decorator pattern:
+```cpp
+auto component = [...]
+component = component
+  | Renderer([](Element e) { return e | border))
+  | Renderer(bold)
+```
+
+As a short hand, you can also compose a component with an element decorator:
+```cpp
+auto component = [...]
+component = component | border | bold;
+```
+
+# CatchEvent {#component-catchevent}
+
+Produced by: `ftxui::CatchEvent()` from \ref ftxui/component/component.hpp.
+This component decorate others, catching events before the underlying component.
+
+Examples:
+```cpp
+auto screen = ScreenInteractive::TerminalOutput();
+auto renderer = Renderer([] {
+  return text("My interface");
+});
+auto component = CatchEvent(renderer, [&](Event event) {
+  if (event == Event::Character('q')) {
+    screen.ExitLoopClosure()();
+    return true;
+  }
+  return false;
+});
+screen.Loop(component);
+```
+
+The `ftxui::CatchEvent` can also be used as a decorator:
+```cpp
+component = component
+  | CatchEvent(handler_1)
+  | CatchEvent(handler_2)
+  | CatchEvent(handler_3)
+  ;
+```
+
+# Collapsible {#component-collapsible}
+
+Useful for visual elements whose visibility can be toggled on or off by the
+user. Essentially, this is the combination of the `ftxui::Checkbox()` and
+`ftxui::Maybe()` components.
+
+```cpp
+auto collapsible = Collapsible("Show more", inner_element);
+```
+
+# Maybe {#component-maybe}
+
+Produced by: `ftxui::Maybe()` from \ref ftxui/component/component.hpp.
+This component can be utilized to show/hide any other component via a boolean or
+a predicate.
+
+Example with a boolean:
+```cpp
+bool show = true;
+auto component = Renderer([]{ return "Hello World!"; });
+auto maybe_component = Maybe(component, &show)
+```
+
+Example with a predicate:
+```cpp
+auto component = Renderer([]{ return "Hello World!"; });
+auto maybe_component = Maybe(component, [&] { return time > 10; })
+```
+
+As usual, `ftxui::Maybe` can also be used as a decorator:
+```cpp
+component = component
+  | Maybe(&a_boolean)
+  | Maybe([&] { return time > 10; })
+  ;
+```
+
+# Container {#component-container}
+
+## Horizontal {#component-horizontal}
+
+Produced by: `ftxui::Container::Horizontal()` from
+"ftxui/component/component.hpp". It displays a list of components horizontally
+and handles keyboard/mouse navigation.
+
+## Vertical {#component-vertical}
+
+Produced by: `ftxui::Container::Vertical()` from
+"ftxui/component/component.hpp". It displays a list of components vertically 
+and handles keyboard/mouse navigation.
+
+## Tab {#component-tab}
+
+Produced by: `ftxui::Container::Tab()` from
+"ftxui/component/component.hpp". It takes a list of components and displays
+only one of them. This is useful for implementing a tab bar.
+
+[Vertical](https://arthursonzogni.github.io/FTXUI/examples_2component_2tab_vertical_8cpp-example.html):
+  
+![ezgif com-gif-maker (1)](https://user-images.githubusercontent.com/4759106/147250144-22ff044a-4773-4ff7-a49c-12ba4034acb4.gif)
+
+[Horizontal](https://arthursonzogni.github.io/FTXUI/examples_2component_2tab_horizontal_8cpp-example.html):
+  
+  ![ezgif com-gif-maker (2)](https://user-images.githubusercontent.com/4759106/147250217-fe447e0f-7a99-4e08-948a-995087d9b40e.gif)
+
+
+# ResizableSplit  {#component-resizable-split}
+
+It defines a horizontal or vertical separation between two children components.
+The position of the split is variable and controllable using the mouse. 
+There are four possible splits:
+- `ftxui::ResizableSplitLeft()`
+- `ftxui::ResizableSplitRight()`
+- `ftxui::ResizableSplitTop()`
+- `ftxui::ResizableSplitBottom()`
+from "ftxui/component/component.hpp"
+
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2component_2resizable_split_8cpp-example.html):
+
+![ezgif com-gif-maker](https://user-images.githubusercontent.com/4759106/147248372-c55512fe-9b96-4b08-a1df-d05cf2cae431.gif)  
+
+@htmlonly
+<script id="asciicast-tprMH2EdkUoMb7D2YxgMGgpzx" src="https://asciinema.org/a/tprMH2EdkUoMb7D2YxgMGgpzx.js" async></script>
+@endhtmlonly
+
+# Force a frame redraw. {#component-force-redraw}
+
+Typically, `ftxui::ScreenInteractive::Loop()` is responsible for drawing a new
+frame whenever a new group of events (e.g keyboard, mouse, window resize, etc.)
+has been processed. However, you might want to react to arbitrary events that
+are unknown to FTXUI. To accomplish this, you must post events using
+`ftxui::ScreenInteractive::PostEvent` (**this is thread safe**) via a thread.
+You will have to post the event `ftxui::Event::Custom`.
+
+Example:
+```cpp
+screen->PostEvent(Event::Custom);
+```
+
+If you don't need to process a new Event, you can use:
+```cpp
+screen->RequestAnimationFrame();
+```
+instead.

doc/module-dom.md

@@ -0,0 +1,470 @@
+@page module-dom ftxui / dom
+@tableofcontents
+
+![title-img](https://nsm09.casimages.com/img/2025/05/31//2505310207423242518595347.png)
+
+This module defines a hierarchical set of `ftxui::Element`. An element manages
+the layout and can be responsive to the terminal dimension changes. Note the
+following example where this module is used to create a simple layout with a
+number of operators:
+
+The @subpage module-dom-examples section provides a collection of examples.
+
+**Example:**
+```cpp
+namespace ftxui {
+    ...
+
+// Define the document
+Element document = vbox({
+  text("The window") | bold | color(Color::Blue),
+  gauge(0.5)
+  text("The footer")
+});
+
+// Add a border, by calling the `ftxui::border` decorator function.
+document = border(document);
+
+// Add another border, using the pipe operator.
+document = document | border.
+
+// Add another border, using the |= operator.
+document |= border
+
+...
+}
+```
+
+**List of elements**
+
+The list of all elements are included and can be accessed by including the
+corresponding header file:
+```cpp
+#include <ftxui/dom/elements.hpp>
+```
+
+\include{strip} "ftxui/dom/elements.hpp"
+
+# text # {#dom-text}
+
+The most simple widget. It displays a text.
+```cpp
+text("I am a piece of text");
+```
+```bash
+I am a piece of text.
+```
+
+# vtext {#dom-vtext}
+
+Identical to `ftxui::text`, but displayed vertically.
+
+Code:
+```cpp
+vtext("HELLO");
+```
+
+Terminal output:
+```bash
+H
+E
+L
+L
+O
+```
+
+# paragraph {#dom-paragraph}
+
+Similar to `ftxui::text`, but the individual word are wrapped along multiple
+lines, depending on the width of its container.
+
+Sample Code:
+```cpp
+paragraph("A very long text")
+```
+
+![ezgif com-gif-maker (4)](https://user-images.githubusercontent.com/4759106/147251370-983a06e7-6f41-4113-92b8-942f43d34d06.gif)
+
+For a more detailed example refer to [detailed example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2paragraph_8cpp-example.html). Paragraph also includes a number of other variants as shown below:
+```cpp
+namespace ftxui {
+    Element paragraph(std::string text);
+    Element paragraphAlignLeft(std::string text);
+    Element paragraphAlignRight(std::string text);
+    Element paragraphAlignCenter(std::string text);
+    Element paragraphAlignJustify(std::string text);
+}
+```
+
+
+# border {#dom-border}
+
+Adds a border around an element.
+
+Code:
+```cpp
+border(text("The element"))
+```
+
+Terminal output:
+```bash
+┌───────────┐
+│The element│
+└───────────┘
+```
+
+> [!note]
+> You can achieve the same behavior by using the pipe operator.
+> 
+> Code:
+> ```cpp
+> text("The element") | border
+> ```
+
+Border also comes in a variety of styles as shown below:
+```cpp
+namespace ftxui {
+    Element border(Element);
+    Element borderLight(Element);
+    Element borderHeavy(Element);
+    Element borderDouble(Element);
+    Element borderRounded(Element);
+    Element borderEmpty(Element);
+    Decorator borderStyled(BorderStyle);
+    Decorator borderWith(Pixel);
+}
+```
+
+
+# window # {#dom-window}
+
+A `ftxui::window` is a `ftxui::border`, but with an additional header. To add a
+window around an element, wrap it and specify a string as the header.
+Code:
+```cpp
+window("The window", text("The element"))
+```
+
+Terminal output:
+```bash
+┌The window─┐
+│The element│
+└───────────┘
+```
+
+# separator {#dom-separator}
+
+Displays a vertical/horizontal line to visually split the content of a
+container in two.
+
+Code:
+```cpp
+border(
+  hbox({
+    text("Left"), 
+    separator(),
+    text("Right")
+  })
+)
+```
+
+Terminal output:
+```bash
+┌────┬─────┐
+│left│right│
+└────┴─────┘
+```
+
+
+Separators come in a variety of flavors as shown below:
+```cpp
+namespace ftxui {
+    Element separator(void);
+    Element separatorLight();
+    Element separatorHeavy();
+    Element separatorDouble();
+    Element separatorEmpty();
+    Element separatorStyled(BorderStyle);
+    Element separator(Pixel);
+    Element separatorCharacter(std::string);
+    Element separatorHSelector(float left,
+                               float right,
+                               Color background,
+                               Color foreground);
+    Element separatorVSelector(float up,
+                               float down,
+                               Color background,
+                               Color foreground);
+}
+```
+
+# gauge {#dom-gauge}
+
+This is a visual element that represents a ratio of progress.
+
+Code:
+```cpp
+border(gauge(0.5))
+```
+
+Terminal output:
+```bash
+┌────────────────────────────────────────────────────────────────────────────┐
+│██████████████████████████████████████                                      │
+└────────────────────────────────────────────────────────────────────────────┘
+```
+
+Gauges can be displayed in many orientations as shown below:
+```cpp
+namespace {
+    Element gauge(float ratio);
+    Element gaugeLeft(float ratio);
+    Element gaugeRight(float ratio);
+    Element gaugeUp(float ratio);
+    Element gaugeDown(float ratio);
+    Element gaugeDirection(float ratio, GaugeDirection);
+}
+```
+
+# graph {#dom-graph}
+
+@htmlonly
+<script id="asciicast-223726" src="https://asciinema.org/a/223726.js" async></script>
+@endhtmlonly
+
+See:
+```cpp
+Element graph(GraphFunction);
+```
+
+# Colors {#dom-colors}
+
+Most terminal consoles can display colored text and colored backgrounds. FTXUI
+supports every color palette:
+```cpp
+Decorator color(Color);
+Decorator bgcolor(Color);
+```
+
+
+Color [gallery](https://arthursonzogni.github.io/FTXUI/examples_2dom_2color_gallery_8cpp-example.html):
+![image](https://user-images.githubusercontent.com/4759106/147248595-04c7245a-5b85-4544-809d-a5984fc6f9e7.png)
+
+## Palette16 #{#dom-colors-palette-16}
+
+On most terminals the following colors are supported:
+- Default
+
+- Black
+- GrayDark
+- GrayLight
+
+- White
+
+- Blue
+- BlueLight
+
+- Cyan
+- CyanLight
+
+- Green
+- GreenLight
+
+- Magenta
+- MagentaLight
+
+- Red
+- RedLight
+
+- Yellow
+- YellowLight
+
+Example use of the above colors using the pipe operator:
+```cpp
+text("Blue foreground") | color(Color::Blue);
+text("Blue background") | bgcolor(Color::Blue);
+text("Black on white") | color(Color::Black) | bgcolor(Color::White);
+```
+
+## Palette256 #{#dom-colors-palette-256}
+
+On terminal supporting 256 colors. 
+@htmlonly
+<script id="asciicast-OAUc3n6QrkmrLt7XEEb8AzbLt" src="https://asciinema.org/a/OAUc3n6QrkmrLt7XEEb8AzbLt.js" async></script>
+@endhtmlonly
+
+```cpp
+text("HotPink") | color(Color::HotPink);
+```
+
+## TrueColor #{#dom-colors-true-color}
+
+On terminal supporting trueColor, you can directly use the 24bit RGB color
+space:
+
+Use the constructors below to specify the **RGB** or **HSV** values for your
+color:
+
+There are two constructors:
+```cpp
+ftxui::Color::RGB(uint8_t red, uint8_t green, uint8_t blue);
+ftxui::Color::HSV(uint8_t hue, uint8_t saturation, uint8_t value);
+```
+
+@htmlonly
+<script id="asciicast-dk5r8IcCH0aFIIgWG0keSEHMG" src="https://asciinema.org/a/dk5r8IcCH0aFIIgWG0keSEHMG.js" async></script>
+<script id="asciicast-xwzzghmqcqzIuyLwCpQFEqbEu" src="https://asciinema.org/a/xwzzghmqcqzIuyLwCpQFEqbEu.js" async></script>
+@endhtmlonly
+
+# LinearGradient #{#dom-linear-gradient}
+
+FTXUI supports linear gradient. Either on the foreground or the background.
+
+```cpp
+Decorator color(const LinearGradient&);
+Decorator bgcolor(const LinearGradient&);
+```
+
+A `ftxui::LinearGradient` is defined by an angle in degree, and a list of color
+stops.
+```cpp
+auto gradient = LinearGradient()
+  .Angle(45)
+  .AddStop(0.0, Color::Red)
+  .AddStop(0.5, Color::Green)
+  .AddStop(1.0, Color::Blue);
+```
+
+You can also use simplified constructors:
+```cpp
+LinearGradient(Color::Red, Color::Blue);
+```
+```cpp
+LinearGradient(45, Color::Red, Color::Blue);
+```
+
+See [demo](https://arthursonzogni.github.io/FTXUI/examples/?file=component/linear_gradient_gallery).
+
+
+# Style {#dom-style}
+In addition to colored text and colored backgrounds. Many terminals support text
+effects such as: `bold`, `italic`, `dim`, `underlined`, `inverted`, `blink`.
+
+```cpp
+Element bold(Element);
+Element italic(Element);
+Element dim(Element);
+Element inverted(Element);
+Element underlined(Element);
+Element underlinedDouble(Element);
+Element strikethrough(Element);
+Element blink(Element);
+Decorator color(Color);
+Decorator bgcolor(Color);
+Decorator colorgrad(LinearGradient);
+Decorator bgcolorgrad(LinearGradient);
+```
+
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2style_gallery_8cpp-example.html)
+
+![image](https://user-images.githubusercontent.com/4759106/147244118-380bf834-9e33-40df-9ff0-07c10f2598ef.png)
+
+To use these effects, simply wrap your elements with your desired effect:
+```cpp
+underlined(bold(text("This text is bold and underlined")))
+```
+
+Alternatively, use the pipe operator to chain it on your element:
+```cpp
+text("This text is bold") | bold | underlined
+```
+
+# Layout {#dom-layout}
+
+Enables elements to be arranged in the following ways:
+  - **Horizontally** with `ftxui::hbox`
+  - **Vertically** with `ftxui::vbox`
+  - **Inside a grid** with `ftxui::gridbox`
+  - **Wrapped along one direction** using the `ftxui::flexbox`.
+  
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2vbox_hbox_8cpp-example.html) using `ftxui::hbox`, `ftxui::vbox` and `ftxui::filler`.
+
+![image](https://user-images.githubusercontent.com/4759106/147242524-7103b5d9-1a92-4e2d-ac70-b3d6740061e3.png)
+  
+  
+[Example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2gridbox_8cpp-example.htmlp)
+using `ftxui::gridbox`:
+
+![image](https://user-images.githubusercontent.com/4759106/147242972-0db1f2e9-0790-496f-86e6-ed2c604f7a73.png)
+
+[Example](https://github.com/ArthurSonzogni/FTXUI/blob/master/examples/dom/hflow.cpp)
+using flexbox:
+
+![image](https://user-images.githubusercontent.com/4759106/147243064-780ac7cc-605b-475f-94b8-cf7c4aed03a5.png)
+
+Checkout this
+[example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2hflow_8cpp-example.html)
+and the associated
+[demo](https://arthursonzogni.github.io/FTXUI/examples/?file=component/flexbox).
+
+Element can also become flexible using the `ftxui::flex` decorator.
+
+Code:
+```cpp
+  hbox({
+    text("left") | border ,
+    text("middle") | border | flex,
+    text("right") | border,
+  });
+```
+Terminal output:
+```bash
+┌────┐┌─────────────────────────────────────────────────────┐┌─────┐
+│left││middle                                               ││right│
+└────┘└─────────────────────────────────────────────────────┘└─────┘
+```
+
+Code:
+```cpp
+  hbox({
+    text("left") | border ,
+    text("middle") | border | flex,
+    text("right") | border | flex,
+  });
+```
+
+Terminal output:
+```bash
+┌────┐┌───────────────────────────────┐┌───────────────────────────────┐
+│left││middle                         ││right                          │
+└────┘└───────────────────────────────┘└───────────────────────────────┘
+```
+
+# Table {#dom-table}
+
+Enables easy formatting of data into a neat table like visual form.
+
+[Code example](https://arthursonzogni.github.io/FTXUI/examples_2dom_2table_8cpp-example.html):
+  
+![image](https://user-images.githubusercontent.com/4759106/147250766-77d8ec9e-cf2b-486d-9866-1fd9f1bd2e6b.png)
+
+# Canvas {#dom-canvas}
+
+See the API [<ftxui/dom/canvas.hpp>](./canvas_8hpp_source.html)
+
+```cpp
+  auto c = Canvas(100, 100);
+  c.DrawPointLine(10, 10, 80, 10, Color::Red);
+  auto element = canvas(c);
+```
+
+Drawing can be performed on a `ftxui::Canvas`, using braille, block, or simple
+characters:
+  
+Simple [example](https://github.com/ArthurSonzogni/FTXUI/blob/master/examples/dom/canvas.cpp):
+  
+![image](https://user-images.githubusercontent.com/4759106/147245843-76cc62fb-ccb4-421b-aacf-939f9afb42fe.png)
+
+Complex [example](https://github.com/ArthurSonzogni/FTXUI/blob/master/examples/component/canvas_animated.cpp):
+  
+![ezgif com-gif-maker (3)](https://user-images.githubusercontent.com/4759106/147250538-783a8246-98e0-4a25-b032-3bd3710549d1.gif)

doc/module-screen.md

@@ -0,0 +1,202 @@
+@page module-screen ftxui / screen
+@tableofcontents
+
+![title-img](https://nsm09.casimages.com/img/2025/05/31//2505310207423242518595348.png)
+
+The `ftxui::screen` module is the low-level foundation. It can be used
+standalone, but it is primarily designed to be used together by
+[ftxui::dom](module-dom.html) and [ftxui::component](module-component.html)
+modules.
+
+It provides a @ref ftxui::Screen.
+
+---
+
+# ftxui::Screen
+
+The @ref ftxui::Screen class represents a 2D grid of styled characters that can
+be rendered to a terminal.  
+It provides methods to create a screen, access pixels, and render elements.
+
+You can access the individual cells (@ref ftxui::Pixel) of the screen using 
+the @ref ftxui::Screen::PixelAt method, which returns a reference
+to the pixel at the specified coordinates.
+
+**Example**
+```cpp
+#include <ftxui/screen/screen.hpp>
+#include <ftxui/screen/color.hpp>
+
+void main() {
+    auto screen = ftxui::Screen::Create(
+        ftxui::Dimension::Full(),   // Use full terminal width
+        ftxui::Dimension::Fixed(10) // Fixed height of 10 rows
+    );
+
+    // Access a specific pixel at (10, 5)
+    auto& pixel = screen.PixelAt(10, 5);
+
+    // Set properties of the pixel.
+    pixel.character = U'X';
+    pixel.foreground_color = ftxui::Color::Red;
+    pixel.background_color = ftxui::Color::RGB(0, 255, 0);
+    pixel.bold = true; // Set bold style
+    screen.Print(); // Print the screen to the terminal
+}
+```
+
+> [!note]
+> If the coordinates are out of bounds, a dummy pixel is returned.
+
+The screen can be printed to the terminal using @ref ftxui::Screen::Print() or
+converted to a std::string with @ref ftxui::Screen::ToString().
+
+<div class="tabbed">
+ 
+- <b class="tab-title">Print()</b>
+  ```cpp
+  auto screen = ...;
+  screen.Print();
+  ```
+- <b class="tab-title">ToString()</b>
+  ```cpp
+  auto screen = ...;
+  std::cout << screen.ToString();
+  ```
+ 
+</div>
+
+Note that you can reset the cursor position to the top-left corner of the
+screen after printing by calling @ref ftxui::Screen::ResetCursorPosition().
+
+**Example**
+```cpp
+auto screen = ...;
+while(true) {
+  // Drawing operations:
+  ...
+  
+  // Print the screen to the terminal. Then reset the cursor position and the
+  // screen content.
+  std::cout << screen.ToString();
+  std::cout << screen.ResetCursorPosition(/*clear=*/true);
+  std::cout << std::flush;
+
+  // Sleep for a short duration to control the refresh rate.
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+}
+```
+
+---
+
+# ftxui::Dimension
+
+The @ref ftxui::Dimension utility controls screen sizing:
+
+* `Dimension::Full()` — use full terminal width or height
+* `Dimension::Fit(element)` — size to fit the rendered @ref ftxui::Element
+* `Dimension::Fixed(n)` — use exactly `n` columns or rows
+
+These values are to be passed to `ftxui::Screen::Create()`.
+
+@ref ftxui::Screen::Create() provides two overloads:
+
+- `Screen::Create(Dimension)` sets both width and height to the same kind of dimension
+- `Screen::Create(Dimension width, Dimension height)` allows distinct control per axis
+
+```cpp
+auto screen = ftxui::Screen::Create(
+  ftxui::Dimension::Full(),      // width
+  ftxui::Dimension::Fixed(10)    // height
+);
+```
+
+Once created, render an element and display the result:
+
+```cpp
+ftxui::Render(screen, element);
+screen.Print();
+```
+
+---
+
+# ftxui::Pixel
+
+Each cell in the screen grid is a @ref ftxui::Pixel, which holds:
+
+- Unicode codepoint.
+    - `character`
+- @ref ftxui::Color:
+    - `foreground_color`
+    - `background_color`
+- Booleans:
+    - `blink`
+    - `bold`
+    - `dim`
+    - `italic`
+    - `inverted` (swap foreground and background colors)
+    - `underlined`
+    - `underlined_double`
+    - `strikethrough`
+
+
+```cpp
+auto screen = ftxui::Screen::Create(
+  ftxui::Dimension::Fixed(5),
+  ftxui::Dimension::Fixed(5),
+);
+
+auto& pixel = screen.PixelAt(3, 3);
+pixel.character = U'X';
+pixel.bold = true;
+pixel.foreground_color = ftxui::Color::Red;
+pixel.background_color = ftxui::Color::RGB(0, 255, 0);
+
+screen.Print();
+```
+
+> [!note]
+> `PixelAt(x, y)` performs bounds checking and returns a reference to the pixel
+> at the specified coordinate. If out-of-bounds, a dummy pixel reference is
+> returned.
+
+
+Each cell in the screen is a @ref ftxui::Pixel. You can modify them using:
+
+```cpp
+auto& pixel = screen.PixelAt(x, y);
+pixel.character = U'X';
+pixel.bold = true;
+pixel.foreground_color = Color::Red;
+```
+
+---
+
+# ftxui::Color
+
+The @ref ftxui::Color class is used to define foreground and background colors for each @ref ftxui::Pixel.
+
+It supports various color spaces and predefined palettes. FTXUI will
+dynamically fallback to the closest available color in the terminal if the
+requested color is not supported by the terminal.
+
+**Color Spaces**
+
+- **Default**: `ftxui::Color::Default` (terminal's default color)
+- **16-color palette** [Demo](https://arthursonzogni.github.io/FTXUI/examples/?file=dom/color_gallery):
+    - `ftxui::Color::Black`,
+    - `ftxui::Color::Red`,
+    - ...
+- **256-color palette** [Demo](https://arthursonzogni.github.io/FTXUI/examples/?file=dom/color_palette256):
+    - `ftxui::Color::Chartreuse1`,
+    - `ftxui::Color::DarkViolet`,
+    - ...
+- **True color** (24bit) [Demo](https://arthursonzogni.github.io/FTXUI/examples/?file=dom/color_truecolor_HSV:
+    - `ftxui::Color::RGB(uint8_t red, uint8_t green, uint8_t blue)`
+    - `ftxui::Color::HSV(uint8_t h, uint8_t s, uint8_t v)`.
+    
+
+> [!note]
+> You can query the terminal capability using @ref ftxui::Terminal::ColorSupport();
+>
+> This can manually be set using @ref ftxui::Terminal::SetColorSupport().

doc/module.md

@@ -0,0 +1,74 @@
+# ftxui {#ftxui}
+
+![title-img](https://nsm09.casimages.com/img/2025/05/30//2505300816063242518595251.jpg)
+
+FTXUI is organized into three modules, each building upon the previous:
+
+1. [ftxui/screen](#module-screen) - Low-level rendering
+2. [ftxui/dom](#module-dom) - Layout and composition
+3. [ftxui/component](#module-component) - User interaction
+
+---
+
+# ftxui/screen
+
+Defines:
+
+- **`ftxui::Screen`**: a 2D grid of styled characters.
+- **`ftxui::Pixel`**: the unit of rendering.
+- Helpers like `ftxui::Color` and `Dimension`.
+
+Use for direct terminal drawing and styling.
+
+<div class="section_buttons">
+ 
+|                                  Next |
+|--------------------------------------:|
+| [Documentation](module-screen.html) |
+ 
+</div>
+
+
+---
+
+# ftxui/dom
+
+Provides:
+
+- **`ftxui::Element`**: a tree structure for layout and UI.
+- Composable and responsive elements.
+- `Render()` to draw onto a `Screen`.
+
+Ideal for structured, styled UIs.
+
+<div class="section_buttons">
+
+|                                  Next |
+|--------------------------------------:|
+| [Documentation](module-dom.html) |
+
+</div>
+
+
+---
+# ftxui/component
+
+Adds:
+
+- **`ftxui::Component`**: stateful, interactive widgets.
+- Built-ins: `Checkbox`, `Input`, `Menu`, `Button`.
+- Supports keyboard/cursor input and composition.
+
+Use for interactive apps.
+
+<div class="section_buttons">
+
+|                                  Next |
+|--------------------------------------:|
+| [Documentation](module-component.html) |
+
+</div>
+
+---
+
+Modules can be used independently, or together: `screen → dom → component`.

doc/posix_pipe.md

@@ -0,0 +1,58 @@
+# POSIX Piped Input in FTXUI
+
+> [!WARNING]
+> This feature works only on Linux and macOS. It is not supported on
+> Windows and WebAssembly.
+
+## What is a POSIX Pipe?
+
+A POSIX pipe is a way for two separate programs to communicate. One program sends its output directly as input to another program. Think of it like a one-way tube for data.
+
+**Example:**
+
+Imagine you want to list files and then filter them interactively.
+
+- `ls`: Lists files.
+- `interactive_grep`: An FTXUI application that filters text and lets you type.
+
+You can connect them with a pipe (`|`):
+
+```bash
+ls -l | interactive_grep
+```
+
+Here's what happens:
+1. `ls -l` lists files with details.
+2. The `|` sends this list directly to `interactive_grep`.
+3. `interactive_grep` receives the list and displays it. Because it's an FTXUI app, you can then type to filter the list, even though it received initial data from `ls`.
+
+## How FTXUI Handles Piped Input
+
+Now that you understand what a POSIX pipe is, let's look at how FTXUI uses them.
+
+FTXUI lets your application read data from other programs (like from a pipe) while still allowing you to use your keyboard for interaction. This is useful for interactive command-line tools that process data.
+
+Normally, FTXUI applications receive all input from `stdin`. However, when FTXUI detects that `stdin` is connected to the output of a pipe (meaning data is being piped into your application), it automatically switches to reading interactive keyboard input from `/dev/tty`. This ensures that your application can still receive user input even while processing piped data.
+
+This feature is **turned on by default**.
+
+If your FTXUI application needs to read piped data and also respond to keyboard input, you typically don't need to do anything special:
+
+```cpp
+auto screen = ScreenInteractive::Fullscreen();
+// screen.HandlePipedInput(true); // This is enabled by default
+screen.Loop(component);
+```
+
+
+## Turning Off Piped Input
+
+If you don't need this feature, or if it conflicts with your custom input handling, you can turn it off.
+
+To disable it, call `HandlePipedInput(false)` before starting your application's main loop:
+
+```cpp
+auto screen = ScreenInteractive::Fullscreen();
+screen.HandlePipedInput(false); // Turn off piped input handling
+screen.Loop(component);
+```

doc/stylesheet.css

@@ -0,0 +1,119 @@
+html {
+  --primary-color: #9ed072;         /* green (identifier, strings) */
+  --primary-dark-color: #f39660;    /* orange (functions, tags) */
+  --primary-light-color: #7fbbb3;   /* teal (types, decorators) */
+
+  --page-background-color: #2c2e34; /* main background */
+  --page-foreground-color: #e2e2e3; /* main text */
+  --page-secondary-foreground-color: #9aa5ce; /* dim text */
+  --separator-color: #3b3e48;
+  --side-nav-background: #1a1b26;
+
+  --code-background: #2a2e38;
+  --code-foreground: #e2e2e3;
+
+  --tablehead-background: #1f1f28;
+
+  --blockquote-background: #3a3e44;
+  --blockquote-foreground: #d4bfff;
+
+  --warning-color: #e0af68;
+  --warning-color-dark: #ff9e64;
+  --warning-color-darker: #f7768e;
+  --bug-color: #f7768e;
+
+  --fragment-background: #222222;
+  --fragment-foreground: #e2e2e3;
+  --fragment-keyword: #f7768e;       /* pink */
+  --fragment-keywordtype: #7fbbb3;   /* teal */
+  --fragment-keywordflow: #e0af68;   /* orange-yellow */
+  --fragment-token: #9ed072;         /* green */
+  --fragment-comment: #5c6370;
+  --fragment-link: #7aa2f7;          /* blue link */
+  --fragment-preprocessor: #f39660;  /* orange */
+  --fragment-linenumber-color: #414868;
+  --fragment-linenumber-background: #2c2e34;
+  --fragment-linenumber-border: #1a1b26;
+  --fragment-lineheight: 1.125em;
+}
+
+/* Base style for all sections */
+.section.note,
+.section.warning,
+.section.remark,
+.section.attention,
+.section.important {
+  border-left: 4px solid var(--primary-dark-color);
+  border-radius: 6px;
+  padding: 0.9em 1.2em;
+  margin: 1.5em 0;
+  background-color: #2e303e;
+  color: var(--page-foreground-color);
+  font-size: 0.95em;
+}
+
+/* Section title */
+.section.note dt,
+.section.warning dt,
+.section.remark dt,
+.section.attention dt,
+.section.important dt {
+  font-weight: bold;
+  display: block;
+  margin-bottom: 0.35em;
+}
+
+/* Section body */
+.section.note dd,
+.section.warning dd,
+.section.remark dd,
+.section.attention dd,
+.section.important dd {
+  margin: 0;
+}
+
+/* Note - soft cyan */
+.section.note {
+  border-left-color: #7fbbb3;
+  background-color: #263640;
+}
+.section.note dt {
+  color: #7fbbb3;
+}
+
+/* Warning - amber */
+.section.warning {
+  border-left-color: #e0af68;
+  background-color: #3d2f1f;
+}
+.section.warning dt {
+  color: #e0af68;
+}
+
+/* Tip (Remark) - green */
+.section.remark {
+  border-left-color: #9ed072;
+  background-color: #2d3a2d;
+}
+.section.remark dt {
+  color: #9ed072;
+}
+
+/* Caution (Attention) - bold red-orange */
+.section.attention {
+  border-left-color: #f7768e;
+  background-color: #3d2a2e;
+}
+.section.attention dt {
+  color: #f7768e;
+}
+
+/* Important - purple */
+.section.important {
+  border-left-color: #ab9df2;
+  background-color: #2f2a3a;
+}
+.section.important dt {
+  color: #ab9df2;
+}
+

examples/CMakeLists.txt

@@ -15,16 +15,14 @@ add_subdirectory(component)
 add_subdirectory(dom)
 
 if (EMSCRIPTEN)
-  string(APPEND CMAKE_EXE_LINKER_FLAGS " -s ALLOW_MEMORY_GROWTH=1")
-  target_link_options(component PUBLIC "SHELL: -s ALLOW_MEMORY_GROWTH=1")
-
   get_property(EXAMPLES GLOBAL PROPERTY FTXUI::EXAMPLES)
   foreach(file
+      "index.css"
       "index.html"
       "index.mjs"
-      "index.css"
+      "run_webassembly.py"
       "sw.js"
-      "run_webassembly.py")
+  )
     configure_file(${file} ${file})
   endforeach(file)
 endif()

examples/component/CMakeLists.txt

@@ -39,6 +39,7 @@ example(radiobox)
 example(radiobox_in_frame)
 example(renderer)
 example(resizable_split)
+example(resizable_split_clamp)
 example(scrollbar)
 example(selection)
 example(slider)

examples/component/button.cpp

@@ -1,9 +1,64 @@
-#include "ftxui/component/component.hpp"
-#include "ftxui/component/screen_interactive.hpp"
+// Copyright 2020 Arthur Sonzogni. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+#include <memory>  // for shared_ptr, __shared_ptr_access
+#include <string>  // for operator+, to_string
 
-int main(){
-    auto screen = ftxui::ScreenInteractive::Fullscreen();
-    auto testComponent = ftxui::Renderer([](){return ftxui::text("test Component");});
-    screen.Loop(testComponent);
-    return 0;
+#include "ftxui/component/captured_mouse.hpp"  // for ftxui
+#include "ftxui/component/component.hpp"  // for Button, Horizontal, Renderer
+#include "ftxui/component/component_base.hpp"      // for ComponentBase
+#include "ftxui/component/screen_interactive.hpp"  // for ScreenInteractive
+#include "ftxui/dom/elements.hpp"  // for separator, gauge, text, Element, operator|, vbox, border
+
+using namespace ftxui;
+
+// This is a helper function to create a button with a custom style.
+// The style is defined by a lambda function that takes an EntryState and
+// returns an Element.
+// We are using `center` to center the text inside the button, then `border` to
+// add a border around the button, and finally `flex` to make the button fill
+// the available space.
+ButtonOption Style() {
+  auto option = ButtonOption::Animated();
+  option.transform = [](const EntryState& s) {
+    auto element = text(s.label);
+    if (s.focused) {
+      element |= bold;
+    }
+    return element | center | borderEmpty | flex;
+  };
+  return option;
+}
+
+int main() {
+  int value = 50;
+
+  // clang-format off
+  auto btn_dec_01 = Button("-1", [&] { value -= 1; }, Style());
+  auto btn_inc_01 = Button("+1", [&] { value += 1; }, Style());
+  auto btn_dec_10 = Button("-10", [&] { value -= 10; }, Style());
+  auto btn_inc_10 = Button("+10", [&] { value += 10; }, Style());
+  // clang-format on
+
+  // The tree of components. This defines how to navigate using the keyboard.
+  // The selected `row` is shared to get a grid layout.
+  int row = 0;
+  auto buttons = Container::Vertical({
+      Container::Horizontal({btn_dec_01, btn_inc_01}, &row) | flex,
+      Container::Horizontal({btn_dec_10, btn_inc_10}, &row) | flex,
+  });
+
+  // Modify the way to render them on screen:
+  auto component = Renderer(buttons, [&] {
+    return vbox({
+               text("value = " + std::to_string(value)),
+               separator(),
+               buttons->Render() | flex,
+           }) |
+           flex | border;
+  });
+
+  auto screen = ScreenInteractive::FitComponent();
+  screen.Loop(component);
+  return 0;
 }

examples/component/canvas_animated.cpp

@@ -133,8 +133,9 @@ int main() {
       float dy = 50.f;
       ys[x] = int(dy + 20 * cos(dx * 0.14) + 10 * sin(dx * 0.42));
     }
-    for (int x = 1; x < 99; x++)
+    for (int x = 1; x < 99; x++) {
       c.DrawPointLine(x, ys[x], x + 1, ys[x + 1]);
+    }
 
     return canvas(std::move(c));
   });

examples/component/flexbox_gallery.cpp

@@ -82,10 +82,12 @@ int main() {
                    size(WIDTH, EQUAL, dimx) | size(HEIGHT, EQUAL, dimy) |
                    bgcolor(Color::HSV(index * 25, 255, 255)) |
                    color(Color::Black);
-    if (element_xflex_grow)
+    if (element_xflex_grow) {
       element = element | xflex_grow;
-    if (element_yflex_grow)
+    }
+    if (element_yflex_grow) {
       element = element | yflex_grow;
+    }
     return element;
   };
 
@@ -119,10 +121,12 @@ int main() {
 
     group = group | notflex;
 
-    if (!group_xflex_grow)
+    if (!group_xflex_grow) {
       group = hbox(group, filler());
-    if (!group_yflex_grow)
+    }
+    if (!group_yflex_grow) {
       group = vbox(group, filler());
+    }
 
     group = group | flex;
     return group;

examples/component/homescreen.cpp

@@ -1,11 +1,12 @@
 // Copyright 2020 Arthur Sonzogni. All rights reserved.
 // Use of this source code is governed by the MIT license that can be found in
 // the LICENSE file.
-#include <stddef.h>    // for size_t
-#include <array>       // for array
-#include <atomic>      // for atomic
-#include <chrono>      // for operator""s, chrono_literals
-#include <cmath>       // for sin
+#include <stddef.h>  // for size_t
+#include <array>     // for array
+#include <atomic>    // for atomic
+#include <chrono>    // for operator""s, chrono_literals
+#include <cmath>     // for sin
+#include <ftxui/component/loop.hpp>
 #include <functional>  // for ref, reference_wrapper, function
 #include <memory>      // for allocator, shared_ptr, __shared_ptr_access
 #include <string>  // for string, basic_string, char_traits, operator+, to_string
@@ -269,7 +270,7 @@ int main() {
   auto spinner_tab_renderer = Renderer([&] {
     Elements entries;
     for (int i = 0; i < 22; ++i) {
-      entries.push_back(spinner(i, shift / 2) | bold |
+      entries.push_back(spinner(i, shift / 5) | bold |
                         size(WIDTH, GREATER_THAN, 2) | border);
     }
     return hflow(std::move(entries));
@@ -512,24 +513,20 @@ int main() {
     });
   });
 
-  std::atomic<bool> refresh_ui_continue = true;
-  std::thread refresh_ui([&] {
-    while (refresh_ui_continue) {
-      using namespace std::chrono_literals;
-      std::this_thread::sleep_for(0.05s);
-      // The |shift| variable belong to the main thread. `screen.Post(task)`
-      // will execute the update on the thread where |screen| lives (e.g. the
-      // main thread). Using `screen.Post(task)` is threadsafe.
-      screen.Post([&] { shift++; });
-      // After updating the state, request a new frame to be drawn. This is done
-      // by simulating a new "custom" event to be handled.
-      screen.Post(Event::Custom);
-    }
-  });
+  Loop loop(&screen, main_renderer);
+  while (!loop.HasQuitted()) {
+    // Update the state of the application.
+    shift++;
 
-  screen.Loop(main_renderer);
-  refresh_ui_continue = false;
-  refresh_ui.join();
+    // Request a new frame to be drawn.
+    screen.RequestAnimationFrame();
+
+    // Execute events, and draw the next frame.
+    loop.RunOnce();
+
+    // Sleep for a short duration to control the frame rate (60 FPS).
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000 / 60));
+  }
 
   return 0;
 }

examples/component/menu_entries.cpp

@@ -22,10 +22,12 @@ MenuEntryOption Colored(ftxui::Color c) {
   option.transform = [c](EntryState state) {
     state.label = (state.active ? "> " : "  ") + state.label;
     Element e = text(state.label) | color(c);
-    if (state.focused)
+    if (state.focused) {
       e = e | inverted;
-    if (state.active)
+    }
+    if (state.active) {
       e = e | bold;
+    }
     return e;
   };
   return option;

examples/component/menu_in_frame.cpp

@@ -17,8 +17,9 @@ int main() {
   std::vector<std::string> entries;
   int selected = 0;
 
-  for (int i = 0; i < 30; ++i)
+  for (int i = 0; i < 30; ++i) {
     entries.push_back("Entry " + std::to_string(i));
+  }
   auto radiobox = Menu(&entries, &selected);
   auto renderer = Renderer(radiobox, [&] {
     return radiobox->Render() | vscroll_indicator | frame |

examples/component/menu_in_frame_horizontal.cpp

@@ -17,8 +17,9 @@ int main() {
   std::vector<std::string> entries;
   int selected = 0;
 
-  for (int i = 0; i < 100; ++i)
+  for (int i = 0; i < 100; ++i) {
     entries.push_back(std::to_string(i));
+  }
   auto radiobox = Menu(&entries, &selected, MenuOption::Horizontal());
   auto renderer = Renderer(
       radiobox, [&] { return radiobox->Render() | hscroll_indicator | frame; });

examples/component/menu_style.cpp

@@ -116,10 +116,12 @@ Component VMenu1(std::vector<std::string>* entries, int* selected) {
   option.entries_option.transform = [](EntryState state) {
     state.label = (state.active ? "> " : "  ") + state.label;
     Element e = text(state.label);
-    if (state.focused)
+    if (state.focused) {
       e = e | bgcolor(Color::Blue);
-    if (state.active)
+    }
+    if (state.active) {
       e = e | bold;
+    }
     return e;
   };
   return Menu(entries, selected, option);
@@ -130,10 +132,12 @@ Component VMenu2(std::vector<std::string>* entries, int* selected) {
   option.entries_option.transform = [](EntryState state) {
     state.label += (state.active ? " <" : "  ");
     Element e = hbox(filler(), text(state.label));
-    if (state.focused)
+    if (state.focused) {
       e = e | bgcolor(Color::Red);
-    if (state.active)
+    }
+    if (state.active) {
       e = e | bold;
+    }
     return e;
   };
   return Menu(entries, selected, option);
@@ -144,13 +148,16 @@ Component VMenu3(std::vector<std::string>* entries, int* selected) {
   option.entries_option.transform = [](EntryState state) {
     Element e = state.active ? text("[" + state.label + "]")
                              : text(" " + state.label + " ");
-    if (state.focused)
+    if (state.focused) {
       e = e | bold;
+    }
 
-    if (state.focused)
+    if (state.focused) {
       e = e | color(Color::Blue);
-    if (state.active)
+    }
+    if (state.active) {
       e = e | bold;
+    }
     return e;
   };
   return Menu(entries, selected, option);
@@ -245,10 +252,12 @@ Component HMenu5(std::vector<std::string>* entries, int* selected) {
                                 animation::easing::ElasticOut);
   option.entries_option.transform = [](EntryState state) {
     Element e = text(state.label) | hcenter | flex;
-    if (state.active && state.focused)
+    if (state.active && state.focused) {
       e = e | bold;
-    if (!state.focused && !state.active)
+    }
+    if (!state.focused && !state.active) {
       e = e | dim;
+    }
     return e;
   };
   option.underline.color_inactive = Color::Default;

examples/component/menu_underline_animated_gallery.cpp

@@ -20,8 +20,9 @@ using namespace ftxui;
 Component DummyComponent(int id) {
   return Renderer([id](bool focused) {
     auto t = text("component " + std::to_string(id));
-    if (focused)
+    if (focused) {
       t = t | inverted;
+    }
     return t;
   });
 }

examples/component/radiobox_in_frame.cpp

@@ -17,8 +17,9 @@ int main() {
   std::vector<std::string> entries;
   int selected = 0;
 
-  for (int i = 0; i < 30; ++i)
+  for (int i = 0; i < 30; ++i) {
     entries.push_back("RadioBox " + std::to_string(i));
+  }
   auto radiobox = Radiobox(&entries, &selected);
   auto renderer = Renderer(radiobox, [&] {
     return radiobox->Render() | vscroll_indicator | frame |

examples/component/renderer.cpp

@@ -19,10 +19,11 @@ int main() {
 
   // 1. Example of focusable renderer:
   auto renderer_focusable = Renderer([](bool focused) {
-    if (focused)
+    if (focused) {
       return text("FOCUSABLE RENDERER()") | center | bold | border;
-    else
+    } else {
       return text(" Focusable renderer() ") | center | border;
+    }
   });
 
   // 2. Examples of a non focusable renderer.
@@ -33,10 +34,11 @@ int main() {
   // 3. Renderer can wrap other components to redefine their Render() function.
   auto button = Button("Wrapped quit button", screen.ExitLoopClosure());
   auto renderer_wrap = Renderer(button, [&] {
-    if (button->Focused())
+    if (button->Focused()) {
       return button->Render() | bold | color(Color::Red);
-    else
+    } else {
       return button->Render();
+    }
   });
 
   // Let's renderer everyone:

examples/component/resizable_split.cpp

@@ -3,7 +3,6 @@
 // the LICENSE file.
 #include <memory>  // for shared_ptr, allocator, __shared_ptr_access
 
-#include "ftxui/component/captured_mouse.hpp"  // for ftxui
 #include "ftxui/component/component.hpp"  // for Renderer, ResizableSplitBottom, ResizableSplitLeft, ResizableSplitRight, ResizableSplitTop
 #include "ftxui/component/component_base.hpp"      // for ComponentBase
 #include "ftxui/component/screen_interactive.hpp"  // for ScreenInteractive
@@ -14,17 +13,24 @@ using namespace ftxui;
 int main() {
   auto screen = ScreenInteractive::Fullscreen();
 
-  auto middle = Renderer([] { return text("middle") | center; });
-  auto left = Renderer([] { return text("Left") | center; });
-  auto right = Renderer([] { return text("right") | center; });
-  auto top = Renderer([] { return text("top") | center; });
-  auto bottom = Renderer([] { return text("bottom") | center; });
-
+  // State:
   int left_size = 20;
   int right_size = 20;
   int top_size = 10;
   int bottom_size = 10;
 
+  // Renderers:
+  auto RendererInfo = [](const std::string& name, int* size) {
+    return Renderer([name, size] {
+      return text(name + ": " + std::to_string(*size)) | center;
+    });
+  };
+  auto middle = Renderer([] { return text("Middle") | center; });
+  auto left = RendererInfo("Left", &left_size);
+  auto right = RendererInfo("Right", &right_size);
+  auto top = RendererInfo("Top", &top_size);
+  auto bottom = RendererInfo("Bottom", &bottom_size);
+
   auto container = middle;
   container = ResizableSplitLeft(left, container, &left_size);
   container = ResizableSplitRight(right, container, &right_size);

examples/component/resizable_split_clamp.cpp

@@ -0,0 +1,43 @@
+// Copyright 2025 Arthur Sonzogni. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+#include <memory>  // for shared_ptr, allocator, __shared_ptr_access
+
+#include "ftxui/component/component.hpp"  // for Renderer, ResizableSplitBottom, ResizableSplitLeft, ResizableSplitRight, ResizableSplitTop
+#include "ftxui/component/component_base.hpp"      // for ComponentBase
+#include "ftxui/component/screen_interactive.hpp"  // for ScreenInteractive
+#include "ftxui/dom/elements.hpp"  // for Element, operator|, text, center, border
+
+using namespace ftxui;
+
+int main() {
+  auto screen = ScreenInteractive::Fullscreen();
+
+  // State:
+  int size = 40;
+  int size_min = 10;
+  int size_max = 80;
+
+  // Renderers:
+  auto split = ResizableSplit({
+      .main = Renderer([] { return text("Left") | center; }),
+      .back = Renderer([] { return text("Right") | center; }),
+      .direction = Direction::Left,
+      .main_size = &size,
+      .min = &size_min,
+      .max = &size_max,
+  });
+
+  auto renderer = Renderer(split, [&] {
+    return window(text("Drag the separator with the mouse"),
+                  vbox({
+                      text("Min:  " + std::to_string(size_min)),
+                      text("Max:  " + std::to_string(size_max)),
+                      text("Size: " + std::to_string(size)),
+                      separator(),
+                      split->Render() | flex,
+                  }));
+  });
+
+  screen.Loop(renderer);
+}

examples/component/scrollbar.cpp

@@ -3,6 +3,7 @@
 // the LICENSE file.
 #include <ftxui/component/component.hpp>
 #include <ftxui/component/screen_interactive.hpp>
+#include <string>
 
 using namespace ftxui;
 

examples/component/window.cpp

@@ -3,6 +3,7 @@
 // the LICENSE file.
 #include <ftxui/component/component.hpp>
 #include <ftxui/component/screen_interactive.hpp>
+#include <string>
 
 using namespace ftxui;
 

examples/dom/canvas.cpp

@@ -32,10 +32,12 @@ int main() {
 
   // Plot a function:
   std::vector<int> ys(100);
-  for (int x = 0; x < 100; x++)
+  for (int x = 0; x < 100; x++) {
     ys[x] = int(80 + 20 * cos(x * 0.2));
-  for (int x = 0; x < 99; x++)
+  }
+  for (int x = 0; x < 99; x++) {
     c.DrawPointLine(x, ys[x], x + 1, ys[x + 1], Color::Red);
+  }
 
   auto document = canvas(&c) | border;
 

examples/dom/package_manager.cpp

@@ -86,8 +86,9 @@ int main() {
 
   auto render = [&]() {
     std::vector<Element> entries;
-    for (auto& task : displayed_task)
+    for (auto& task : displayed_task) {
       entries.push_back(renderTask(task));
+    }
 
     return vbox({
         // List of tasks.
@@ -138,8 +139,9 @@ int main() {
     std::this_thread::sleep_for(0.01s);
 
     // Exit
-    if (nb_active + nb_queued == 0)
+    if (nb_active + nb_queued == 0) {
       break;
+    }
 
     // Update the model for the next frame.
     updateModel();

examples/dom/spinner.cpp

@@ -21,8 +21,9 @@ int main() {
   for (int index = 0; index < 200; ++index) {
     std::vector<Element> entries;
     for (int i = 0; i < 23; ++i) {
-      if (i != 0)
+      if (i != 0) {
         entries.push_back(separator());
+      }
       entries.push_back(  //
           hbox({
               text(std::to_string(i)) | size(WIDTH, EQUAL, 2),

examples/index.css

@@ -1,15 +1,19 @@
 @import url(https://fonts.googleapis.com/css?family=Khula:700);
 
+html {
+  --toc-width: 250px;
+}
+
 body {
-  background-color:#EEE;
-  padding:0px;
-  margin:0px;
+  background-color: #EEE;
+  padding: 0px;
+  margin: 0px;
   font-family: Khula, Helvetica, sans-serif;
   font-size: 130%;
 }
 
 .page {
-  max-width:1300px;
+  max-width: 1300px;
   margin: auto;
   padding: 10px;
 }
@@ -20,7 +24,7 @@ a {
   margin: 0 -.25rem;
   padding: 0 .25rem;
   transition: color .3s ease-in-out,
-              box-shadow .3s ease-in-out;
+    box-shadow .3s ease-in-out;
 }
 
 a:hover {
@@ -30,45 +34,48 @@ a:hover {
 
 h1 {
   text-decoration: underline;
-  width:100%;
-  background-color: rgba(100,100,255,0.5);
+  width: 100%;
+  background-color: rgba(100, 100, 255, 0.5);
   padding: 10px;
   margin: 0;
 }
 
 
 #selectExample {
-  flex:1;
+  flex: 1;
 }
 
-#selectExample, #selectExample option {
+#selectExample,
+#selectExample option {
   font-size: 16px;
   font-family: sans-serif;
   font-weight: 700;
   line-height: 1.3;
-  border:0px;
+  border: 0px;
   background-color: #bbb;
-  color:black;
+  color: black;
 }
 
 #selectExample:focus {
-  outline:none;
+  outline: none;
 }
 
 #terminal {
-  width:100%;
+  width: 100%;
   height 500px;
   height: calc(clamp(200px, 100vh - 300px, 900px));
   overflow: hidden;
-  border:none;
-  background-color:black;
+  border: none;
+  padding: 10px;
+  margin: 10px;
 }
 
 #terminalContainer {
   overflow: hidden;
   border-radius: 10px;
-  box-shadow: 0px 2px 10px 0px rgba(0,0,0,0.75),
-  0px 2px 80px 0px rgba(0,0,0,0.50);
+  box-shadow: 0px 2px 10px 0px rgba(0, 0, 0, 0.75),
+    0px 2px 80px 0px rgba(0, 0, 0, 0.50);
+  background-color: black;
 }
 
 .fakeButtons {
@@ -76,7 +83,7 @@ h1 {
   width: 10px;
   border-radius: 50%;
   border: 1px solid #000;
-  margin:6px;
+  margin: 6px;
   background-color: #ff3b47;
   border-color: #9d252b;
   display: inline-block;
@@ -95,13 +102,79 @@ h1 {
 }
 
 .fakeMenu {
-  display:flex;
+  display: flex;
   flex-direction: row;
-  width:100%;
+  width: 100%;
   box-sizing: border-box;
   height: 25px;
   background-color: #bbb;
-  color:black;
+  color: black;
   margin: 0 auto;
   overflow: hidden;
 }
+
+.toc-container {
+  position: fixed;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  width: var(--toc-width);
+  background: white;
+  padding: 0;
+  overflow-y: auto;
+  overflow-x: hidden;
+  scrollbar-width: thin;
+}
+
+.toc-title {
+  font-weight: bold;
+  margin-bottom: 5px;
+  font-size: 0.9em;
+  color: #555;
+
+  position: sticky;
+  transition: position 1.0s ease-in-out;
+  top: 0;
+  z-index: 1;
+  padding: 20px;
+  margin: 0;
+
+  border-bottom: 1px solid #ddd;
+
+  /* Gradient background for the title */
+  background-color: #f0f0f0;
+}
+
+.toc-item {
+  padding: 3px 8px;
+  margin: 0;
+  cursor: pointer;
+  font-size: 0.85em;
+  border-radius: 3px;
+  transition: background 0.2s;
+}
+
+.toc-item:hover {
+  background: #f0f0f0;
+}
+
+.toc-item.selected {
+  background: #e0e0e0;
+  font-weight: bold;
+}
+
+@media (max-width: 1024px) {
+  .toc-container {
+    display: none;
+  }
+
+  .page {
+    margin-left: 0;
+  }
+}
+
+@media (min-width: 1025px) {
+  .page {
+    margin-left: calc(var(--toc-width) + 20px);
+  }
+}

examples/index.html

@@ -9,13 +9,18 @@
     <script type="module" src="index.mjs"></script>
   </head>
   <body>
+    <div class="toc-container">
+      <div class="toc-list"></div>
+    </div>
     <script id="example_script"></script>
 
     <div class="page">
       <p>
         <a href="https://github.com/ArthurSonzogni/FTXUI">FTXUI</a> is a simple
         functional C++ library for terminal user interface. <br/>
-        This showcases the: <a href="https://github.com/ArthurSonzogni/FTXUI/tree/master/examples">./example/</a> folder. <br/>
+        This showcases the: <a
+          href="https://github.com/ArthurSonzogni/FTXUI/tree/master/examples">./example/</a>
+        folder. See <a id="source">source</a>.
       </p>
 
       <div id="terminalContainer">

examples/index.mjs

@@ -55,7 +55,7 @@ const stdout = code => {
 const stderr = code => {
   if (code == 0 || code == 10) {
     console.error(String.fromCodePoint(...stderr_buffer));
-    stderr_buffer = [];
+    stderr_buffer.length = 0;
   } else {
     stderr_buffer.push(code)
   }
@@ -89,12 +89,72 @@ window.Module = {
     const resize_observer = new ResizeObserver(resize_handler);
     resize_observer.observe(term_element);
     resize_handler();
-
-    // Disable scrollbar
-    //term.write('\x1b[?47h')
   },
 };
 
+const source = document.querySelector("#source");
+source.href = "https://github.com/ArthurSonzogni/FTXUI/blob/main/examples/" + example + ".cpp";
+
 const words = example.split('/')
 words[1] = "ftxui_example_" + words[1] + ".js"
 document.querySelector("#example_script").src = words.join('/');
+
+
+// Table of Contents (TOC) for quick navigation.
+
+// Get select element
+const selectEl = document.querySelector('select#selectExample');
+if (!selectEl) {
+  console.error('select#selectExample not found');
+} else {
+  // Get TOC container
+  const tocContainer = document.querySelector('.toc-container');
+  const tocList = tocContainer.querySelector('.toc-list');
+
+  // Group options by directory
+  const groupedOptions = Array.from(selectEl.options).reduce((acc, option) => {
+    const [dir, file] = option.text.split('/');
+    if (!acc[dir]) {
+      acc[dir] = [];
+    }
+    acc[dir].push({ option, file });
+    return acc;
+  }, {});
+
+  // Generate TOC items
+  for (const dir in groupedOptions) {
+    const dirContainer = document.createElement('div');
+
+    const dirHeader = document.createElement('div');
+    dirHeader.textContent = dir;
+    dirHeader.className = 'toc-title';
+    dirContainer.appendChild(dirHeader);
+
+    groupedOptions[dir].forEach(({ option, file }) => {
+      const tocItem = document.createElement('div');
+      tocItem.textContent = file;
+      tocItem.className = 'toc-item';
+
+      if (selectEl.options[selectEl.selectedIndex].value === option.value) {
+        tocItem.classList.add('selected');
+      }
+
+      // Click handler
+      tocItem.addEventListener('click', () => {
+        for(let i=0; i<selectEl.options.length; ++i) {
+          if (selectEl.options[i].value == option.value) {
+            selectEl.selectedIndex = i;
+            break;
+          }
+        }
+
+        history.pushState({}, "", "?file=" + option.value);
+        location.reload();
+      });
+
+      dirContainer.appendChild(tocItem);
+    });
+
+    tocList.appendChild(dirContainer);
+  }
+}''

flake.lock

@@ -5,11 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1694529238,
-        "narHash": "sha256-zsNZZGTGnMOf9YpHKJqMSsa0dXbfmxeoJ7xHlrt+xmY=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "ff7b65b44d01cf9ba6a71320833626af21126384",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1697915759,
-        "narHash": "sha256-WyMj5jGcecD+KC8gEs+wFth1J1wjisZf8kVZH13f1Zo=",
+        "lastModified": 1765644376,
+        "narHash": "sha256-yqHBL2wYGwjGL2GUF2w3tofWl8qO9tZEuI4wSqbCrtE=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "51d906d2341c9e866e48c2efcaac0f2d70bfd43e",
+        "rev": "23735a82a828372c4ef92c660864e82fbe2f5fbe",
         "type": "github"
       },
       "original": {

flake.nix

@@ -12,15 +12,9 @@
     let llvm = pkgs.llvmPackages_latest; in
     {
       packages = rec {
-        default = pkgs.stdenv.mkDerivation rec {
-          pname = "ftxui";
-          version = "v4.0.0";
-          src = pkgs.fetchFromGitHub {
-            owner = "ArthurSonzogni";
-            repo = "FTXUI";
-            rev = version;
-            sha256 = "sha256-3kAhHDUwzwdvHc8JZAcA14tGqa6w69qrN1JXhSxNBQY=";
-          };
+        default = pkgs.stdenv.mkDerivation {
+          name = "ftxui";
+          src = ./.;
 
           nativeBuildInputs = [
             pkgs.cmake

include/ftxui/component/animation.hpp

@@ -8,11 +8,21 @@
 #include <functional>  // for function
 
 namespace ftxui::animation {
-// Components who haven't completed their animation can call this function to
-// request a new frame to be drawn later.
-//
-// When there is no new events and no animations to complete, no new frame is
-// drawn.
+/// @brief RequestAnimationFrame is a function that requests a new frame to be
+/// drawn in the next animation cycle.
+///
+/// @note This function is typically called by components that need to
+/// update their state or appearance over time, such as animations or
+/// transitions. This is useful when the change doesn't depend depend on the
+/// events seen by the terminal, but rather on the passage of time.
+///
+/// Components who haven't completed their animation can call this function to
+/// request a new frame to be drawn later.
+///
+/// When there is no new events and no animations to complete, no new frame is
+/// drawn.
+///
+/// @ingroup component
 void RequestAnimationFrame();
 
 using Clock = std::chrono::steady_clock;

include/ftxui/component/captured_mouse.hpp

@@ -7,6 +7,7 @@
 #include <memory>
 
 namespace ftxui {
+
 class CapturedMouseInterface {
  public:
   CapturedMouseInterface() = default;

include/ftxui/component/component.hpp

@@ -8,6 +8,7 @@
 #include <memory>      // for make_shared, shared_ptr
 #include <utility>     // for forward
 
+#include <ftxui/util/warn_windows_macro.hpp>
 #include "ftxui/component/component_base.hpp"  // for Component, Components
 #include "ftxui/component/component_options.hpp"  // for ButtonOption, CheckboxOption, MenuOption
 #include "ftxui/dom/elements.hpp"  // for Element

include/ftxui/component/component_options.hpp

@@ -9,17 +9,18 @@
 #include <ftxui/dom/direction.hpp>  // for Direction, Direction::Left, Direction::Right, Direction::Down
 #include <ftxui/dom/elements.hpp>  // for Element, separator
 #include <ftxui/util/ref.hpp>      // for Ref, ConstRef, StringRef
-#include <functional>              // for function
-#include <string>                  // for string
+#include <ftxui/util/warn_windows_macro.hpp>
+#include <functional>  // for function
+#include <limits>      // for numeric_limits
+#include <string>      // for string
 
 #include "ftxui/component/component_base.hpp"  // for Component
 #include "ftxui/screen/color.hpp"  // for Color, Color::GrayDark, Color::White
 
 namespace ftxui {
 
-/// @brief arguments for |ButtonOption::transform|, |CheckboxOption::transform|,
-/// |Radiobox::transform|, |MenuEntryOption::transform|,
-/// |MenuOption::transform|.
+/// @brief arguments for transform from |ButtonOption|, |CheckboxOption|,
+/// |RadioboxOption|, |MenuEntryOption|, |MenuOption|.
 struct EntryState {
   std::string label;  ///< The label to display.
   bool state;         ///< The state of the button/checkbox/radiobox
@@ -28,6 +29,8 @@ struct EntryState {
   int index;          ///< Index of the entry when applicable or -1.
 };
 
+/// @brief Option for the underline effect.
+/// @ingroup component
 struct UnderlineOption {
   bool enabled = false;
 
@@ -215,6 +218,10 @@ struct ResizableSplitOption {
       (direction() == Direction::Left || direction() == Direction::Right) ? 20
                                                                           : 10;
   std::function<Element()> separator_func = [] { return ::ftxui::separator(); };
+
+  // Constraints on main_size:
+  Ref<int> min = 0;
+  Ref<int> max = std::numeric_limits<int>::max();
 };
 
 // @brief Option for the `Slider` component.
@@ -231,7 +238,8 @@ struct SliderOption {
   std::function<void()> on_change;  ///> Called when `value` is updated.
 };
 
-// Parameter pack used by `WindowOptions::render`.
+/// @brief State passed to the `Window` component's render function.
+/// @ingroup component
 struct WindowRenderState {
   Element inner;             ///< The element wrapped inside this window.
   const std::string& title;  ///< The title of the window.

include/ftxui/component/event.hpp

@@ -6,6 +6,7 @@
 
 #include <ftxui/component/mouse.hpp>  // for Mouse
 #include <string>                     // for string, operator==
+#include <string_view>
 
 namespace ftxui {
 
@@ -24,15 +25,17 @@ class ComponentBase;
 ///
 /// Useful documentation about xterm specification:
 /// https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+///
+/// @ingroup component
 struct Event {
   // --- Constructor section ---------------------------------------------------
-  static Event Character(std::string);
+  static Event Character(std::string_view);
   static Event Character(char);
   static Event Character(wchar_t);
-  static Event Special(std::string);
-  static Event Mouse(std::string, Mouse mouse);
-  static Event CursorPosition(std::string, int x, int y);  // Internal
-  static Event CursorShape(std::string, int shape);        // Internal
+  static Event Special(std::string_view);
+  static Event Mouse(std::string_view, Mouse mouse);
+  static Event CursorPosition(std::string_view, int x, int y);  // Internal
+  static Event CursorShape(std::string_view, int shape);        // Internal
 
   // --- Arrow ---
   static const Event ArrowLeft;

include/ftxui/component/loop.hpp

@@ -14,6 +14,45 @@ class ComponentBase;
 using Component = std::shared_ptr<ComponentBase>;
 class ScreenInteractive;
 
+/// @brief Loop is a class that manages the event loop for a component.
+///
+/// It is responsible for running the component, handling events, and
+/// updating the screen.
+///
+/// The Loop class is designed to be used with a ScreenInteractive object,
+/// which represents the terminal screen.
+///
+/// **Example**
+/// ```cpp
+/// #include <ftxui/component/component.hpp>
+/// #include <ftxui/component/screen_interactive.hpp>
+/// #include <ftxui/component/loop.hpp>
+///
+/// int main() {
+///  auto screen = ftxui::ScreenInteractive::TerminalOutput();
+///  auto component = ftxui::Button("Click me", [] { ... });
+///
+///  ftxui::Loop loop(screen.get(), component);
+///
+///  // Either
+///  loop.Run();  // Blocking until the component quits.
+///
+///  // Or
+///  loop.RunOnce();  // Non-blocking, returns immediately.
+///
+///  // Or
+///  loop.RunOnceBlocking();  // Blocking until handling one event.
+///
+///  // Or in a loop:
+///  while (!loop.HasQuitted()) {
+///    loop.RunOnce();
+///
+///    // Do something else like running a different library loop function.
+///  }
+/// }
+/// ```
+///
+/// @ingroup component
 class Loop {
  public:
   Loop(ScreenInteractive* screen, Component component);

include/ftxui/component/receiver.hpp

@@ -7,13 +7,16 @@
 #include <algorithm>           // for copy, max
 #include <atomic>              // for atomic, __atomic_base
 #include <condition_variable>  // for condition_variable
-#include <memory>              // for unique_ptr, make_unique
-#include <mutex>               // for mutex, unique_lock
-#include <queue>               // for queue
-#include <utility>             // for move
+#include <ftxui/util/warn_windows_macro.hpp>
+#include <memory>   // for unique_ptr, make_unique
+#include <mutex>    // for mutex, unique_lock
+#include <queue>    // for queue
+#include <utility>  // for move
 
 namespace ftxui {
 
+// Deprecated
+//
 // Usage:
 //
 // Initialization:
@@ -39,17 +42,24 @@ namespace ftxui {
 // Receiver::Receive() returns true when there are no more senders.
 
 // clang-format off
+// Deprecated:
 template<class T> class SenderImpl;
+// Deprecated:
 template<class T> class ReceiverImpl;
+// Deprecated:
 
+// Deprecated:
 template<class T> using Sender = std::unique_ptr<SenderImpl<T>>;
+// Deprecated:
 template<class T> using Receiver = std::unique_ptr<ReceiverImpl<T>>;
+// Deprecated:
 template<class T> Receiver<T> MakeReceiver();
 // clang-format on
 
 // ---- Implementation part ----
 
 template <class T>
+// Deprecated:
 class SenderImpl {
  public:
   SenderImpl(const SenderImpl&) = delete;

include/ftxui/component/screen_interactive.hpp

@@ -4,13 +4,10 @@
 #ifndef FTXUI_COMPONENT_SCREEN_INTERACTIVE_HPP
 #define FTXUI_COMPONENT_SCREEN_INTERACTIVE_HPP
 
-#include <atomic>                        // for atomic
-#include <ftxui/component/receiver.hpp>  // for Receiver, Sender
-#include <functional>                    // for function
-#include <memory>                        // for shared_ptr
-#include <string>                        // for string
-#include <thread>                        // for thread
-#include <variant>                       // for variant
+#include <atomic>      // for atomic
+#include <functional>  // for function
+#include <memory>      // for shared_ptr
+#include <string>      // for string
 
 #include "ftxui/component/animation.hpp"       // for TimePoint
 #include "ftxui/component/captured_mouse.hpp"  // for CapturedMouse
@@ -27,6 +24,14 @@ struct Event;
 using Component = std::shared_ptr<ComponentBase>;
 class ScreenInteractivePrivate;
 
+namespace task {
+class TaskRunner;
+}
+
+/// @brief ScreenInteractive is a `Screen` that can handle events, run a main
+/// loop, and manage components.
+///
+/// @ingroup component
 class ScreenInteractive : public Screen {
  public:
   // Constructors:
@@ -37,8 +42,12 @@ class ScreenInteractive : public Screen {
   static ScreenInteractive FitComponent();
   static ScreenInteractive TerminalOutput();
 
+  // Destructor.
+  ~ScreenInteractive() override;
+
   // Options. Must be called before Loop().
   void TrackMouse(bool enable = true);
+  void HandlePipedInput(bool enable = true);
 
   // Return the currently active screen, nullptr if none.
   static ScreenInteractive* Active();
@@ -92,8 +101,14 @@ class ScreenInteractive : public Screen {
   void Draw(Component component);
   void ResetCursorPosition();
 
+  void InstallPipedInputHandling();
+
   void Signal(int signal);
 
+  void FetchTerminalEvents();
+
+  void PostAnimationTask();
+
   ScreenInteractive* suspended_screen_ = nullptr;
   enum class Dimension {
     FitComponent,
@@ -101,30 +116,27 @@ class ScreenInteractive : public Screen {
     Fullscreen,
     TerminalOutput,
   };
-  Dimension dimension_ = Dimension::Fixed;
-  bool use_alternative_screen_ = false;
-  ScreenInteractive(int dimx,
+  ScreenInteractive(Dimension dimension,
+                    int dimx,
                     int dimy,
-                    Dimension dimension,
                     bool use_alternative_screen);
 
-  bool track_mouse_ = true;
+  const Dimension dimension_;
+  const bool use_alternative_screen_;
 
-  Sender<Task> task_sender_;
-  Receiver<Task> task_receiver_;
+  bool track_mouse_ = true;
 
   std::string set_cursor_position;
   std::string reset_cursor_position;
 
   std::atomic<bool> quit_{false};
-  std::thread event_listener_;
-  std::thread animation_listener_;
   bool animation_requested_ = false;
   animation::TimePoint previous_animation_time_;
 
   int cursor_x_ = 1;
   int cursor_y_ = 1;
 
+  std::uint64_t frame_count_ = 0;
   bool mouse_captured = false;
   bool previous_frame_resized_ = false;
 
@@ -133,6 +145,11 @@ class ScreenInteractive : public Screen {
   bool force_handle_ctrl_c_ = true;
   bool force_handle_ctrl_z_ = true;
 
+  // Piped input handling state (POSIX only)
+  bool handle_piped_input_ = true;
+  // File descriptor for /dev/tty, used for piped input handling.
+  int tty_fd_ = -1;
+
   // The style of the cursor to restore on exit.
   int cursor_reset_shape_ = 1;
 
@@ -152,8 +169,14 @@ class ScreenInteractive : public Screen {
   std::unique_ptr<Selection> selection_;
   std::function<void()> selection_on_change_;
 
+  // PIMPL private implementation idiom (Pimpl).
+  struct Internal;
+  std::unique_ptr<Internal> internal_;
+
   friend class Loop;
 
+  Component component_;
+
  public:
   class Private {
    public:

include/ftxui/dom/canvas.hpp

@@ -20,6 +20,21 @@
 
 namespace ftxui {
 
+/// @brief Canvas is a drawable buffer associated with drawing operations.
+///
+/// Canvas is a drawable area that can be used to create complex graphics. It
+/// supports drawing points, lines, circles, ellipses, text, and images using
+/// braille, block, or normal characters.
+///
+/// Note: A terminal contains cells. A cells is a unit of:
+/// - 2x4 braille characters (1x1 pixel)
+/// - 2x2 block characters (2x2 pixels)
+/// - 2x4 normal characters (2x4 pixels)
+///
+/// You need to multiply the x coordinate by 2 and the y coordinate by 4 to
+/// get the correct position in the terminal.
+///
+/// @ingroup dom
 struct Canvas {
  public:
   Canvas() = default;
@@ -91,9 +106,9 @@ struct Canvas {
   // Draw using character of size 2x4 at position (x,y)
   // x is considered to be a multiple of 2.
   // y is considered to be a multiple of 4.
-  void DrawText(int x, int y, const std::string& value);
-  void DrawText(int x, int y, const std::string& value, const Color& color);
-  void DrawText(int x, int y, const std::string& value, const Stylizer& style);
+  void DrawText(int x, int y, std::string_view value);
+  void DrawText(int x, int y, std::string_view value, const Color& color);
+  void DrawText(int x, int y, std::string_view value, const Stylizer& style);
 
   // Draw using directly pixels or images --------------------------------------
   // x is considered to be a multiple of 2.

include/ftxui/dom/direction.hpp

@@ -5,6 +5,11 @@
 #define FTXUI_DOM_DIRECTION_HPP
 
 namespace ftxui {
+
+/// @brief Direction is an enumeration that represents the four cardinal
+/// directions.
+///
+/// @ingroup dom
 enum class Direction {
   Up = 0,
   Down = 1,

include/ftxui/dom/elements.hpp

@@ -7,6 +7,7 @@
 #include <functional>
 #include <memory>
 
+#include <string_view>
 #include "ftxui/dom/canvas.hpp"
 #include "ftxui/dom/direction.hpp"
 #include "ftxui/dom/flexbox_config.hpp"
@@ -24,6 +25,14 @@ using Elements = std::vector<Element>;
 using Decorator = std::function<Element(Element)>;
 using GraphFunction = std::function<std::vector<int>(int, int)>;
 
+/// @brief BorderStyle is an enumeration that represents the different styles
+/// of borders that can be applied to elements in the terminal UI.
+///
+/// BorderStyle is an enumeration that represents the different styles of
+/// borders that can be applied to elements in the terminal UI.
+/// It is used to define the visual appearance of borders around elements,
+/// such as windows, frames, or separators.
+/// @ingroup dom
 enum BorderStyle {
   LIGHT,
   DASHED,
@@ -43,8 +52,8 @@ Elements operator|(Elements, Decorator);
 Decorator operator|(Decorator, Decorator);
 
 // --- Widget ---
-Element text(std::string text);
-Element vtext(std::string text);
+Element text(std::string_view text);
+Element vtext(std::string_view text);
 Element separator();
 Element separatorLight();
 Element separatorDashed();
@@ -53,7 +62,7 @@ Element separatorDouble();
 Element separatorEmpty();
 Element separatorStyled(BorderStyle);
 Element separator(Pixel);
-Element separatorCharacter(std::string);
+Element separatorCharacter(std::string_view);
 Element separatorHSelector(float left,
                            float right,
                            Color unselected_color,
@@ -81,11 +90,11 @@ Decorator borderStyled(Color);
 Decorator borderWith(const Pixel&);
 Element window(Element title, Element content, BorderStyle border = ROUNDED);
 Element spinner(int charset_index, size_t image_index);
-Element paragraph(const std::string& text);
-Element paragraphAlignLeft(const std::string& text);
-Element paragraphAlignRight(const std::string& text);
-Element paragraphAlignCenter(const std::string& text);
-Element paragraphAlignJustify(const std::string& text);
+Element paragraph(std::string_view text);
+Element paragraphAlignLeft(std::string_view text);
+Element paragraphAlignRight(std::string_view text);
+Element paragraphAlignCenter(std::string_view text);
+Element paragraphAlignJustify(std::string_view text);
 Element graph(GraphFunction);
 Element emptyElement();
 Element canvas(ConstRef<Canvas>);
@@ -112,8 +121,8 @@ Element bgcolor(const LinearGradient&, Element);
 Decorator focusPosition(int x, int y);
 Decorator focusPositionRelative(float x, float y);
 Element automerge(Element child);
-Decorator hyperlink(std::string link);
-Element hyperlink(std::string link, Element child);
+Decorator hyperlink(std::string_view link);
+Element hyperlink(std::string_view link, Element child);
 Element selectionStyleReset(Element);
 Decorator selectionColor(Color foreground);
 Decorator selectionBackgroundColor(Color foreground);

include/ftxui/dom/flexbox_config.hpp

@@ -12,6 +12,18 @@
 
 namespace ftxui {
 
+/// @brief FlexboxConfig is a configuration structure that defines the layout
+/// properties for a flexbox container.
+//
+/// It allows you to specify the direction of the flex items, whether they
+/// should wrap, how they should be justified along the main axis, and how
+/// they should be aligned along the cross axis.
+/// It also includes properties for gaps between flex items in both the
+/// main and cross axes.
+/// This structure is used to configure the layout behavior of flexbox
+/// containers in a terminal user interface.
+///
+/// @ingroup dom
 struct FlexboxConfig {
   /// This establishes the main-axis, thus defining the direction flex items are
   /// placed in the flex container. Flexbox is (aside wrapping) single-direction

include/ftxui/dom/linear_gradient.hpp

@@ -27,8 +27,15 @@ namespace ftxui {
 /// LinearGradient(Color::Red, Color::Blue);
 /// LinearGradient(45, Color::Red, Color::Blue);
 /// ```
+///
+/// @ingroup dom
 struct LinearGradient {
   float angle = 0.f;
+
+  /// A stop is a color at a specific position in the gradient.
+  /// The position is a value between 0.0 and 1.0,
+  /// where 0.0 is the start of the gradient
+  /// and 1.0 is the end of the gradient.
   struct Stop {
     Color color = Color::Default;
     std::optional<float> position;

include/ftxui/dom/node.hpp

@@ -20,6 +20,20 @@ class Screen;
 using Element = std::shared_ptr<Node>;
 using Elements = std::vector<Element>;
 
+/// @brief Node is the base class for all elements in the DOM tree.
+///
+/// It represents a single node in the document object model (DOM) and provides
+/// the basic structure for layout and rendering.
+/// It contains methods for computing layout requirements, setting the box
+/// dimensions, selecting content, rendering to the screen, and checking the
+/// layout status.
+/// It typically contains child elements, which are also instances of Node.
+///
+/// Users are expected to derive from this class to create custom elements.
+///
+/// A list of builtin elements can be found in the `elements.hpp` file.
+///
+/// @ingroup dom
 class Node {
  public:
   Node();

include/ftxui/dom/requirement.hpp

@@ -10,6 +10,11 @@
 namespace ftxui {
 class Node;
 
+/// @brief Requirement is a structure that defines the layout requirements for a
+/// Node in the terminal user interface.
+///
+/// It specifies the minimum size required to fully draw the element,
+/// @ingroup dom
 struct Requirement {
   // The required size to fully draw the element.
   int min_x = 0;

include/ftxui/dom/selection.hpp

@@ -13,7 +13,12 @@
 
 namespace ftxui {
 
-/// @brief Represent a selection in the terminal.
+/// @brief Represents a selection in a terminal user interface.
+///
+/// Selection is a class that represents the two endpoints of a selection in a
+/// terminal user interface.
+///
+/// @ingroup dom
 class Selection {
  public:
   Selection();  // Empty selection.
@@ -25,7 +30,7 @@ class Selection {
   Selection SaturateVertical(Box box);
   bool IsEmpty() const { return empty_; }
 
-  void AddPart(const std::string& part, int y, int left, int right);
+  void AddPart(std::string_view part, int y, int left, int right);
   std::string GetParts() { return parts_.str(); }
 
  private:

include/ftxui/dom/table.hpp

@@ -11,28 +11,28 @@
 
 namespace ftxui {
 
-// Usage:
-//
-// Initialization:
-// ---------------
-//
-// auto table = Table({
-//   {"X", "Y"},
-//   {"-1", "1"},
-//   {"+0", "0"},
-//   {"+1", "1"},
-// });
-//
-// table.SelectAll().Border(LIGHT);
-//
-// table.SelectRow(1).Border(DOUBLE);
-// table.SelectRow(1).SeparatorInternal(Light);
-//
-// std::move(table).Element();
-
 class Table;
 class TableSelection;
 
+/// @brief Table is a utility to draw tables.
+///
+/// **example**
+/// ```cpp
+/// auto table = Table({
+///  {"X", "Y"},
+///  {"-1", "1"},
+///  {"+0", "0"},
+///  {"+1", "1"},
+/// });
+///
+/// table.SelectAll().Border(LIGHT);
+/// table.SelectRow(1).Border(DOUBLE);
+/// table.SelectRow(1).SeparatorInternal(LIGHT);
+///
+/// std::move(table).Render();
+/// ```
+///
+/// @ingroup dom
 class Table {
  public:
   Table();

include/ftxui/dom/take_any_args.hpp

@@ -5,25 +5,18 @@
 #define FTXUI_DOM_TAKE_ANY_ARGS_HPP
 
 // IWYU pragma: private, include "ftxui/dom/elements.hpp"
+#include <deque>
 #include <ftxui/dom/node.hpp>
+#include <queue>
+#include <stack>
+#include <vector>
 
 namespace ftxui {
 
-template <class T>
-void Merge(Elements& /*container*/, T /*element*/) {}
-
-template <>
 inline void Merge(Elements& container, Element element) {
   container.push_back(std::move(element));
 }
 
-template <>
-inline void Merge(Elements& container, Elements elements) {
-  for (auto& element : elements) {
-    container.push_back(std::move(element));
-  }
-}
-
 // Turn a set of arguments into a vector.
 template <class... Args>
 Elements unpack(Args... args) {
@@ -32,11 +25,50 @@ Elements unpack(Args... args) {
   return vec;
 }
 
-// Make |container| able to take any number of argments.
+// Make |container| able to take any number of arguments.
 #define TAKE_ANY_ARGS(container)                               \
+  inline Element container(Element child) {                    \
+    return container(unpack(std::move(child)));                \
+  }                                                            \
+                                                               \
   template <class... Args>                                     \
-  Element container(Args... children) {                        \
+  inline Element container(Args... children) {                 \
     return container(unpack(std::forward<Args>(children)...)); \
+  }                                                            \
+                                                               \
+  template <class Container>                                   \
+  inline Element container(Container&& children) {             \
+    Elements elements;                                         \
+    for (auto& child : children) {                             \
+      elements.push_back(std::move(child));                    \
+    }                                                          \
+    return container(std::move(elements));                     \
+  }                                                            \
+  template <>                                                  \
+  inline Element container(std::stack<Element>&& children) {   \
+    Elements elements;                                         \
+    while (!children.empty()) {                                \
+      elements.push_back(std::move(children.top()));           \
+      children.pop();                                          \
+    }                                                          \
+    return container(std::move(elements));                     \
+  }                                                            \
+  template <>                                                  \
+  inline Element container(std::queue<Element>&& children) {   \
+    Elements elements;                                         \
+    while (!children.empty()) {                                \
+      elements.push_back(std::move(children.front()));         \
+      children.pop();                                          \
+    }                                                          \
+    return container(std::move(elements));                     \
+  }                                                            \
+  template <>                                                  \
+  inline Element container(std::deque<Element>&& children) {   \
+    Elements elements;                                         \
+    for (auto& child : children) {                             \
+      elements.push_back(std::move(child));                    \
+    }                                                          \
+    return container(std::move(elements));                     \
   }
 
 TAKE_ANY_ARGS(vbox)

include/ftxui/screen/box.hpp

@@ -6,6 +6,13 @@
 
 namespace ftxui {
 
+/// @brief Box is a structure that represents a rectangular area in a 2D space.
+///
+/// It is defined by its minimum and maximum coordinates along the x and y axes.
+/// Note that the coordinates are inclusive, meaning that the box includes both
+/// the minimum and maximum values.
+///
+/// @ingroup screen
 struct Box {
   int x_min = 0;
   int x_max = 0;