Stimpack is the open-source implementation of the research paper "Stimpack: An Adaptive Rendering Optimization System for Scalable Cloud Gaming".

In cloud gaming, high-quality rendering often yields diminishing returns on user-perceived quality when delivered over bandwidth-constrained or lossy networks. Stimpack solves this by adaptively balancing server-side rendering costs against user-perceived quality, maximizing system utility in multi-user scenarios.

Figure 1: Strategic adaptation for multi-user scalability (Left) and the Stimpack System Architecture (Right).

Cloud gaming GPUs are often shared among multiple users. Traditional systems waste resources by rendering at high quality even when the network is poor, leading to GPU bottlenecks and high latency.

Stimpack maximizes efficiency by:

• Workload Adaptation: Instead of blindly rendering at high quality, Stimpack dynamically scales down the Rendering Quality (RQ) for users under poor network conditions.
• Utility Maximization: By reducing unnecessary rendering load that would be lost anyway during network compression, we free up GPU resources to maintain a playable FPS for all concurrent users and accommodate twice the capacity of baseline systems.
• Evaluated on Network Traces and Unreal Engine-powered Games: We validate our approach using real-world 3G/4G network traces and Unreal Engine-based games.

The following demos show a side-by-side comparison in a multi-user scenario. Stimpack (Left) adaptively optimizes rendering quality, balancing performance and computational load.

Side-by-Side: Stimpack (Left) vs. Non-Stimpack Baseline (Right).

As described in the paper, Stimpack is designed as a distributed system consisting of two primary components: the Central Runtime and the In-game Plugin.

• Central Runtime (This Repository): The official implementation of the "Brain" of Stimpack. It handles multi-user orchestration, VMAF quality prediction, and RQ optimization logic.
• In-game Plugin & Game Environments: The "Body" of Stimpack implemented in Unreal Engine 5. It manages real-time telemetry and applies the rendering quality changes decided by the runtime.

Stimpack Runtime orchestrates the optimization process by communicating with game instances via ZeroMQ-based IPC, balancing server-side rendering costs against user-perceived quality.

The project is organized into three primary modules that correspond to the system's logic:

The core execution engine that manages the real-time feedback loop.

• runner.py: The main orchestrator that runs the multi-threaded optimization environment.
• rq_manager.py: [Paper §4.3] Implements the round-based RQ optimization and efficiency scoring mechanism.
• user_registerer.py: [Paper §4.1] Manages user sessions and ZeroMQ-based IPC ports for game instances.
• fl_monitor.py: Monitors per-frame rendering latency to ensure SLO compliance.

The pipeline for quantifying and predicting user-perceived quality.

• pred_vmaf/: [Paper §4.2] Contains the pre-trained regression models (Random Forest, SVR, etc.) used to predict VMAF from (Codec, RQ, QP) features.
• trained_models/: Ready-to-use .pkl model files for immediate deployment.
• VMAF Pipeline: Scripts to automate quality scoring using Docker-based easyvmaf.

Tools to simulate the "network-induced lossy compression" discussed in the paper.

• Traces: Real-world 3G and 4G network logs used for evaluation.
• QP Traces: Tools to convert raw throughput logs into the dynamic QP (Quantization Parameter) profiles that Stimpack reacts to.

Stimpack requires Python 3.10+ and uses uv for efficient dependency management.

# Clone the repository
git clone https://github.com/jin-heo/Stimpack.git
cd Stimpack

# Install dependencies using uv
uv sync

Start the main quality manager. It will wait for incoming connections from game instances with Stimpack plugins.

End-to-End Testing: To test Stimpack with real game environments, you need to run the game instances of Stimpack Unreal Engine Plugin along with this runtime. By default, they communicate over localhost:10000.

uv run runtime/runner.py [log_file] [case_name]

In a separate terminal, replay a network trace to simulate changing network quality for a specific user:

uv run runtime/replay_user_qp.py <user_id> <path_to_trace.csv>

To retrain the quality prediction models:

cd models/pred_vmaf
uv run 0_model_train_rev.py

@inproceedings{heo2026stimpack,
  title={Stimpack: An Adaptive Rendering Optimization System for Scalable Cloud Gaming},
  author={Heo, Jin and Wang, Vic and Bhardwaj, Ketan and Gavrilovska, Ada},
  booktitle={23rd USENIX Symposium on Networked Systems Design and Implementation (NSDI 26)},
  year={2026}
}

Licensed under the MIT License.

The name Stimpack is a tribute to the iconic ability of the Terran Marine in Blizzard's StarCraft series.

In the game, a Marine injects a Stimpack to trade a bit of health for a massive boost in combat speed and efficiency. Similarly, our system strategically adjusts (or "sacrifices") unnecessary rendering details to significantly boost the overall scalability and utility of the cloud gaming server.

As a former competitive StarCraft player, the lead author designed Stimpack with a "gamer-first" mindset: ensuring that every bit of computing power is spent where it actually improves the experience.