Start with the project README to install the operator. Choose a reading path by task, or find a capability in the module map.
The capability guides are Heterogeneous Devices, RDMA Networking, Topology, KV Cache, Model Delivery, Model Deployment and GPU Instances.
For a first workload, follow Usage, then use Accelerator Requests to choose its resource keys. The Heterogeneous Devices Walkthrough records a run on a four-node cluster. Workloads that need RDMA also need the RDMA Operations.
For cluster operations, read Architecture and Installation Modes first. The settings, vendor prerequisites and preflight pages cover installation decisions.
Use the topology, model store, high availability and RDMA runbooks as those features are enabled. Hardware partitioning has separate runbooks for NVIDIA, T-Head and Hygon.
For complete examples, use the Walkthroughs entry point. For replica autoscaling, follow the Scaling Walkthrough and read the measured Scaling Benchmark.
Start an upgrade with the relevant page under migration.
For code changes, read Architecture, then use the
module map to find the relevant guide. Internals covers startup constraints, and
Development lists the build and validation commands. The
gpustack-operator-docs skill routes
documentation changes.
Agents should load gpustack-operator-overview, Architecture,
and only the deep page needed for the task.
Each entry routes one module or shared task to its guides, owning specs, code entry points, related modules and skills. Links here are navigation, not proof: a spec records what was decided and measured when it was written, so what the current checkout implements needs the current code. A skill link names a procedure; the entry's other fields carry shared facts.
- ID:
devices - Use for: which resource key a workload asks for; how detection, capacity labels, queues and admission checks enforce it; MIG partitioning runbooks.
- Aliases:
Devices,GPU,NPU,MIG,accelerator,device plugin - Guides: Heterogeneous Devices; the request contract in Accelerator Requests; the gates in Admission.
- Specs: accelerator resource modes · soft-slicing runtime isolation · unified pool · credit scoring · preflight unhealthy accelerators
- Code: pkg/devicemanager (detector, allocator, preflight) · pkg/deviceplugin · pkg/nodefeature · chain reconcilers under pkg/worker/controllers/worker
- Related: RDMA Networking (interfaces in the same node inventory) · Topology (placement over pool capacity) · GPU Instances (the workload the chain admits)
- Skills: gpustack-operator-e2e (scheduling-chain cases) · gpustack-operator-xbuild-and-verify (slicing builder stages and shims)
- ID:
rdma - Use for: requesting RDMA endpoints for a workload; how the NIC inventory, link states and labels are discovered; aligning requests with the kubelet TopologyManager policy.
- Aliases:
RDMA,NIC,RoCE,link state,rdma.capable - Guides: RDMA Networking; keys and policy in RDMA Operations; inventory in Network Topology; endpoints in RDMA Networking Walkthrough.
- Specs: NIC/RDMA topology · endpoint discovery and selection filters · extended resource · NVIDIA fabric domain · fabric by protocol · interface count
- Code: NIC and link discovery in pkg/devicemanager/detector (
network.go,link.go) · internal verbs discovery in detector/rdma.go and observations in pkg/device/rdma.go · interface policy status in api/worker/v1alpha1/devices.go · policy API in api/worker/v1/devices_rdma_selection_policy.go, CRUD proxy and validation · policy resolution in pkg/deviceplugin/rdma_policy.go and active selection reconciliation in rdma_selection_observer.go · response snapshots in pkg/deviceplugin/rdma_selection.go and grant output in pkg/deviceplugin/rdma_allocate.go · request vocabulary in pkg/nodefeature/rdma.go and pkg/nodefeature/fabric.go - Related: Heterogeneous Devices (the interfaces are entries in the same per-node inventory)
- Skills: gpustack-operator-e2e (RDMA cases)
- ID:
topology - Use for: describing domains such as zones and racks; letting Kueue place replicas within a domain; enabling a topology source; diagnosing a Pending group.
- Aliases:
TAS,Topograph,topology source,zone,placement - Guides: Topology; semantics in Topology-Aware Scheduling; enablement in Topology-Aware Scheduling Operations; placement in Hierarchical Placement Walkthrough.
- Specs: topology discovery · model placement preference
- Code: pkg/worker/controllers/worker/topology_source.go and pkg/worker/controllers/worker/node_topology.go
- Related: Heterogeneous Devices (placement constrains which pool serves a replica) · Model Deployment (replicas can prefer nodes holding their model)
- Skills: gpustack-operator-e2e (TAS cases)
- ID:
kv-cache - Use for: standing up a shared inference cache; pool grants and quotas; attaching a workload to a pool.
- Aliases:
KVCacheBackend,KVCachePool,Mooncake,prefix cache,injection - Guides: KV Cache; setup order in Shared Cache Walkthrough; store and grants in KV Cache Backend and KV Cache Pools and Bindings.
- Specs: backend · pool · injection · media and scaling · high availability
- Code: store rendering and read-back in pkg/worker/kvcache · per-engine client config in pkg/worker/kvcache/inject ·
kv_cache_*.goreconcilers under pkg/worker/controllers/worker - Related: Model Deployment (deployments and Pods consume a pool through injection)
- Skills: gpustack-operator-e2e (cache and serving cases)
- ID:
model-delivery - Use for: giving model weights a stable identity; node caching and delivery; prefetch, peer sync, progress views and cache operations.
- Aliases:
ModelArtifact,NodeModelStore,ModelStore,ModelPrefetch,model cache,Hugging Face - Guides: Model Delivery; the artifact contract in Model Artifact; the node cache in Node Model Store; the runbook in Model Store Operations; a measured example in Model Prefetch Walkthrough.
- Specs: model artifact · node model store · prefetch · peer sync · image source · settings sync semantics
- Code: Hub resolution in pkg/modelartifact · the per-node plugin and cache in pkg/modelmanager · cache configuration in pkg/modelstore
- Related: Model Deployment (deployments mount or download artifacts) · KV Cache (the weight identity enters KV keys) · GPU Instances (an Instance can mount weights)
- Skills: gpustack-operator-e2e (node-delivery cases)
- ID:
model-deployment - Use for: describing a serving workload's model, engine and roles; prefill/decode pairing; replica routing, status and metrics; planning a deployment's replica count from its own signals.
- Aliases:
ModelDeployment,ModelDeploymentScaler,scaler,autoscaling,prefill,decode,router,vLLM,SGLang,replica,EPD,encode - Guides: Model Deployment; the role contract in Model Deployment Configuration; replica-count planning in Model Deployment Scaling; the synthetic algorithm-dynamics comparison in Model Deployment Scaling Simulation; measured algorithm behavior in Model Deployment Scaling Benchmark; configuring and observing the scaler in Model Deployment Scaling Walkthrough; engine and transport compatibility in Engine Compatibility; pairing in Prefill and Decode; multimodal disaggregation in Encode, Prefill and Decode; its measured latency and throughput in Encode, Prefill and Decode Benchmark; the disaggregated-versus-aggregated comparison in Prefill and Decode Benchmark; the measured live width change in Elastic EP Benchmark; the measured External DP crossover in External DP Benchmark; replica selection and Router observation in Routing; what a status field means in Status; retirement and drain in Shutdown; in-place collective resize in Elastic EP; fixed per-rank HTTP serving in External DP; disaggregated serving in Prefill and Decode Walkthrough; a recorded multimodal disaggregation run in Encode, Prefill and Decode Walkthrough; a recorded run in Elastic EP Walkthrough; a recorded four-rank External DP run in External DP Walkthrough; multi-node serving in Multi-Host Serving Walkthrough.
- Specs: consolidation · role replica admission · role configuration mutability · P/D pairing and router · router implementations · router qualification and drain · elastic EP resize · EPD disaggregation · unified port 8000 · render version · compilation cache and startup timeout · docs and benchmarks · scaler · capacity priors and evaluation · DP group router supervisor
- Code:
model_deployment_*.goreconcilers (includingmodel_deployment_compile_cache.go) under pkg/worker/controllers/worker · the scaler planner, priors, constraints and rebalance inmodel_deployment_scaler_*.go, the algorithms and prior catalog under pkg/worker/scaling and the catalog generator in gen/priors · native resize client in pkg/worker/elasticengine · webhooks in pkg/worker/webhooks/worker · router image under pack/llm-router - Related: KV Cache (a deployment can attach a shared cache) · Model Delivery (weights reach replicas through an artifact) · Topology (the placement field constrains replicas)
- Skills: gpustack-operator-e2e (serving cases and role update scheduling checks, case 115) · gpustack-operator-benchmark (ModelDeployment serving topology benchmarks) · gpustack-operator-priors (maintain the capacity prior catalog)
- ID:
instances - Use for: launching an accelerator-backed container workspace; SSH access; node pinning and instance metrics.
- Aliases:
Instance,InstanceType,SSH,workspace - Guides: GPU Instances; the request form in Accelerator Requests; utilization in Instance Metrics Reference.
- Specs: SSH instance slicing · sidecar partition visibility · node pinning and additional volumes · utilization metrics · Service preserved across stop
- Code:
instance*.goreconcilers under pkg/worker/controllers/worker · API handlers in pkg/worker/extensionapis/worker · gauges in pkg/devicemanager/exporter and pkg/kubemetrics - Related: Heterogeneous Devices (the request families and the admission chain) · Model Delivery (mounting weights into an Instance)
- Skills: gpustack-operator-e2e (Instance cases)
- ID:
api - Use for: which version a manifest or call targets. User-facing resources are
worker.gpustack.ai/v1;worker.gpustack.ai/v1alpha1is internal controller storage behind the public API, not a version users switch between. The layers: public types, the handlers that proxy them onto internal storage, code generation, and the RBAC that grants access. - Aliases:
worker.gpustack.ai/v1,v1alpha1,CRD,aggregated apiserver - Guides: the version table in Development; a public surface example with its grants in Model Artifact API.
- Code: public types in api/worker/v1 and internal storage in api/worker/v1alpha1 · handlers and proxies in pkg/worker/extensionapis over the pkg/extensionapi plumbing · the routing objects the extension API services are fronted by in pkg/systemkuberess · generators in gen/api · worker RBAC in deploy/gpustack-operator/chart/templates/worker/serviceaccount.yaml
- Related: Development (
make generateregenerates the API surface) · GPU Instances (Instance and InstanceType are the main public resources) - Skills: gpustack-operator-generate (regenerate after type or webhook edits)
- ID:
installation - Use for: choosing chart or image mode; vendored subcharts and their patches; vendor prerequisites; upgrade and migration paths.
- Aliases:
Helm chart,subchart,chart mode,image mode,values.yaml - Guides: choices in Installation Modes; node drivers in Vendor Prerequisites; transfer in Migrating to Bundled Subcharts.
- Specs: bundled apps subchart split · settings sync semantics
- Code: deploy/gpustack-operator/chart · vendoring in hack/deps.sh · image-mode in-cluster install in pkg/worker/kuberess · the settings sync on every worker start in pkg/setting and pkg/worker/settings
- Related: Development (chart targets and subchart patches) · Heterogeneous Devices (the Device Manager DaemonSets the chart deploys)
- Skills: gpustack-operator-chart-e2e (install, rollout and uninstall verification) · gpustack-operator-chart-subcharts-manage (add, patch or bump a vendored subchart)
- ID:
development - Use for: build, lint, test and codegen commands; commit and PR conventions; contributor invariants; release steps; site publication and translations.
- Aliases:
make,lint,codegen,vendored dependencies,staging,Hugo,GitHub Pages - Guides: commands and targets in Development; a local test cluster in Local Cluster Setup; startup invariants in Internals; orientation in Architecture.
- Code: Terraform test infrastructure: clusters on EKS, K3s, Nebius, and RKE2; Nebius standalone compute; storage on in-cluster services and AWS S3 · Makefile and the scripts behind it in hack · site publication in Site workflow and publisher · patched modules in staging · generators in gen · upgrade compatibility checks in upgrade-compat.sh · the chart test's kubeconfig isolation in helm.sh and helm-chart-test-selftest.sh
- Related: API Changes (what
make generateowns) · Installation (chart targets and vendoring) - Skills: gpustack-operator-overview (codebase tour) · gpustack-operator-docs (documentation changes) · gpustack-operator-code-review (PR review criteria) · gpustack-operator-issue-pr (issue and PR titles) · gpustack-operator-release (cut a release) · gpustack-operator-generate (API codegen)
| Page | Description |
|---|---|
| Architecture | See the operator’s four-stage path. |
| Vendor Prerequisites | Prepare each manufacturer’s driver. |
| Page | Description |
|---|---|
| Walkthroughs | Choose a complete example by module. |
| Heterogeneous Devices Walkthrough | Follow a recorded accelerator scheduling run. |
| RDMA Networking Walkthrough | Request and verify RDMA endpoints and NUMA alignment. |
| Hierarchical Placement Walkthrough | Place serving replicas across zones and physical racks. |
| Shared Cache Walkthrough | Create a shared cache from backend to workload. |
| Model Prefetch Walkthrough | Cache weights and verify captured model CR output. |
| Model Deployment Walkthroughs | Choose a serving configuration and its hardware, model and InstanceType setup. |
| Prefill and Decode Walkthrough | Deploy H100 prefill and decode roles with tested TCP transfer settings. |
| Encode, Prefill and Decode Walkthrough | Deploy encode, prefill and decode roles and verify a multimodal request. |
| Model Deployment Scaling Walkthrough | Configure Shadow and Active scaling, choose algorithms and observe replica retirement. |
| Elastic EP Walkthrough | Expand an H100 collective from four to eight GPUs and verify effective width and inference. |
| External DP Walkthrough | Deploy four fixed H100 ranks and verify captured endpoint and Router coverage. |
| Multi-Host Serving Walkthrough | Scale models across multiple GPU nodes. |
| Page | Description |
|---|---|
| Heterogeneous Devices | Choose an accelerator request. |
| Preflight Checks | Check a node before installation. |
| Device Discovery | Trace hardware detection and allocation. |
| Accelerator Requests | Look up resource keys and valid requests. |
| Scheduling Chain | Follow capacity from labels to queues. |
| Admission | Understand the five request checks. |
| NVIDIA MIG Operations | Enable and recover NVIDIA partitions. |
| Hygon MIG Operations | Enable and recover Hygon partitions. |
| T-Head MIG Operations | Enable and recover T-Head partitions. |
| Page | Description |
|---|---|
| RDMA Networking | Start with RDMA requests. |
| Network Topology | See how links and devices are discovered. |
| RDMA Operations | Request and check RDMA endpoints. |
| Page | Description |
|---|---|
| Topology | Start with placement by domain. |
| Topology-Aware Scheduling | Follow topology data into scheduling. |
| Topology-Aware Scheduling Operations | Enable and diagnose topology placement. |
| Page | Description |
|---|---|
| KV Cache | Start with a shared inference cache. |
| KV Cache Backend | Understand the store and its capacity. |
| KV Cache Pools and Bindings | Grant and limit cache use. |
| KV Cache Injection Reference | Attach a Pod to a pool. |
| KV Cache Election and Failover | Understand leader election and health. |
| KV Cache Local Disk Tier | Configure local disk storage. |
| KV Cache on Disk-Heavy Nodes | Size memory on disk-heavy nodes. |
| Page | Description |
|---|---|
| Model Delivery | Choose how weights reach workloads. |
| Model Artifact | Resolve and verify model weights. |
| Model Artifact API | Read artifact and node cache status. |
| Model Image Source | Package weights in an image. |
| Model Prefetch | Warm weights before a workload starts. |
| Node Model Store | Understand node cache state and collection. |
| Node-to-Node Sync | Move cached weights between nodes. |
| Model Store Operations | Operate the node model cache. |
| Page | Description |
|---|---|
| Model Deployment | Start with managed model serving. |
| Model Deployment Configuration | Configure serving roles and overrides. |
| Engine Compatibility | Check engine releases, client and store requirements, and transport support. |
| Prefill and Decode | Pair serving roles. |
| Prefill and Decode Benchmark | Compare equal-GPU H100 aggregated and disaggregated serving across fixed shapes and mixed traffic. |
| Encode, Prefill and Decode | Disaggregate visual encoding, prefill and decode roles. |
| Encode, Prefill and Decode Benchmark | Compare EPD, prefill/decode and aggregated on measured latency and throughput. |
| Elastic EP | Resize one serving instance's collective in place. |
| Elastic EP Benchmark | Compare four- and eight-GPU H100 collectives and measure requests during live expansion. |
| External DP | Run one fixed data-parallel group with an HTTP endpoint on every rank. |
| External DP Benchmark | Compare External DP ranks with a monolithic wide tensor-parallel group. |
| Model Deployment Scaling | Plan a deployment's replica count from the signals it publishes. |
| Model Deployment Scaling Simulation | Compare the three scaler algorithms on identical synthetic traffic with measured adjustment dynamics. |
| Model Deployment Scaling Benchmark | Compare H100 and H200 scaling configurations and capacity priors with measured latency, throughput and lifecycle limits. |
| Model Deployment Routing | Choose a routing policy, confirm a Router serves. |
| Model Deployment Metrics | Read serving metrics. |
| Model Deployment Status | Diagnose deployment conditions, follow a retirement, read the scaler annotations. |
| Model Deployment Shutdown | Understand replica retirement, draining, adoption and unadmitted removal. |
| Page | Description |
|---|---|
| GPU Instances | Start an accelerator-backed workspace. |
| Page | Description |
|---|---|
| Installation Modes | Choose chart or image installation. |
| High Availability Operations | Set replica counts for control-plane parts. |
| Migrating from v0.5.x | Upgrade across the queue refactor. |
| Migrating to Bundled Subcharts | Transfer chart ownership. |
| Upgrading to an Enforced Binding Dtype | Check dtype before upgrading. |
| Migration Troubleshooting | Recover a stuck upgrade. |
| Page | Description |
|---|---|
| Command Reference | Look up binary commands and flags. |
| Settings & Environment Variables | Look up operator configuration. |
| Instance Type Unit Resources Reference | Look up CPU and memory presets. |
| Instance Metrics Reference | Read an Instance’s resource use. |
| Page | Description |
|---|---|
| Development | Build, generate and lint the project. |
| Local Cluster Setup | Install kind and provide a cluster for development tests. |
| Internals | Review startup and naming constraints. |
Every page in this directory (this index excepted) carries:
- a short introduction that explains the subject or task;
- a
## Contentslist mirroring its##headings, in order; - a footer —
**See also**for sideways links and**Next** →for the next page on the path.
Each label above matches its page's H1 exactly. The page table follows the site navigation order.
Deep rationale is demoted into a > **Why** note, so the rule stays skimmable.
Length is not the defect, verbosity is.
Adding or moving a page means updating its row above. Run make lint docs to check links, Contents,
paragraph length, index labels, page coverage and paths named in skills.
Documentation changes do not require Go tests. The former Go tests that read Markdown pages were
removed; compare code-owned values with their reference pages when either changes.