Guillaume is a C++20 UI framework for modern desktop and extended reality (XR) applications. It provides the application shell, an ECS-based UI composition model, scene management, event dispatching, and storage helpers.
Key Concepts
- Application — owns the engine, scene manager, event bus, and system registry; drives the main loop (see the frame lifecycle).
- ECS — entities, components, and systems compose the UI. Systems run in ordered phases (Event, Measure, Layout, Render) and traverse the entity hierarchy.
- Scenes — self-contained UI states with their own entity/component registries; the scene manager handles transitions.
- Events — an EventBus routes typed events to subscribed listeners and systems.
- Storage — LocalStorage (SQLite-backed, persistent) and SessionStorage (in-memory) key-value helpers. If the storage file cannot be opened, LocalStorage keeps working in memory and isPersistent() returns false.
- Theme & metadata — component metadata and theming support.
Quickstart
A minimal application requires a utility::Engine implementation and at least one Scene type:
#include <utility/engine.hpp>
#include <guillaume/application.hpp>
#include <guillaume/scene.hpp>
class MyEngine : public utility::Engine {
};
};
int main() {
auto resources = std::make_shared<utility::RessourceProvider>(...);
std::make_unique<MyEngine>());
return app.run();
}
The entry point of a program: owns the engine, the scenes and the systems, and runs the frame loop.
One screen of the application: it owns the entities shown and the components that hold their state.
See the Getting Started tutorial and the examples directory for a complete walkthrough.
Building
Dependencies
- CMake 3.10+
- A C++20 compiler
- Doxygen + Graphviz (only for -DBUILD_DOCS=ON)
SQLite3, GoogleTest, Google Benchmark and the Doxygen theme are vendored under third_party/. The sibling utility library is fetched with CMake FetchContent, so the first configure needs network access.
Configure and build
cmake -S . -B build -DBUILD_TESTING=ON
cmake --build build
ctest --test-dir build --output-on-failure
Optional options:
- -DBUILD_TESTING=ON — build and run the test suite.
- -DBUILD_DOCS=ON — build Doxygen documentation.
- -DBUILD_BENCHMARKS=ON — build the benchmark harness.
Consuming as a dependency
The supported way today is to build Guillaume as part of your project:
include(FetchContent)
FetchContent_Declare(guillaume
GIT_REPOSITORY https://github.com/etib-corp/guillaume.git
GIT_TAG v2026.3.1
)
FetchContent_MakeAvailable(guillaume)
target_link_libraries(my_app PRIVATE guillaume)
Guillaume loads its bundled fonts as fonts/Roboto-Regular.ttf and fonts/Roboto-Medium.ttf through the utility::RessourceProvider you pass to Application, so the resource root must contain the repository's fonts/ directory (installed to share/guillaume/fonts).
cmake --install also writes a guillaumeConfig.cmake, but find_package(guillaume) does not work yet: the installed utility package asks for a glm package that is not installed alongside it. tests/package_consumer/ is a minimal project that reproduces this and will pass once it is fixed in utility.
API Overview
The public API lives under headers/guillaume/. Doxygen documentation is published to GitHub Pages.
Documentation
Contributing
We welcome contributions! See the Contributing Guidelines for how to get involved.
License
Guillaume is released under the [MIT License](LICENSE). See CODE_OF_CONDUCT.md for our community standards and SECURITY.md for reporting vulnerabilities.