Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/Rikitav/Terminality/llms.txt

Use this file to discover all available pages before exploring further.

Terminality is distributed as source. You clone the repository, build a static library with CMake, and then link that library into your own project. This page covers every step: prerequisites, building Terminality itself, and wiring it into your CMake project.

​
Prerequisites

Before you build, make sure you have:
  • C++23-capable compiler — MSVC (latest) or GCC (latest). Terminality relies on C++23 named modules; older compiler versions are not supported.
  • CMake 4.0 or newer — the root CMakeLists.txt declares cmake_minimum_required(VERSION 4.0).
  • Git — to clone the repository.
C++23 module support varies across toolchains. MSVC in Visual Studio 2022 (17.4+) and GCC 14+ have the most complete implementations. Clang module support for C++23 is still maturing and is not officially tested.

​
Build Terminality

1

Clone the repository

git clone https://github.com/Rikitav/Terminality.git
cd Terminality
2

Configure with CMake

Create a build directory and run CMake from inside it:
mkdir build && cd build
cmake ..
CMake sets CMAKE_CXX_STANDARD 23, enables module scanning with CMAKE_CXX_SCAN_FOR_MODULES ON, and automatically selects the platform-specific backend — HostApplication.Windows.cpp on Windows, HostApplication.Linux.cpp on Linux.
3

Build the library

cmake --build .
This produces terminality as a static library (libterminality.a on Linux, terminality.lib on Windows) along with the Terminality.TespApp test executable.

​
Integrate into your own project

Once the library is built, there are two ways to integrate it: consume the build tree directly via add_subdirectory, or point to the already-built artifacts manually. If your project and Terminality share a repository or are co-located, add Terminality as a subdirectory in your CMakeLists.txt: 
cmake_minimum_required(VERSION 4.0)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_SCAN_FOR_MODULES ON)

project(MyApp LANGUAGES CXX)

add_subdirectory(Terminality)

add_executable(MyApp main.cpp)
target_link_libraries(MyApp PRIVATE terminality)
The terminality target already exposes its include directories and module sources as PUBLIC file sets, so target_link_libraries is all you need. If you built Terminality separately, point CMake to the include path and the library file: 
cmake_minimum_required(VERSION 4.0)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_SCAN_FOR_MODULES ON)

project(MyApp LANGUAGES CXX)

add_executable(MyApp main.cpp)

target_include_directories(MyApp PRIVATE /path/to/Terminality/Terminality/include)
target_link_libraries(MyApp PRIVATE /path/to/Terminality/build/libterminality.a)
You must set CMAKE_CXX_SCAN_FOR_MODULES ON in your own project’s CMakeLists.txt. Without it, CMake will not scan .ixx files for module dependencies and the build will fail to find the terminality module.

​
C++23 modules requirement

Terminality exposes no traditional headers. Every public type is exported from the terminality named module. Your source files must use: 
import terminality;
Do not mix #include with import for the same translation unit containing Terminality types. The module boundary is intentional — it enforces clean separation between the framework and your application code.

​
Platform notes

Build with MSVC via the Visual Studio 2022 generator or the cl command line. The Windows backend (HostApplication.Windows.cpp) is selected automatically by CMake when WIN32 is defined.
cmake .. -G "Visual Studio 17 2022"
cmake --build . --config Release

​
Verify the build

Run the bundled test application to confirm everything is working: 
./Terminality.TespApp
You should see a multi-pane terminal UI with a chat history area, a text input row, and a status bar with a progress indicator. Press Escape to exit.

​
Next steps

Get started with Terminality

Build your first app with a complete code walkthrough.

What is Terminality?

Understand the architecture, module system, and extension points.

Build docs developers (and LLMs) love

Get started for freeTalk to us