System requirements
ClikaRT ships one distribution per platform. Every distribution includes the CPU backend; accelerator backends are included where the platform has them and load on demand at run time.
Platforms
| Platform | Architecture | Backends |
|---|---|---|
| Linux | x86_64 | CPU, CUDA, Vulkan |
| Linux | arm64 | CPU, CUDA, Vulkan |
| Android | arm64-v8a | CPU, Vulkan |
| Windows | x86_64 | CPU, Vulkan (CUDA on request) |
| Windows | arm64 | CPU, Vulkan |
| macOS | Apple silicon | CPU, Metal |
Host software
| Requirement | Detail |
|---|---|
| C++ toolchain | A C++17 compiler for your own code; the library itself has no compiler requirement |
| CMake | 3.19 or newer |
| Linux glibc | 2.28 or newer (manylinux_2_28 compatible) |
| macOS | 14 (Sonoma) or newer, on Apple silicon |
| NVIDIA driver | The driver alone: the runtime's CUDA images carry the CUDA runtime and cuBLASLt inside them, so no CUDA toolkit install and no LD_LIBRARY_PATH. A driver of major version 580 or newer serves the CUDA 13 image, an older driver the CUDA 12 image; the Linux archives carry both, and the Python wheel comes in one flavor per image |
| Vulkan | A driver supporting Vulkan 1.2 or newer |
| Python | CPython 3.10 to 3.14 for the clika-runtime wheel, which carries the runtime and clika_runtime.modelverse, on Linux, macOS and Windows x64; CPython 3.11 to 3.14 on Windows arm64. The wheel is an LZMA-compressed zip, which pip reads and uv pip does not |
| License credential | The CLIKA1-... credential your project's license carries, in CLIKA_RT_LICENSE or in the per-user file clikart-license-init writes. Every process that runs an operator needs one (License credential) |
Accelerators
| Backend | Hardware |
|---|---|
| CUDA | NVIDIA GPUs from compute capability 7.0 (Volta) upward, Jetson included |
| Vulkan | Desktop and mobile GPUs with a conformant Vulkan driver (NVIDIA, AMD, Intel, Qualcomm Adreno) |
| Metal | Apple silicon |
Memory
A running model needs memory in proportion to the size of its weights file. The minimums below were measured on devices running the platform's performance benchmark (up to 8 concurrent requests, prompts up to about 2K tokens), with models whose weights are up to about 2.5 GB. The KV cache drives the peak, so fewer concurrent requests or a shorter context need less, and more requests, a longer context or a larger model can need more than these rules give.
| Backend | Platforms | Minimum memory |
|---|---|---|
| CPU | Linux x86_64, Linux arm64, Windows x86_64, macOS | 2 GB of RAM plus about 3.5 times the model's file size |
| CUDA on a discrete NVIDIA GPU | Linux x86_64 | 1 GB of system RAM plus about 0.5 times the model's file size, in addition to GPU memory for the model |
| CUDA on Jetson | Linux arm64 | 2 GB plus about 4 times the model's file size, in the memory the CPU and GPU share |
| Metal on Apple silicon | macOS | no rule: the one measurement, on a 32 GB machine, read about 11 to 14 GB for models from about 0.9 to 2.4 GB, nearly the same whatever the model's size, which does not give a minimum; a rule needs the benchmark on a 16 GB and an 8 GB Mac |
| Vulkan on an integrated GPU | Linux x86_64, Windows x86_64 | no rule: the host's resident-memory counter leaves out the GPU driver's own allocations, so a figure read that way understates the need; a rule needs a GPU-memory counter beside it |
The file size is the size of the model's weights on disk as the platform lists the model. The measurements used models stored as bf16 safetensors; a quantized file of the same model is smaller on disk, and these rules were not measured for it.
Storage
Engine package
The engine package is the ClikaRT build the platform delivers to a device for a benchmark or a model deployment. The platform delivers it to Linux, macOS and Windows x86_64 devices; Windows arm64 devices receive none. Where it can, the platform sends only the part of the engine the device uses. The device keeps the download in its cache next to the extracted tree, so plan for both together. They live under the device agent's staging directory: /var/lib/clika-runtime-agent/staging for a system-wide agent on Linux and macOS, %ProgramData%\Clika\DeviceAgent\staging on Windows, otherwise ~/.clika-rt/staging.
| Device | Download | Installed | Both together |
|---|---|---|---|
| Linux x86_64, no GPU | the dialog's figure | about 320 MB | the download plus about 320 MB |
| Linux x86_64, NVIDIA GPU, driver 580 or newer | the dialog's figure | about 1.6 GB | the download plus about 1.6 GB |
| Linux x86_64, NVIDIA GPU, older driver | the dialog's figure | about 3.0 GB | the download plus about 3.0 GB |
| Linux x86_64, another GPU (AMD, Intel): the whole package | about 1.96 GB | about 4.1 GB | about 6.1 GB |
| Linux arm64, no GPU | the dialog's figure | about 210 MB | the download plus about 210 MB |
| Linux arm64, with the Vulkan backend | the dialog's figure | about 350 MB | the download plus about 350 MB |
| Linux arm64, NVIDIA GPU, driver 580 or newer | the dialog's figure | about 1.8 GB | the download plus about 1.8 GB |
| Linux arm64, NVIDIA GPU, older driver | the dialog's figure | about 3.6 GB | the download plus about 3.6 GB |
| Linux arm64, the whole package | about 2.41 GB | about 5.1 GB | about 7.5 GB |
| Windows x86_64, no GPU | the dialog's figure | about 220 MB | the download plus about 220 MB |
| Windows x86_64, with a GPU: the whole package | about 159 MB | about 370 MB | about 530 MB |
| Windows arm64, the whole package | about 154 MB | about 330 MB | about 480 MB |
| macOS, Apple silicon: the whole package | about 31 MB | about 170 MB | about 200 MB |
| Android arm64, the whole package | about 64 MB | about 310 MB | about 380 MB |
The installed figures are the release archive's tree, summed, less the backend images a row does not carry: on Linux x86_64 the CUDA 13 image is about 1.2 GB, the CUDA 12 image about 2.5 GB and the Vulkan backend about 150 MB of the 4.1 GB; on Linux arm64 about 1.4 GB, 3.3 GB and 150 MB of the 5.1 GB; on Windows the Vulkan backend is about 150 MB of the tree; on macOS the Metal backend about 40 MB. A whole package's download is the release archive itself, whose size the platform's dialog and clika-cli runtime-sdk list show beside it; a composed download (one backend's worth of the tree) is smaller, and the dialog shows its size in the same place, so a row that reads "the dialog's figure" takes it from there.
The first time the platform prepares a part of the engine for one kind of device, that one job or deployment receives the whole package for the platform instead (on Linux x86_64, the "another GPU" row). Each model deployment keeps its own extracted copy, and after an engine update the device also keeps the previous version's download for a while.
Models
Required storage grows with the models you pull, by each model's file size. Benchmarks keep their models in a cache of up to 20 GB by default and remove the oldest first. A model deployment keeps its model until the deployment is deleted with its model removed. A model used by both is stored twice.
Platform software
The device agent takes about 25 MB of disk. clika-cli takes about 15 MB of disk and about 70 MB of RAM while it runs.