NVIDIA Run:ai Is Now Open Source as Part of NVIDIA DSX AI Factory Platform

NVIDIA announced that the complete NVIDIA Run:ai platform is now available as open source software, released under the umbrella of the NVIDIA DSX AI Factory Platform. The company positioned the move as establishing Run:ai as an open foundation for AI workload and GPU orchestration that lets the broader ecosystem bring differentiated products to market faster. The source code lives in the NVIDIA Run:ai repository within the NVIDIA DSX AI Factory GitHub organization, and the integrated stack is also published on NVIDIA NGC as a Community Product with a Helm chart for installation.
The open release carries licensing and support caveats worth noting. The source code is governed by its applicable open source licenses, and downloading the NGC Community Product requires accepting the NVIDIA Software License Agreement and Product-Specific Terms for NVIDIA AI Products. No paid Run:ai subscription or NVIDIA support entitlement is required for the Community Product, but NVIDIA enterprise support is not included. Run:ai remains available for NVIDIA Enterprise AI Factory deployments through NVIDIA-supported commercial offerings, including as a standalone product, through NVIDIA Mission Control and NVIDIA AI Enterprise, and in select cloud marketplaces, with availability, licensing and support terms varying by offering.
Historically, Run:ai has been used to run AI workloads on Kubernetes at scale by dynamically allocating GPUs and managing workloads across the full lifecycle, from data processing and training to inference. NVIDIA frames the open sourcing as a way for DSX ecosystem partners and AI clouds to increase workload throughput, improve GPU utilization, and operate shared AI infrastructure more efficiently. Platform teams can adopt the integrated platform wholesale, build their own products on top of it, or integrate individual components.
The release includes four modular components that can each be adopted independently. KAI Scheduler is the Kubernetes-native scheduling engine behind Run:ai, released under the Apache 2.0 license and contributed to CNCF as a Sandbox project. NVIDIA says all scheduler development now happens in the community repository so improvements flow through one codebase, while NVIDIA continues to support maintainers. Its features include gang scheduling with prescheduling in-memory simulation so multipod jobs are placed all-or-nothing rather than evicted needlessly; fair-share allocation including time-based fair-share, plus quota allocation; topology awareness and bin-packing at the scheduling-decision level; GPU sharing across MIG, MPS, time sharing, HaMi and CUDA 13.4 MPS fractioning; and Dynamic Resource Allocation support. It can be deployed alongside an existing software stack without adopting the full Run:ai platform.
GPU Fractioning Operator addresses GPU sharing on Kubernetes. Run:ai previously supplied fractional GPU allocation through a proprietary implementation, which NVIDIA says has been retired in favor of CUDA 13.4-native capability. With that native path, the CUDA driver enforces a hard memory limit per workload and each workload sees only the GPU memory allocated to its fraction. The operator is the Kubernetes integration layer that lets workloads consume CUDA-native fractions, and it ships with a metrics exporter for per-pod visibility into fractions in use. It is scheduler-agnostic but integrates with KAI Scheduler to translate available GPU capacity into placement decisions. Typical uses include interactive notebooks, development sessions and smaller models that do not need a full GPU's memory.
KAI Resource Management is the organizational layer that governs who gets what: projects and departments as an org layer mapping resources to teams and initiatives; allocation, guarantees and sharing of GPU capacity across that hierarchy with fair-share and quota semantics; and node pools for grouping and targeting heterogeneous hardware. NVIDIA describes a scenario where a platform team guarantees 50 percent of a cluster to research while preventing any one team from monopolizing the rest, positioning the component as a replacement for spreadsheets tracking quota entitlements or hand-maintained per-team namespaces.
Workload Map is a workload-management contract. In Kubernetes, AI workloads are rarely bare Deployments or Jobs; they are PyTorchJobs, RayClusters, JobSets, KServe InferenceServices, Dynamo graph deployments or custom resources, each with distinct internal structure, roles such as driver and workers or prefill and decode, scaling and gang semantics, and status reporting. Workload Map describes pods, components and roles; submission and configuration; gang- and topology-aware scheduling; consistent status and health observation; and policy at admission or runtime. It sits between Kubernetes primitives and the schedulers, dashboards, SRE and troubleshooting tools, cost tools, backup tools and ML platforms above it. Rather than each tool building a private partial integration for every CRD, a workload type is defined once. It ships as a Go library that works offline on unstructured objects, so adoption requires nothing added to a cluster, and NVIDIA notes it is deliberately narrow: it describes workload structure and does not schedule, queue, autoscale or propagate across clusters.
Eight DSX ecosystem partners are integrating the open source platform. Crusoe is combining it with Crusoe Managed Kubernetes; Mirantis is extending k0rdent AI to deliver a lifecycle-managed Metal-to-Model AI factory stack; Nebius offers it as a one-click application deployment in Nebius AI Cloud on Nebius Managed Service for Kubernetes; OpenNebula Systems integrates it with the OpenNebula AI Cloud Platform through OneKS for open and sovereign AI clouds; Rafay is expanding its integration into a fully managed service automating GPU infrastructure, clusters, the Run:ai control plane and tenants; Saturn Cloud uses it to help AI cloud operators launch white-label inference services through its Token Factory platform with per-token metering and automated billing; Spectro Cloud integrates it into PaletteAI for deployment through PaletteAI Studio; and vCluster provides pre-validated deployment templates standing up a complete environment per tenant while Run:ai schedules across one GPU fleet.
Two related open source projects complement the platform. Model Streamer targets cold-start latency, reading model weights concurrently and streaming them into GPU memory instead of the usual sequential load. It is integrated upstream in vLLM and SGLang, where it is enabled with the --load-format runai_streamer flag, and in ModelExpress, with support for local filesystems, S3-compatible stores and network file shares. AWS ships it in the vLLM Deep Learning Container and recommends it in official EKS inference documentation; Google Cloud has native Cloud Storage support built with NVIDIA plus GKE documentation; Azure Blob Storage integration was jointly developed by Microsoft and NVIDIA Run:ai, and published benchmarks on eight NVIDIA H100 VMs show 3x to 6x faster loading than the default loader at a steady 80 Gbps versus roughly 40 Gbps. Storage partners have published their own numbers: WEKA reported loading into GPU memory in 3.5 seconds, about 40 percent faster than local NVMe; VAST Data measured 1.7 seconds, a 60 percent improvement over local NVMe; and DDN streamed the 65.5 GB Qwen3-32B across 8 GPUs in under four seconds, translating to up to 10 percent of daily GPU runtime saved versus local storage.
Grove provides a Kubernetes API for orchestrating multi-component workloads such as agentic pipelines, disaggregated serving and mixture-of-experts training, from a single pod to deployments spanning tens of thousands of GPUs. It offers topology-aware autoscaling and hierarchical gang scheduling so components like prefill and decode start as all-or-nothing units, and on NVIDIA GB200 NVL72 it manages ComputeDomain resources automatically so multinode NVLink performance comes from a single annotation rather than hand-authored YAML. Grove is a modular part of NVIDIA Dynamo usable independently, and recent work includes support for llm-d and Volcano as a scheduler backend, with Kueue support in progress.
In practice, this release gives platform teams a way to pick up GPU-aware scheduling and resource governance without committing to a commercial Run:ai subscription. The trade-off is support: the Community Product explicitly excludes NVIDIA enterprise support, so teams adopting it directly take on operational responsibility, while organizations that need vendor backing can continue buying Run:ai commercially or through DSX partner offerings. The modular split also means a team already running Kubernetes can try KAI Scheduler alone, or add only the GPU fractioning layer, rather than replacing its stack.
Why it matters: Platform and infrastructure teams that run shared Kubernetes GPU clusters now have an open path to the scheduling, quota and GPU-sharing machinery that previously came only through Run:ai commercial deployments, including CUDA 13.4-native memory fractioning and a gang-scheduling engine hosted at CNCF. The main practical decisions are whether to adopt the integrated stack or single components, and whether the absence of included enterprise support is acceptable. The eight partner integrations suggest, as inference rather than a stated fact, that managed and hosted variants will appear relatively quickly for teams that want the capability without running it themselves.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
NVIDIA is making the full NVIDIA Run:ai platform available as open source software, giving customers, developers, and ecosystem partners access to...