Skip to content

Ship a Windows release

A release of a Windows game is a folder: the program, the DLLs it loads, its content and the notices of what it carries. A player unzips it anywhere and runs the program. The folder the build makes while you work is not that folder, because it also holds debug symbols, test programs and CMake’s own files, and a debug build’s runtime may not be given away. The project from the starter project or Start your own project has install rules that make the release folder for you, so you do not pick the files out of the build tree by hand.

Send your game to a friend is this page as steps: every command with its output and time, a ZIP, what the player sees when they download and start it, SmartScreen’s warning included, and the second program below with the whole presets file.

This is every file the install puts in the release folder of the Get Started project, and nothing else:

FileWhat it is
MyGame.exeThe game, with the engine, rapidjson and DirectXMath compiled into it.
DirectXTK.dllDirectX Tool Kit, which the engine's audio and gamepad code call.
xaudio2_9redist.dllThe XAudio2 redistributable, which DirectXTK.dll loads.
vcruntime140.dllThe MSVC runtime, which the game and DirectXTK.dll load.
vcruntime140_1.dllThe MSVC runtime's exception handling, which the game and DirectXTK.dll load.
msvcp140.dllThe C++ standard library's DLL, which the game and DirectXTK.dll load.
msvcp140_1.dllMore of the C++ standard library, on CMake's list of the MSVC runtime; a game can start to load it as it grows.
msvcp140_2.dllMore of the C++ standard library, on CMake's list of the MSVC runtime.
msvcp140_atomic_wait.dllMore of the C++ standard library, on CMake's list of the MSVC runtime.
msvcp140_codecvt_ids.dllMore of the C++ standard library, on CMake's list of the MSVC runtime.
concrt140.dllThe Concurrency Runtime, on CMake's list of the MSVC runtime.
manifest.jsonThe content manifest, which names everything the game loads.
fonts/jetbrains_mono_bold_16.spritefontThe template's font atlas.
fonts/OFL.txtThe font's licence, the SIL Open Font License, which must travel with it.
notices/Labrador.txtLabrador's licence, MIT.
notices/Labrador-NOTICE.txtLabrador's NOTICE: the code in the engine that is not Labrador's to license, Microsoft's sample code and Ericson's collision routines.
notices/rapidjson.txtrapidjson's licence, MIT.
notices/DirectXTK.txtDirectX Tool Kit's licence, MIT.
notices/DirectXMath.txtDirectXMath's licence, MIT.
notices/XAudio2Redist.txtThe XAudio2 redistributable's licence terms, Microsoft's.

CI’s consumer job installs the project on every pull request to Labrador and checks the folder against this list, so the list is what the install rules actually make. Your game’s list grows as its content does.

In the x64 Native Tools Command Prompt, from your project’s folder:

Terminal window
cmake --preset x64-release
cmake --build --preset x64-release
ctest --preset x64-release
if exist C:\dev\mygame-release rmdir /s /q C:\dev\mygame-release
cmake --install out\build\x64-release --prefix C:\dev\mygame-release

On a fast desktop the first configure, build and tests took 17 seconds, and the install under a second, printing 21 -- Installing: lines: one for each of the 20 files and one for the fonts folder. --prefix is the folder to fill. Install into an empty folder: the install adds and replaces files, but it never deletes one, so a file left from an earlier release would stay. The rmdir line empties it first, without asking, so check its path. Then check that the folder starts on its own, from anywhere:

Terminal window
start /wait /b "" C:\dev\mygame-release\MyGame.exe --smoke-test 2> "%TEMP%\startup.txt"
echo %errorlevel%

start /wait makes the prompt wait for the game to quit, which it does not do for a windowed program otherwise. 0 means the game opened its window hidden, drew its first frames and quit; 1 means it stopped at start-up. The game writes why to standard error, and shows no message box under --smoke-test, and a windowed program has no console of its own, so 2> "%TEMP%\startup.txt" puts the reason in a file you can read, in Windows’ folder for temporary files rather than the project’s, where Git would record it. /b is what hands the game that redirect: without it, start gives the game no standard error and startup.txt stays empty. On 1, type "%TEMP%\startup.txt" shows the line beginning startup failure: that says why. Zip the folder and that is the release:

Terminal window
tar -a -c -f C:\dev\mygame-release.zip -C C:\dev mygame-release

