Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/Excurs1ons/PrismaEngine/llms.txt

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

This guide walks you through creating a minimal Prisma Engine game using the prebuilt SDK. By the end, you will have a working project that compiles and runs the engine’s initialize-run-shutdown lifecycle using your own IApplication<T> subclass.

​
Requirements

Before you start, make sure you have the following installed:
  • CMake 3.20 or later
  • C++20 compiler — GCC 11+, Clang 13+, or MSVC 2022+
  • Vulkan SDK 1.3+ — install libvulkan-dev on Ubuntu/Debian, or download from vulkan.lunarg.com
The prune branch of Prisma Engine focuses exclusively on SDL3 + Vulkan. DirectX 12, XAudio2, and OpenGL backends are not available on this branch. Make sure your system supports Vulkan 1.3 before proceeding.

​
Steps

1

Download the SDK

Download the prebuilt SDK tarball from the GitHub releases page and extract it into your project directory. Replace VERSION with the SDK version you want, for example 1.0.1.
SDK_VERSION=1.0.1

# Download and extract the SDK with project template
curl -sL https://github.com/Excurs1ons/PrismaEngine/releases/download/v${SDK_VERSION}-sdk/PrismaEngine-SDK-${SDK_VERSION}-linux-arm64.tar.gz | tar xz

# Move the template files into your working directory
mv PrismaEngine-SDK-${SDK_VERSION}-linux-arm64/template/* .
mv PrismaEngine-SDK-${SDK_VERSION}-linux-arm64/template/.* . 2>/dev/null || true
rm -rf PrismaEngine-SDK-${SDK_VERSION}-linux-arm64
This places a ready-to-use project template — including a starter CMakeLists.txt and source files — directly in your current directory.
2

Create CMakeLists.txt

If you prefer to integrate the SDK manually rather than using the template, create a CMakeLists.txt that downloads and links the SDK automatically at configure time.
cmake_minimum_required(VERSION 3.20)
project(MyGame VERSION 0.1.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Download PrismaEngine SDK
set(PRISMA_SDK_VERSION "1.0.1")
set(PRISMA_SDK_URL "https://github.com/Excurs1ons/PrismaEngine/releases/download/v${PRISMA_SDK_VERSION}-sdk/PrismaEngine-SDK-${PRISMA_SDK_VERSION}-linux-arm64.tar.gz")

set(PRISMA_SDK_DIR "${CMAKE_BINARY_DIR}/PrismaEngine-SDK")
if(NOT EXISTS "${PRISMA_SDK_DIR}/cmake/PrismaEngineConfig.cmake")
    message(STATUS "Downloading PrismaEngine SDK...")
    file(DOWNLOAD "${PRISMA_SDK_URL}" "${CMAKE_BINARY_DIR}/PrismaEngine-SDK.tar.gz" SHOW_PROGRESS)
    execute_process(COMMAND ${CMAKE_COMMAND} -E tar xzf "${CMAKE_BINARY_DIR}/PrismaEngine-SDK.tar.gz"
                    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}")
    file(REMOVE "${CMAKE_BINARY_DIR}/PrismaEngine-SDK.tar.gz")
    file(RENAME "${CMAKE_BINARY_DIR}/PrismaEngine-SDK-${PRISMA_SDK_VERSION}-linux-arm64" "${PRISMA_SDK_DIR}")
endif()

list(APPEND CMAKE_PREFIX_PATH "${PRISMA_SDK_DIR}")
find_package(PrismaEngine REQUIRED)

add_executable(MyGame src/main.cpp src/MyApp.h)
target_include_directories(MyGame PRIVATE ${PRISMA_SDK_DIR}/include src)
target_link_libraries(MyGame PRIVATE PrismaEngine::Engine)
target_link_directories(MyGame PRIVATE "${PRISMA_SDK_DIR}/lib/linux")
3

Write your first app

Create src/main.cpp. Your application must subclass IApplication<T> and implement three lifecycle methods: Initialize(), Run(), and Shutdown().
#include <PrismaEngine/PrismaEngine.h>

using namespace PrismaEngine;

class MyGame : public IApplication<MyGame> {
public:
    bool Initialize() override {
        LOG_INFO("MyGame", "Game initializing");
        return Platform::Initialize();
    }

    int Run() override {
        // Main game loop goes here
        return 0;
    }

    void Shutdown() override {
        Platform::Shutdown();
    }
};

int main() {
    MyGame game;
    game.Initialize();
    return game.Run();
}
The IApplication<T> template uses CRTP (Curiously Recurring Template Pattern) to allow the engine to access your concrete type without virtual dispatch overhead. The LOG_INFO macro writes to the engine’s thread-safe logger, which is 100% complete and available across all platforms.
4

Build and run

Configure and build with CMake, then run the resulting binary.
cmake -B build
cmake --build build

./build/MyGame
On a successful build, the engine initializes, runs your game loop, and shuts down cleanly. You should see log output from the LOG_INFO call in your Initialize() method.

​
Next steps

Now that your project builds, explore the rest of the engine:

Build from source

Build the engine, editor, or runtime directly from the repository using CMake presets.

ECS architecture

Learn how to define components, create systems, and wire up the game world using the Entity Component System.

Rendering system

Understand the Vulkan backend, render pipelines, and shader management.

SDK overview

See the full SDK directory structure, CMake helpers, and sample projects.

Build docs developers (and LLMs) love

Get started for freeTalk to us