Frame Toolbox

A collection of small utilities for Steam Frame, built with C++20 and Qt Quick.

The initial application is a desktop window with a working Device Info tool showing the operating system, CPU architecture, and kernel version. It runs locally on the headset. VR overlays, background services, and settings-changing tools are future work.

Build and run

Requirements: a C++20 compiler, CMake 3.21+, Ninja, and Qt 6.5+ development packages for Quick and Quick Controls 2, including their QML runtime modules. Use ARM64 dependencies for a native build on Steam Frame.

cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug
cmake --build build --parallel 2
./build/src/app/frametoolbox

Launch from the headset's desktop session to check the actual interface. A remote shell may not have the same graphics environment.

Optional installation into your user directory:

cmake --install build --prefix "$HOME/.local"

This installs the executable; it does not bundle Qt. A distributable release will need an ARM64 runtime/dependency packaging strategy and testing through Steam. For Devkit uploads, Valve documents the Steam Linux Runtime 3.0 ARM64 (Sniper) target: loading builds.

Architecture

Dependencies point toward the core. The executable assembles the concrete implementations; tool logic does not depend on the interface or Qt.

src/
  core/       Plain C++ data types and system-facing interfaces
  tools/      Individual tool behavior, depending only on core
  platform/   Implementations of core interfaces using OS/framework APIs
  app/        Startup wiring, Qt presentation models, and QML views

Each layer has its own CMake target. frame_core is currently header-only. frame_tools and frame_platform depend on frame_core; frametoolbox links them together and owns their lifetimes.

Device Info demonstrates the flow: SystemInfoProvider defines the contract, QtSystemInfoProvider reads the system, DeviceInfo requests a snapshot, and DeviceInfoModel exposes it to QML. System information is read once at startup.

Adding a tool

1. Add its behavior under src/tools, using plain C++.
2. Add core interfaces and platform implementations if it needs new system access.
3. Add a presentation model and QML view under src/app.
4. Wire its dependencies in main.cpp and register sources in CMake.
5. Test meaningful behavior with fake core interfaces, and verify platform integration on the headset in the intended desktop or VR session.

Keep modules bundled until a real need for external plugins emerges. Add shared services when tools actually require them, rather than introducing an unused plugin loader, service process, or settings framework.

Development principles

• Keep disabled tools idle; prefer events over continuous polling.
• Check capabilities before offering a system action.
• For future tweaks, preserve prior settings and provide a restore path.
• Keep app data and development dependencies in the user's writable directories.
• Preserve the existing KWin cursor workaround when adding desktop tools.
• Verify text readability, controller navigation, and frame timing on hardware.

This scaffold has no automated behavior tests yet. Building and starting it with Qt's offscreen platform can catch startup and QML errors, but cannot validate graphics or input in the headset.