tar is Windows’ own; the ZIP holds the folder mygame-release and everything in it, about 1.6 MB for the template. These are the rules in game/CMakeLists.txt that make the folder:

game/CMakeLists.txt
# The release folder a player gets, from the x64-release build:
# cmake --install out/build/x64-release --prefix <folder>
# The program, the DLLs it loads, its content and the notices of what it
# carries. A debug build loads the debug runtime, which may not be given away.
if(NOT CMAKE_BUILD_TYPE STREQUAL "Release")
install(CODE [[message(FATAL_ERROR "Install the x64-release build.")]])
endif()
install(TARGETS MyGame RUNTIME DESTINATION .)
# DirectXTK and the XAudio2 redistributable, which vcpkg built as DLLs.
install(FILES $<TARGET_RUNTIME_DLLS:MyGame> DESTINATION .)
# The MSVC runtime, copied beside the program from Visual Studio's redist
# folder, so a player needs no installer: CMake's list of its DLLs, which
# leaves out vcruntime140_threads.dll and vccorlib140.dll.
set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
include(InstallRequiredSystemLibraries)
install(PROGRAMS ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS} DESTINATION .)
install(FILES content/manifest.json DESTINATION .)
install(DIRECTORY content/fonts DESTINATION .)
# The licences of what the program carries: the engine, the libraries
# compiled into it and the DLLs beside it. The font's is fonts/OFL.txt.
get_target_property(labrador_engine_dir LabradorEngine SOURCE_DIR)
set(vcpkg_share "${VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/share")
install(FILES "${labrador_engine_dir}/../LICENSE"
DESTINATION notices RENAME Labrador.txt)
# NOTICE: the code in the engine that is not Labrador's to license.
install(FILES "${labrador_engine_dir}/../NOTICE"
DESTINATION notices RENAME Labrador-NOTICE.txt)
install(FILES "${labrador_engine_dir}/../external/rapidjson/license.txt"
DESTINATION notices RENAME rapidjson.txt)
install(FILES "${vcpkg_share}/directxtk/copyright"
DESTINATION notices RENAME DirectXTK.txt)
install(FILES "${vcpkg_share}/directxmath/copyright"
DESTINATION notices RENAME DirectXMath.txt)
install(FILES "${vcpkg_share}/xaudio2redist/copyright"
DESTINATION notices RENAME XAudio2Redist.txt)
  • install(TARGETS ...) copies the program.
  • $<TARGET_RUNTIME_DLLS:MyGame> is every DLL that a library the game links was built as: DirectXTK and the XAudio2 redistributable, which vcpkg built for the engine. CMake works the list out from the targets, so it does not depend on what happens to be in the build folder.
  • InstallRequiredSystemLibraries finds the MSVC runtime in Visual Studio’s redist folder; the next section says why it is copied.
  • The content lines copy what the build copies beside the program while you work. When you add a folder to content, add an install(DIRECTORY ...) line for it after the fonts one, such as install(DIRECTORY content/textures DESTINATION .) or install(DIRECTORY content/waves DESTINATION .), or the release will start and then stop on the missing file, naming it. Put a picture in your game and Play a sound in your game add those two lines.
  • The notice lines copy the licence of each thing the program carries, as Notices lists.

Installing a debug build stops with Install the x64-release build., because a debug build loads the debug MSVC runtime, which Microsoft does not let you redistribute.

To keep matching symbols for a failure that appears only in the optimized game, use the optional Release-symbols recipe. It preserves the Release choices and keeps the PDB and source evidence privately, outside the installed game folder.

Your game’s title and artwork are yours to supply. A native state can change the caption with:

this->app_->set_window_title(L"Your title");

Call it on the application thread. Before initialization it selects startup text; later it updates the window without showing or resizing it. Empty text clears the caption. Native startup and the runtime setter refuse embedded NUL instead of silently truncating the text. A browser page keeps ownership of its document title and favicon; these native operations do not change either.

The current development template includes game_icon.rc and an optional GAME_ICON_FILE recipe. They are absent from the v0.3.0 starter. To use the new runtime methods or copied template code, first follow Move a starter project to a newer Labrador or Move your engine pin with an engine containing the additions. Updating the engine alone does not replace your copied game files; the icon recipe names the three pieces to take together and their placement.

With your icon saved as C:\dev\mygame\game\app.ico, configure the Release choice explicitly:

