What is slime?
slime is an open-source LLM training framework for reinforcement learning scaling. slime combines Megatron training, SGLang rollout, and customizable data generation within a shared training and Data Buffer path. The framework supports model post-training and agentic RL workflows, including reward computation, verifier feedback, and environment interaction. The repository identifies slime as the RL framework behind multiple GLM releases.
What slime can do
slime provides training and data-generation capabilities through engine integrations and documented customization interfaces. Generation functions, reward functions, verifiers, and environments connect to the same workflow rather than requiring separate paths for each use case. Supported model families include GLM, Qwen, DeepSeek, and Llama, with model configurations and training examples available in the repository.
- slime connects Megatron training with SGLang rollout.
- slime supports custom generation functions with multi-turn loops and tool calls.
- slime incorporates environment interaction and verifier-based rewards into rollout.
- slime supports external serving processes managed outside the training job.
- slime separates prefill and decode resources through PD Disaggregation.
- slime sends changed weight bytes over shared storage through Delta Weight Sync.
How slime works
slime divides the training workflow into training, rollout, and Data Buffer modules. Megatron reads training data from the Data Buffer and synchronizes parameters to rollout after training. SGLang and a router generate new data, including rewards and verifier outputs, and store that data in the Data Buffer. Custom generation functions extend this process for agent workflows.
slime uses Ray object-store as the default payload transport. Optional straw transport places persistent prompt tasks, rollout continuations, and training batches on shared JuiceFS storage, while Ray carries control messages and references. Configuration exposes Megatron arguments directly and installed SGLang arguments through the --sglang- prefix. The Quick Start Guide covers environment setup, data preparation, and an initial training run.
Who slime is for
slime serves developers and researchers building LLM post-training systems, custom rollout workflows, and agentic reinforcement learning experiments. The repository includes examples that use the standard rollout and Data Buffer interfaces rather than a separate agent training path. These examples cover multi-agent generation, search-oriented interactions, asynchronous generation, and coding-agent training with sandbox execution and test rewards.
- slime supports multi-agent generation through a custom generation function.
- slime supports search and RAG-style multi-turn generation.
- slime provides fully asynchronous rollout examples for long-tail agentic generation.
- slime includes a coding-agent RL example using sunabako sandboxes and official test rewards.
slime licensing and access
slime is available as an open-source project through the public THUDM GitHub repository under the Apache-2.0 license. The repository provides source code, documentation, training examples, model configurations, and contribution information. Access to the project is documented through the repository and Quick Start Guide rather than through subscription plans or a hosted product signup.
slime strengths and setup limitations
slime combines direct engine configuration with customization interfaces and reliability tooling. Separate rollout-only and train-only debugging helps isolate workflow components, while CPU/GPU tests cover training, deployment, checkpointing, precision, and asynchronous rollout behavior. Guides address reproducibility, fault tolerance, tracing, and profiling. These capabilities accompany a technical training framework that requires environment preparation and engine configuration.
- slime requires environment setup and data preparation before training.
- slime deployments require configuration of training and rollout components.
- slime shared-storage transport options introduce storage configuration alongside the training setup.
slime FAQ
What is slime?
slime is an open-source LLM training framework for reinforcement learning scaling. slime connects Megatron training with SGLang rollout and supports custom data generation, reward computation, verifier feedback, and environment interaction through a shared training and Data Buffer workflow.
Is slime open source?
slime is an open-source project available in the public THUDM GitHub repository under the Apache-2.0 license. The repository includes source code, documentation, model configurations, training examples, and contribution guidance.
Which models does slime support?
slime supports the GLM family alongside Qwen, DeepSeek, and Llama models. The repository lists supported variants and directs users to scripts/models and the training examples for model configurations and usage details.
Can slime train AI agents?
slime supports agentic reinforcement learning through custom generation functions and the standard rollout and Data Buffer interfaces. Examples cover multi-agent generation, search and RAG-style multi-turn generation, fully asynchronous rollout, and coding-agent training with sandbox interaction and test rewards.
How do you get started with slime?
slime provides a Quick Start Guide covering environment setup, data preparation, and an initial training run. The repository also supplies additional examples, model configurations, and a Customization Guide for choosing interfaces for agentic workflows.
How does slime integrate Megatron and SGLang?
slime uses Megatron for training and SGLang with a router for rollout generation. Megatron reads from the Data Buffer and synchronizes parameters to rollout after training. Megatron arguments are available directly, while SGLang arguments use the --sglang- prefix.
From the community
No reviews yet
Be the first to review this tool. What you write helps the next person choose.