Terminal window
cmake --preset x64-release "-DGAME_ICON_FILE=C:/dev/mygame/game/app.ico"
cmake --build --preset x64-release
ctest --preset x64-release

The path must name an existing .ico; configure names an explicitly missing file, and the resource compiler reports a malformed icon. The guarded native entry selects the named GAME_ICON resource. At runtime an explicit icon name that cannot load stops startup with that name. Leaving the choice empty retains the ordinary optional IDI_ICON lookup. The engine borrows the shared resource handles and does not destroy them.

Use the install command above afterward. The .ico is compiled into the executable: the release list stays the same, with no loose icon or new installer for a player. CI builds this optional recipe in its assembled consumer copy, checks the native entry’s compile definition, checks the installed named group and image resources, and runs its hidden startup check. Those checks establish resource delivery and lookup; Explorer/taskbar appearance with your artwork and display scaling are separate observations. The existing scaled-display qualification applies; no new physical DPI support is claimed by the icon recipe.

The game and DirectXTK.dll are built with Visual Studio, and they load its runtime: MSVCP140.dll, VCRUNTIME140.dll and VCRUNTIME140_1.dll. Windows does not include these. A player who has never installed the Visual C++ Redistributable sees Windows refuse to start the game, with a message that VCRUNTIME140.dll was not found, before any of your code or the engine’s runs. There are three ways to get the runtime to them:

  • Copy it into the release folder, which is what the install rules do. The loader looks in the program’s own folder first, so the copies there are used whether or not the player has the runtime installed.
  • Have the player install the Visual C++ Redistributable (vc_redist.x64.exe). This suits a game that already has an installer or a store that installs dependencies.
  • Link the runtime statically. Every library the game links would then have to be built the same way, vcpkg’s packages included, and the XAudio2 redistributable would still be a DLL.

The template copies it, so that the folder runs as it is unzipped and the player has nothing else to install. Of the three it is the simplest for both of you: no installer step for the player, and no second way of building every library for you (T3). The runtime is part of the platform edge the engine buys rather than builds, and shipping what it buys is part of buying it (T9). The cost is that Windows Update does not update copies in your folder: a newer runtime reaches players when you build a release with a newer Visual Studio. Microsoft describes all three ways in Redistributing Visual C++ files.

InstallRequiredSystemLibraries copies CMake’s own list of the runtime’s DLLs from Visual Studio’s redist folder for x64: the three the template loads, and msvcp140_1.dll, msvcp140_2.dll, msvcp140_atomic_wait.dll, msvcp140_codecvt_ids.dll and concrt140.dll, which it does not yet. A game that starts to use a part of the standard library that lives in one of those finds it already there. The folder holds two more that the list leaves out: vcruntime140_threads.dll, which C11’s <threads.h> loads, and vccorlib140.dll, the C++/CX runtime. A game that uses either adds an install(FILES ...) line copying it from the same redist folder, or Windows refuses to start it on a machine without the runtime, naming the DLL.

The template’s release folder, run on a desktop with Visual Studio installed, loaded all three from the release folder rather than from Windows. That shows the copies are the ones used, but not that nothing else is missing, because the desktop has the runtime installed as well. A clean Windows install, one that has never had Visual Studio or the redistributable, settles that, and Windows Sandbox is one, on Windows Pro or Enterprise: tools/consumer_check/README.md describes a script that writes a sandbox configuration to run a release folder’s smoke test there and record the result. On 26 October 2026 the template’s release folder, built from the engine at 2fdb322, ran there: Windows 10.0.26100 with none of vcruntime140.dll, vcruntime140_1.dll and msvcp140.dll installed, and the sandbox’s virtual GPU in front of the host’s graphics card. MyGame.exe --smoke-test exited 0 and wrote nothing to standard error. The sandbox’s GPU is virtual, so that proves the folder loads and its runtime is complete, not that the game draws on a player’s graphics card.

What a game built this way carries, the licence of each, and the file in the release folder that carries its notice. Every one is in the release folder the install rules make.

ComponentLicenceIn the release asNotice fileWhich builds
LabradorMITcompiled into the gamenotices/Labrador.txt, from the engine's LICENSE, and notices/Labrador-NOTICE.txt, from its NOTICE, which records what in the engine is not Labrador's to licenseevery build
Microsoft's DirectX sample code in the engineMITcompiled into the game: step_timer.h, throw_if_failed.h and the Direct3D 11 renderer's device_resourcesnotices/Labrador-NOTICE.txt names the files; the MIT text and Microsoft's copyright are those of notices/DirectXTK.txtevery build has step_timer.h, both Direct3D builds throw_if_failed.h, and the Direct3D 11 build device_resources too
Real-Time Collision Detection, Christer Ericsonthe book's own terms: its code is for use in readers' own softwarecompiled into the game: the engine's closest-point and intersection routines, engine/math/ericson_mathnotices/Labrador-NOTICE.txt, which attributes it and asks a commercial release to read the book's termsevery build
rapidjsonMITcompiled into the game; the engine reads the manifest with itnotices/rapidjson.txt, from external/rapidjson/license.txt in the engineevery build
DirectX Tool KitMITDirectXTK.dllnotices/DirectXTK.txt, from vcpkg's share/directxtk/copyrightevery Windows build
DirectXMathMITcompiled into the game and DirectXTK.dllnotices/DirectXMath.txt, from vcpkg's share/directxmath/copyrightevery Windows build
XAudio2 redistributableMicrosoft Software License Termsxaudio2_9redist.dllnotices/XAudio2Redist.txt, from vcpkg's share/xaudio2redist/copyrightevery Windows build, null audio included: DirectXTK.dll loads it
The MSVC runtimeVisual Studio's licence terms, Distributable Codevcruntime140.dll, vcruntime140_1.dll, msvcp140.dll and the five more on CMake's list of itnone requiredevery Windows build
lodepngzlibcompiled into the game; the engine decodes PNG textures with itnone required: the zlib licence asks nothing of a program built from itevery build
JetBrains MonoSIL Open Font License 1.1fonts/jetbrains_mono_bold_16.spritefont, the template's fontfonts/OFL.txt, beside the atlaswhile the game uses the template's font

Not in any release: doctest, the test framework, linked only by test programs; directx-dxc, an optional host shader compiler; no compiler code is linked into the game; spirv-cross, an optional host shader translator; no translator code is linked into the game.

What the files ask of you, in short, and not as legal advice:

  • MIT (Labrador, Microsoft’s sample code in the engine, rapidjson, DirectX Tool Kit, DirectXMath): the copyright notice and the licence go with every copy of the program, which the notices folder does. Labrador’s LICENSE covers the engine except what its NOTICE records as not Labrador’s to license, so both go: Labrador.txt and Labrador-NOTICE.txt.
  • Real-Time Collision Detection (Christer Ericson): the engine’s closest-point and intersection routines are adapted from the book’s code, which its author provides for use in readers’ own software. Labrador-NOTICE.txt attributes it; before selling a game, read the book’s own terms, as that file says.
  • SIL Open Font License (JetBrains Mono): the licence goes with the font, and the font may not be sold on its own. A game with a font of its own replaces both the atlas and OFL.txt.
  • Microsoft’s terms for the XAudio2 redistributable: you may distribute the DLL with a program that adds significant primary functionality to it, the terms you give players must protect it and Microsoft at least as much as Microsoft’s own terms do, and you indemnify Microsoft. The terms are in notices/XAudio2Redist.txt.
  • The MSVC runtime is redistributed under the Distributable Code terms of your Visual Studio edition’s licence, which ask much the same as XAudio2’s. They need no notice file in the folder.

Other configurations. The other render backends change nothing in the list. Direct3D 12 and OpenGL come with Windows and the graphics driver, and Vulkan’s vulkan-1.dll comes with the player’s graphics driver and is not shipped. The audio backend does not change it either: DirectXTK.dll also runs the gamepad, so a Windows build has it, and the XAudio2 redistributable it loads, whichever audio backend it uses. A browser build carries Labrador with its NOTICE, the collision routines, step_timer.h of Microsoft’s sample code, rapidjson and the font, none of the Windows rows, and the Emscripten runtime and system libraries that NOTICE lists under Linked into a browser build by its toolchain. The browser release command gathers their licence texts into NOTICE.txt beside the page and module.

Kept current. This list is changed in the same commit as any change to the dependencies in Labrador’s vcpkg.json. The site does not build if vcpkg.json names a package that the list neither covers nor says no release carries.

Ship the Direct3D 11 renderer. It is the default, so a preset that sets nothing builds it, it asks the least of the player’s hardware (feature level 10_0, below), it needs nothing beyond Windows and its display driver, and it is the renderer CI installs and starts the Get Started project with. The renderer is LABRADOR_RENDER_BACKEND, set in a configure preset’s cacheVariables: d3d11, d3d12, gl or vulkan. This preset, added to your CMakePresets.json with a build preset to match, builds the same game with OpenGL; A second program for older graphics cards gives the whole file with it and the build and test presets, and every command:

{
"name": "x64-release-gl",
"inherits": "x64-release",
"cacheVariables": { "LABRADOR_RENDER_BACKEND": "gl" }
}

The renderer is chosen when you configure, and the program has exactly one. There is no switching at run time (T5), because choosing per frame would cost a virtual call per sprite (T8). So a machine that refuses the renderer stops the game at start-up, and the engine says why (T6): the template’s main.cpp catches the failure and shows it in a message box titled Sample - startup failure, which you should change to your game’s name: it is the text in quotation marks in the MessageBoxA line near the end of game\main.cpp, MessageBoxA(nullptr, e.what(), "Sample - startup failure",, and the change takes effect at the next build. Rename your game changes it with the program’s name, MyGame.exe, and every other place the name is. What the message says:

Renderer When The message
Direct3D 11 No graphics adapter except Windows’ software one No Direct3D hardware device found
Direct3D 11 Device creation reports unsupported feature level 10_0 The Direct3D 11 device (minimum feature level 10.0) could not be created and the HRESULT
Direct3D 12 No adapter that can do Direct3D 12 at feature level 11_0 No Direct3D 12 hardware device found
OpenGL Bootstrap context creation fails wglCreateContext could not create the bootstrap OpenGL context and the Windows error
OpenGL Only an OpenGL 2.1 driver, or Windows’ own software OpenGL, which is all a machine with no vendor graphics driver has This driver has no WGL_ARB_create_context, so it cannot make an OpenGL 3.3 core context. It is an OpenGL 2.1 driver or a software fallback.
OpenGL A driver that refuses OpenGL 3.3 core This driver refused an OpenGL 3.3 core context and the Windows error
OpenGL A 3.3 core context, but no WGL_EXT_swap_control The OpenGL renderer requires WGL_EXT_swap_control to configure its presentation interval.
OpenGL WGL_EXT_swap_control advertised without its entry points The OpenGL driver advertises WGL_EXT_swap_control but lacks its setter or getter.
Vulkan No Vulkan driver at all Windows refuses to start the program, naming vulkan-1.dll, because the program is linked against it
Vulkan vulkan-1.dll present, but instance creation reports an incompatible driver The Vulkan instance could not be created and Vulkan’s error code
Vulkan An instance, but no Vulkan device at all This machine has a Vulkan loader but no Vulkan device.
Vulkan Devices, but none at Vulkan 1.2 with timeline semaphores No Vulkan device on this machine can run this backend: and a line for each device saying why

The OpenGL renderer has a few rarer refusals the table leaves out: a window that cannot be given a 32-bit pixel format or that refuses the one chosen for it, a 3.3 core context missing one of the functions the engine loads (each names the function), and wglSwapIntervalEXT failing with a Windows error. Each says what it is in the same message box.

Catch a graphics requirement refusal separately

Section titled “Catch a graphics requirement refusal separately”

Development after v0.3.0. Include engine/render/device_unavailable.h to catch labrador::RenderDeviceUnavailable before the template’s existing std::exception handler. It derives from std::runtime_error, and what() retains the backend reason and any native error code. For example, replace the final handler with these two handlers, leaving the existing try body:

{
MessageBoxA(nullptr, error.what(), "MyGame - graphics unavailable", MB_ICONERROR);
return 1;
}
catch (const std::exception& error)
{
MessageBoxA(nullptr, error.what(), "MyGame - startup failure", MB_ICONERROR);
return 1;
}

The narrower handler recognises an unmet startup requirement, such as no acceptable Direct3D adapter, unsupported device creation, missing required OpenGL context capabilities, or Vulkan devices without the required API, presentation queue or timeline semaphores. It does not establish that the machine physically has no GPU. The game chooses the wording and response; the exception does not start another renderer.

Keep the broad handler: malformed content, authored shaders, invalid arguments/state, allocation and unrelated API errors, audio, and runtime device-loss recovery are outside this category. In a browser, a missing WebGL2 API is a capability refusal, but a null context can also mean the page already bound its canvas to another context type. Those ambiguous null/context-creation diagnostics remain ordinary runtime errors. The category is deliberately not an exhaustive detector of every unavailable browser situation; do not treat an arbitrary runtime error as optional graphics.

An ordinary Direct3D Release build refuses every known software adapter, including an unflagged Basic Render Driver. It has no implicit software fallback. A Debug build retains hardware-first selection and WARP fallback, which is why it can start where the ordinary Release build refuses.

Maintainer software tests explicitly configure -DLABRADOR_D3D_SOFTWARE_TEST=ON. This forces WARP even when hardware is available and labels the actual device as software; it is not an ordinary starter default or physical-GPU qualification. The software-test contract owns separate default-refusal and software pixel/installed-game checks.

For machines that refuse it, ship a second program. Build the x64-release-gl preset above and install it into a second folder: everything in it is the same file as in the first, except the program. Copy that program into the first folder as MyGame-gl.exe, and tell players who see the Direct3D message to run it instead. It does not help a machine with no vendor graphics driver, which refuses both: Windows’ own OpenGL is 1.1, and that program gets the WGL_ARB_create_context message above. Each program still has one renderer, chosen when it was built, so this is the choice T5 allows, made by which program the player starts. Both programs were checked to start from one folder this way. Which machines refuse Direct3D 11 and accept OpenGL 3.3 has not been measured.

Many laptops run Windows at 125% or 150% scaling. A program that does not declare DPI awareness is drawn at 100% and then stretched by Windows, which blurs point-sampled text. The template declares per-monitor DPI awareness, so Windows does not stretch it. The declaration is game\dpi_aware.manifest, which game\CMakeLists.txt lists with the sources; the linker embeds it in the program, and the release folder gains no file. The engine’s window keeps its client size in pixels across a DPI change (engine/app/win32/window.cpp), so on a 150% display the window is the size you asked for in physical pixels and looks smaller than an unaware program’s. Whether to draw larger there is your game’s choice. To let Windows stretch the window instead, remove the manifest from the sources.

Each of Labrador’s samples carries the same declaration. A running sample has been checked to be per-monitor aware on a 100% display. Nobody has yet looked at the template at 150% scaling.

Windows. 64-bit Windows 10, version 1607 or later, or Windows 11. The engine’s window calls GetDpiForWindow, GetDpiForSystem, AdjustWindowRectExForDpi, AreDpiAwarenessContextsEqual and GetWindowDpiAwarenessContext (engine/app/win32/window.cpp), which Windows 10 added in version 1607, and the program links them directly, so an earlier Windows refuses to start it, naming the missing function. The game is built for x64 only. The engine is tested on Windows 11 and on GitHub’s Windows Server runner; Windows 10 and Windows on Arm have not been tried.

Processor. Any x64 processor. At start-up the engine asks DirectXMath whether the processor has the instructions it was compiled for, and stops with This CPU does not support the instruction set the renderer needs. if not (engine/app/application.cpp).

Graphics. The floor is the renderer’s, and each is enforced where the device is made:

Renderer The floor Where it is enforced
Direct3D 11 Direct3D feature level 10_0 The device is made at the highest of 11_1 down to the floor, 10_0, the last level device_resources.cpp lists (d3d11/device_resources.h, device_resources.cpp). The shaders are compiled for 4_0_level_9_1, below it (engine/CMakeLists.txt).
Direct3D 12 Feature level 11_0, shader model 5.1 min_feature_level (d3d12/device_resources.cpp); shaders compiled for vs_5_1 and ps_5_1 (engine/CMakeLists.txt)
OpenGL GL 3.3 core, with WGL_EXT_swap_control The context asked of WGL (gl/wgl_context.cpp)
Vulkan Vulkan 1.2, with timeline semaphores min_api_version and the timelineSemaphore check (vulkan/device_resources.cpp)

These are the floors the code refuses below. How fast a game runs on hardware near them has not been measured: the engine is meant for low-end machines, and its timings so far are from a fast desktop and a cloud GPU.

Development documentation (unreleased). Built from Labrador aceb130 of 2026-11-20.

All documentation versions