diff --git a/.claude/skills/add-dynamic-filter/SKILL.md b/.claude/skills/add-dynamic-filter/SKILL.md
index 46e58e161..27390a9b6 100644
--- a/.claude/skills/add-dynamic-filter/SKILL.md
+++ b/.claude/skills/add-dynamic-filter/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: add-dynamic-filter
-description: Guide for adding dynamic/filter hooks in slime rollout pipeline. Use when user wants sample-group selection during rollout, buffer filtering before training, or per-sample masking/processing hooks.
+description: Guide for adding dynamic/filter hooks in vime rollout pipeline. Use when user wants sample-group selection during rollout, buffer filtering before training, or per-sample masking/processing hooks.
 ---
 
 # Add Dynamic Filter
@@ -27,7 +27,7 @@ Use this skill when:
 
 ### Step 2: Implement the Function Signature
 
-Dynamic sampling filter (called in `slime/rollout/vllm_rollout.py`):
+Dynamic sampling filter (called in `vime/rollout/vllm_rollout.py`):
 
 ```python
 def filter_function(args, samples, **kwargs):
@@ -37,12 +37,12 @@ def filter_function(args, samples, **kwargs):
 Preferred return type:
 
 ```python
-from slime.rollout.filter_hub.base_types import DynamicFilterOutput
+from vime.rollout.filter_hub.base_types import DynamicFilterOutput
 
 return DynamicFilterOutput(keep=True, reason=None)
 ```
 
-Buffer filter (called in `slime/rollout/data_source.py`):
+Buffer filter (called in `vime/rollout/data_source.py`):
 
 ```python
 def buffer_filter(args, rollout_id, buffer, num_samples):
@@ -74,7 +74,7 @@ def process_all_samples(args, all_samples, data_source):
 Example wiring:
 
 ```bash
---dynamic-sampling-filter-path slime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std
+--dynamic-sampling-filter-path vime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std
 --buffer-filter-path <module>.buffer_filter
 --rollout-sample-filter-path <module>.rollout_sample_filter
 --rollout-all-samples-process-path <module>.process_all_samples
@@ -95,7 +95,7 @@ Example wiring:
 
 ## Reference Locations
 
-- Dynamic filter types: `slime/rollout/filter_hub/base_types.py`
-- Dynamic filter example: `slime/rollout/filter_hub/dynamic_sampling_filters.py`
-- Rollout generation hook points: `slime/rollout/vllm_rollout.py`
-- Buffer filter hook point: `slime/rollout/data_source.py`
+- Dynamic filter types: `vime/rollout/filter_hub/base_types.py`
+- Dynamic filter example: `vime/rollout/filter_hub/dynamic_sampling_filters.py`
+- Rollout generation hook points: `vime/rollout/vllm_rollout.py`
+- Buffer filter hook point: `vime/rollout/data_source.py`
diff --git a/.claude/skills/add-eval-dataset-config/SKILL.md b/.claude/skills/add-eval-dataset-config/SKILL.md
index 6ff2463e5..42bf0c930 100644
--- a/.claude/skills/add-eval-dataset-config/SKILL.md
+++ b/.claude/skills/add-eval-dataset-config/SKILL.md
@@ -1,11 +1,11 @@
 ---
 name: add-eval-dataset-config
-description: Guide for adding and validating evaluation dataset configuration in slime. Use when user wants to configure eval datasets via --eval-config or --eval-prompt-data, add per-dataset overrides, or customize evaluation rollout behavior.
+description: Guide for adding and validating evaluation dataset configuration in vime. Use when user wants to configure eval datasets via --eval-config or --eval-prompt-data, add per-dataset overrides, or customize evaluation rollout behavior.
 ---
 
 # Add Eval Dataset Config
 
-Configure evaluation datasets in slime with explicit dataset-level overrides and predictable runtime behavior.
+Configure evaluation datasets in vime with explicit dataset-level overrides and predictable runtime behavior.
 
 ## When to Use
 
@@ -53,7 +53,7 @@ eval:
 
 ### Step 3: Understand Override Priority
 
-`slime/utils/eval_config.py` resolves fields in this order:
+`vime/utils/eval_config.py` resolves fields in this order:
 
 1. Dataset-level values in `eval.datasets[*]`
 2. `eval.defaults`
@@ -85,7 +85,7 @@ Use a separate eval function when inference/eval behavior must differ from train
 
 ## Reference Locations
 
-- Eval config model: `slime/utils/eval_config.py`
-- Eval config resolution: `slime/utils/arguments.py`
-- Eval rollout path: `slime/rollout/vllm_rollout.py`
+- Eval config model: `vime/utils/eval_config.py`
+- Eval config resolution: `vime/utils/arguments.py`
+- Eval rollout path: `vime/rollout/vllm_rollout.py`
 - Customization docs: `docs/en/get_started/customization.md`
diff --git a/.claude/skills/add-reward-function/SKILL.md b/.claude/skills/add-reward-function/SKILL.md
index f6ba3f9a7..453217747 100644
--- a/.claude/skills/add-reward-function/SKILL.md
+++ b/.claude/skills/add-reward-function/SKILL.md
@@ -1,11 +1,11 @@
 ---
 name: add-reward-function
-description: Guide for adding a custom reward function in slime and wiring it through --custom-rm-path (and optional reward post-processing). Use when user wants new reward logic, remote/service reward integration, or task-specific reward shaping.
+description: Guide for adding a custom reward function in vime and wiring it through --custom-rm-path (and optional reward post-processing). Use when user wants new reward logic, remote/service reward integration, or task-specific reward shaping.
 ---
 
 # Add Reward Function
 
-Implement custom reward logic and connect it to slime rollout/training safely.
+Implement custom reward logic and connect it to vime rollout/training safely.
 
 ## When to Use
 
@@ -24,11 +24,11 @@ Pick one of these:
 - Single-sample mode (`--group-rm` disabled): custom function gets one `Sample`
 - Group/batch mode (`--group-rm` enabled): custom function gets `list[Sample]`
 
-`slime.rollout.rm_hub.__init__.py` calls your function via `--custom-rm-path`.
+`vime.rollout.rm_hub.__init__.py` calls your function via `--custom-rm-path`.
 
 ### Step 2: Create Reward Module
 
-Create `slime/rollout/rm_hub/<your_rm>.py`.
+Create `vime/rollout/rm_hub/<your_rm>.py`.
 
 Supported signatures:
 
@@ -66,14 +66,14 @@ Wire with:
 --custom-reward-post-process-path <module>.post_process_rewards
 ```
 
-This hook is consumed in `slime/ray/rollout.py`.
+This hook is consumed in `vime/ray/rollout.py`.
 
 ### Step 5: Wire and Validate
 
 Use:
 
 ```bash
---custom-rm-path slime.rollout.rm_hub.<your_rm>.custom_rm
+--custom-rm-path vime.rollout.rm_hub.<your_rm>.custom_rm
 ```
 
 ## Common Mistakes
@@ -85,6 +85,6 @@ Use:
 
 ## Reference Locations
 
-- Reward dispatch: `slime/rollout/rm_hub/__init__.py`
-- Reward post-process hook: `slime/ray/rollout.py`
+- Reward dispatch: `vime/rollout/rm_hub/__init__.py`
+- Reward post-process hook: `vime/ray/rollout.py`
 - Customization docs: `docs/en/get_started/customization.md`
diff --git a/.claude/skills/add-rollout-function/SKILL.md b/.claude/skills/add-rollout-function/SKILL.md
index 39aa2f8ca..a1e72cc3f 100644
--- a/.claude/skills/add-rollout-function/SKILL.md
+++ b/.claude/skills/add-rollout-function/SKILL.md
@@ -1,18 +1,18 @@
 ---
 name: add-rollout-function
-description: Guide for adding a new rollout function in slime and wiring it through --rollout-function-path. Use when user wants to implement custom rollout data generation logic, custom train/eval rollout outputs, or migrate from the default vLLM rollout path.
+description: Guide for adding a new rollout function in vime and wiring it through --rollout-function-path. Use when user wants to implement custom rollout data generation logic, custom train/eval rollout outputs, or migrate from the default vLLM rollout path.
 ---
 
 # Add Rollout Function
 
-Implement a custom rollout function and integrate it safely with slime training/eval flow.
+Implement a custom rollout function and integrate it safely with vime training/eval flow.
 
 ## When to Use
 
 Use this skill when:
 
 - User asks to add a new rollout task or rollout generation function
-- User asks to replace default `slime.rollout.vllm_rollout.generate_rollout`
+- User asks to replace default `vime.rollout.vllm_rollout.generate_rollout`
 - User asks to customize train/eval data generation behavior
 
 ## Step-by-Step Guide
@@ -21,15 +21,15 @@ Use this skill when:
 
 Start from one of these references:
 
-- Async RL-style rollout: `slime/rollout/vllm_rollout.py`
-- Simple SFT-style rollout: `slime/rollout/sft_rollout.py`
+- Async RL-style rollout: `vime/rollout/vllm_rollout.py`
+- Simple SFT-style rollout: `vime/rollout/sft_rollout.py`
 
 If the task needs engine-based async generation and rewards, use the vLLM path as base.
 If the task is file/buffer-driven and simple, use sft path as base.
 
 ### Step 2: Create the New Rollout Module
 
-Create a new file, for example: `slime/rollout/<your_rollout>.py`
+Create a new file, for example: `vime/rollout/<your_rollout>.py`
 
 Required callable signature:
 
@@ -38,7 +38,7 @@ def generate_rollout(args, rollout_id, data_source, evaluation=False) -> Rollout
     ...
 ```
 
-Return types are defined in `slime/rollout/base_types.py`.
+Return types are defined in `vime/rollout/base_types.py`.
 
 ### Step 3: Implement Train and Eval Branches Explicitly
 
@@ -48,7 +48,7 @@ Return types are defined in `slime/rollout/base_types.py`.
 Minimal skeleton:
 
 ```python
-from slime.rollout.base_types import RolloutFnTrainOutput, RolloutFnEvalOutput
+from vime.rollout.base_types import RolloutFnTrainOutput, RolloutFnEvalOutput
 
 
 def generate_rollout(args, rollout_id, data_source, evaluation=False):
@@ -83,12 +83,12 @@ If partial rollout or masking logic is involved, keep `loss_mask` semantics cons
 Set your function path via CLI:
 
 ```bash
---rollout-function-path slime.rollout.<your_rollout>.generate_rollout
+--rollout-function-path vime.rollout.<your_rollout>.generate_rollout
 ```
 
 The default and signature expectation are documented in:
 
-- `slime/utils/arguments.py`
+- `vime/utils/arguments.py`
 - `docs/en/get_started/customization.md`
 
 ## Common Mistakes
@@ -100,9 +100,9 @@ The default and signature expectation are documented in:
 
 ## Reference Locations
 
-- Default rollout: `slime/rollout/vllm_rollout.py`
-- Simple custom example: `slime/rollout/sft_rollout.py`
-- Output dataclasses: `slime/rollout/base_types.py`
-- Wiring/loading: `slime/ray/rollout.py`
-- Argument definition: `slime/utils/arguments.py`
+- Default rollout: `vime/rollout/vllm_rollout.py`
+- Simple custom example: `vime/rollout/sft_rollout.py`
+- Output dataclasses: `vime/rollout/base_types.py`
+- Wiring/loading: `vime/ray/rollout.py`
+- Argument definition: `vime/utils/arguments.py`
 - Customization docs: `docs/en/get_started/customization.md`
diff --git a/.claude/skills/add-tests-and-ci/SKILL.md b/.claude/skills/add-tests-and-ci/SKILL.md
index ac5e514b0..ea880bd23 100644
--- a/.claude/skills/add-tests-and-ci/SKILL.md
+++ b/.claude/skills/add-tests-and-ci/SKILL.md
@@ -1,11 +1,11 @@
 ---
 name: add-tests-and-ci
-description: Guide for adding or updating slime tests and CI wiring. Use when tasks require new test cases, CI registration, test matrix updates, or workflow template changes.
+description: Guide for adding or updating vime tests and CI wiring. Use when tasks require new test cases, CI registration, test matrix updates, or workflow template changes.
 ---
 
 # Add Tests and CI
 
-Add reliable tests and integrate them with slime CI flow.
+Add reliable tests and integrate them with vime CI flow.
 
 ## When to Use
 
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index 31c59343a..2996653dc 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -1,5 +1,5 @@
 name: Bug Report
-description: Report a bug to help us improve slime. Please check the docs and existing issues before submitting.
+description: Report a bug to help us improve vime. Please check the docs and existing issues before submitting.
 title: "[Bug] "
 labels: ["bug"]
 body:
@@ -8,13 +8,13 @@ body:
       value: |
         Thank you for taking the time to report a bug!
 
-        > **Note:** slime's open-source collaboration is currently focused on **bug fixes** and **general-purpose RL optimizations**.
-        > Feature requests are outside our current scope — please see [CONTRIBUTING.md](https://github.com/THUDM/slime/blob/main/CONTRIBUTING.md) for details.
+        > **Note:** vime's open-source collaboration is currently focused on **bug fixes** and **general-purpose RL optimizations**.
+        > Feature requests are outside our current scope — please see [CONTRIBUTING.md](https://github.com/vllm-project/vime/blob/main/CONTRIBUTING.md) for details.
 
         Before submitting, please make sure you have:
-        - [ ] Read the [documentation](https://thudm.github.io/slime/) and [FAQ](https://thudm.github.io/slime/en/get_started/qa.html)
-        - [ ] Searched [existing issues](https://github.com/THUDM/slime/issues) to avoid duplicates
-        - [ ] Reproduced the issue with the latest version of slime
+        - [ ] Read the [documentation](https://vllm-project.github.io/vime/) and [FAQ](https://vllm-project.github.io/vime/en/get_started/qa.html)
+        - [ ] Searched [existing issues](https://github.com/vllm-project/vime/issues) to avoid duplicates
+        - [ ] Reproduced the issue with the latest version of vime
 
   - type: textarea
     id: description
@@ -60,9 +60,9 @@ body:
     attributes:
       label: Environment
       description: |
-        Please provide your environment details. You can run `pip show slime` and `python -c "import torch; print(torch.__version__)"` to get some of this info.
+        Please provide your environment details. You can run `pip show vime` and `python -c "import torch; print(torch.__version__)"` to get some of this info.
       value: |
-        - slime version:
+        - vime version:
         - Python version:
         - PyTorch version:
         - CUDA version:
@@ -93,11 +93,11 @@ body:
     attributes:
       label: Pre-submission Checklist
       options:
-        - label: I have read the [CONTRIBUTING.md](https://github.com/THUDM/slime/blob/main/CONTRIBUTING.md) and understand the collaboration scope.
+        - label: I have read the [CONTRIBUTING.md](https://github.com/vllm-project/vime/blob/main/CONTRIBUTING.md) and understand the collaboration scope.
           required: true
-        - label: I have read the [documentation](https://thudm.github.io/slime/) and my issue is not addressed there.
+        - label: I have read the [documentation](https://vllm-project.github.io/vime/) and my issue is not addressed there.
           required: true
-        - label: I have searched for [existing issues](https://github.com/THUDM/slime/issues) and this is not a duplicate.
+        - label: I have searched for [existing issues](https://github.com/vllm-project/vime/issues) and this is not a duplicate.
           required: true
         - label: I have provided a minimal, reproducible example.
           required: true
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
index 04d024a2c..94ade3bd8 100644
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,16 +1,16 @@
 blank_issues_enabled: false
 contact_links:
   - name: Collaboration Scope / 协作范围
-    url: https://github.com/THUDM/slime/blob/main/CONTRIBUTING.md
+    url: https://github.com/vllm-project/vime/blob/main/CONTRIBUTING.md
     about: |
       Please read before submitting. We welcome bug reports and general RL optimizations; feature requests are currently outside our scope.
       提交前请阅读。我们欢迎 bug 报告和通用 RL 优化，feature request 暂时不在协作范围内。
   - name: Documentation
-    url: https://thudm.github.io/slime/
+    url: https://vllm-project.github.io/vime/
     about: Please check the documentation before opening an issue. Many common questions are already answered there.
   - name: Q&A / FAQ
-    url: https://thudm.github.io/slime/en/get_started/qa.html
+    url: https://vllm-project.github.io/vime/en/get_started/qa.html
     about: Check the FAQ — your question might already have an answer.
   - name: Discussions
-    url: https://github.com/THUDM/slime/discussions
+    url: https://github.com/vllm-project/vime/discussions
     about: For general questions and open-ended conversations, please use GitHub Discussions instead.
diff --git a/.github/ISSUE_TEMPLATE/question.yml b/.github/ISSUE_TEMPLATE/question.yml
index a6bd52f97..ac116bfab 100644
--- a/.github/ISSUE_TEMPLATE/question.yml
+++ b/.github/ISSUE_TEMPLATE/question.yml
@@ -1,5 +1,5 @@
 name: Question / Help
-description: Ask a question about using slime. Please check the docs and FAQ first.
+description: Ask a question about using vime. Please check the docs and FAQ first.
 title: "[Question] "
 labels: ["question"]
 body:
@@ -8,16 +8,16 @@ body:
       value: |
         Thank you for reaching out!
 
-        > **Note:** slime's open-source collaboration is currently focused on **bug fixes** and **general-purpose RL optimizations**.
-        > Feature requests are outside our current scope — please see [CONTRIBUTING.md](https://github.com/THUDM/slime/blob/main/CONTRIBUTING.md) for details.
+        > **Note:** vime's open-source collaboration is currently focused on **bug fixes** and **general-purpose RL optimizations**.
+        > Feature requests are outside our current scope — please see [CONTRIBUTING.md](https://github.com/vllm-project/vime/blob/main/CONTRIBUTING.md) for details.
 
         Before asking, please make sure you have checked:
-        - [Quick Start Guide](https://thudm.github.io/slime/en/get_started/quick_start.html)
-        - [Usage Guide](https://thudm.github.io/slime/en/get_started/usage.html)
-        - [FAQ](https://thudm.github.io/slime/en/get_started/qa.html)
-        - [Examples](https://github.com/THUDM/slime/tree/main/examples)
+        - [Quick Start Guide](https://vllm-project.github.io/vime/en/get_started/quick_start.html)
+        - [Usage Guide](https://vllm-project.github.io/vime/en/get_started/usage.html)
+        - [FAQ](https://vllm-project.github.io/vime/en/get_started/qa.html)
+        - [Examples](https://github.com/vllm-project/vime/tree/main/examples)
 
-        Many common questions are already covered in the documentation above. If your question is about general usage or open-ended discussion, consider using [GitHub Discussions](https://github.com/THUDM/slime/discussions) instead.
+        Many common questions are already covered in the documentation above. If your question is about general usage or open-ended discussion, consider using [GitHub Discussions](https://github.com/vllm-project/vime/discussions) instead.
 
   - type: textarea
     id: question
@@ -46,7 +46,7 @@ body:
       label: Environment (if relevant)
       description: If your question is related to setup or runtime behavior, please provide your environment details.
       value: |
-        - slime version:
+        - vime version:
         - Python version:
         - PyTorch version:
         - CUDA version:
@@ -64,9 +64,9 @@ body:
     attributes:
       label: Pre-submission Checklist
       options:
-        - label: I have read the [CONTRIBUTING.md](https://github.com/THUDM/slime/blob/main/CONTRIBUTING.md) and understand the collaboration scope.
+        - label: I have read the [CONTRIBUTING.md](https://github.com/vllm-project/vime/blob/main/CONTRIBUTING.md) and understand the collaboration scope.
           required: true
-        - label: I have read the [documentation](https://thudm.github.io/slime/) and [FAQ](https://thudm.github.io/slime/en/get_started/qa.html) and my question is not answered there.
+        - label: I have read the [documentation](https://vllm-project.github.io/vime/) and [FAQ](https://vllm-project.github.io/vime/en/get_started/qa.html) and my question is not answered there.
           required: true
-        - label: I have searched for [existing issues](https://github.com/THUDM/slime/issues) and my question has not been asked before.
+        - label: I have searched for [existing issues](https://github.com/vllm-project/vime/issues) and my question has not been asked before.
           required: true
diff --git a/.github/workflows/pr-test.yml b/.github/workflows/pr-test.yml
index bc8b8e769..c81c38189 100644
--- a/.github/workflows/pr-test.yml
+++ b/.github/workflows/pr-test.yml
@@ -63,10 +63,10 @@ jobs:
     env:
       GITHUB_COMMIT_NAME: ${{ github.sha }}_${{ github.event.pull_request.number || 'non-pr' }}
       WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
-      SLIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
-      SLIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
-      SLIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
-      SLIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
+      VIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
+      VIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
+      VIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
+      VIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
 
     steps:
       - name: Checkout repository
@@ -96,17 +96,17 @@ jobs:
             -e HTTPS_PROXY \
             -e GITHUB_COMMIT_NAME \
             -e WANDB_API_KEY \
-            -e SLIME_TEST_ENABLE_INFINITE_RUN \
-            -e SLIME_TEST_USE_DEEPEP \
-            -e SLIME_TEST_USE_FP8_ROLLOUT \
-            -e SLIME_TEST_ENABLE_EVAL \
+            -e VIME_TEST_ENABLE_INFINITE_RUN \
+            -e VIME_TEST_USE_DEEPEP \
+            -e VIME_TEST_USE_FP8_ROLLOUT \
+            -e VIME_TEST_ENABLE_EVAL \
             -e TEST_FILE="${{ matrix.info.test_file }}" \
             -e TEST_ARGS="${{ matrix.info.test_args || '' }}" \
             -e NUM_GPUS="${{ matrix.info.num_gpus }}" \
             -v "$GITHUB_WORKSPACE:$GITHUB_WORKSPACE" \
-            -v /mnt/nvme0n1/slime_ci:/data/slime_ci \
-            -v /mnt/nvme0n1/slime_ci/models:/root/models \
-            -v /mnt/nvme0n1/slime_ci/datasets:/root/datasets \
+            -v /mnt/nvme0n1/vime_ci:/data/vime_ci \
+            -v /mnt/nvme0n1/vime_ci/models:/root/models \
+            -v /mnt/nvme0n1/vime_ci/datasets:/root/datasets \
             -w "$GITHUB_WORKSPACE" \
             inferactinc/public:vime-vllm-cu129-latest \
             bash -lc '
@@ -147,10 +147,10 @@ jobs:
     env:
       GITHUB_COMMIT_NAME: ${{ github.sha }}_${{ github.event.pull_request.number || 'non-pr' }}
       WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
-      SLIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
-      SLIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
-      SLIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
-      SLIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
+      VIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
+      VIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
+      VIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
+      VIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
 
     steps:
       - name: Checkout repository
@@ -180,17 +180,17 @@ jobs:
             -e HTTPS_PROXY \
             -e GITHUB_COMMIT_NAME \
             -e WANDB_API_KEY \
-            -e SLIME_TEST_ENABLE_INFINITE_RUN \
-            -e SLIME_TEST_USE_DEEPEP \
-            -e SLIME_TEST_USE_FP8_ROLLOUT \
-            -e SLIME_TEST_ENABLE_EVAL \
+            -e VIME_TEST_ENABLE_INFINITE_RUN \
+            -e VIME_TEST_USE_DEEPEP \
+            -e VIME_TEST_USE_FP8_ROLLOUT \
+            -e VIME_TEST_ENABLE_EVAL \
             -e TEST_FILE="${{ matrix.info.test_file }}" \
             -e TEST_ARGS="${{ matrix.info.test_args || '' }}" \
             -e NUM_GPUS="${{ matrix.info.num_gpus }}" \
             -v "$GITHUB_WORKSPACE:$GITHUB_WORKSPACE" \
-            -v /mnt/nvme0n1/slime_ci:/data/slime_ci \
-            -v /mnt/nvme0n1/slime_ci/models:/root/models \
-            -v /mnt/nvme0n1/slime_ci/datasets:/root/datasets \
+            -v /mnt/nvme0n1/vime_ci:/data/vime_ci \
+            -v /mnt/nvme0n1/vime_ci/models:/root/models \
+            -v /mnt/nvme0n1/vime_ci/datasets:/root/datasets \
             -w "$GITHUB_WORKSPACE" \
             inferactinc/public:vime-vllm-cu129-latest \
             bash -lc '
@@ -231,10 +231,10 @@ jobs:
     env:
       GITHUB_COMMIT_NAME: ${{ github.sha }}_${{ github.event.pull_request.number || 'non-pr' }}
       WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
-      SLIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
-      SLIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
-      SLIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
-      SLIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
+      VIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
+      VIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
+      VIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
+      VIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
 
     steps:
       - name: Checkout repository
@@ -264,17 +264,17 @@ jobs:
             -e HTTPS_PROXY \
             -e GITHUB_COMMIT_NAME \
             -e WANDB_API_KEY \
-            -e SLIME_TEST_ENABLE_INFINITE_RUN \
-            -e SLIME_TEST_USE_DEEPEP \
-            -e SLIME_TEST_USE_FP8_ROLLOUT \
-            -e SLIME_TEST_ENABLE_EVAL \
+            -e VIME_TEST_ENABLE_INFINITE_RUN \
+            -e VIME_TEST_USE_DEEPEP \
+            -e VIME_TEST_USE_FP8_ROLLOUT \
+            -e VIME_TEST_ENABLE_EVAL \
             -e TEST_FILE="${{ matrix.info.test_file }}" \
             -e TEST_ARGS="${{ matrix.info.test_args || '' }}" \
             -e NUM_GPUS="${{ matrix.info.num_gpus }}" \
             -v "$GITHUB_WORKSPACE:$GITHUB_WORKSPACE" \
-            -v /mnt/nvme0n1/slime_ci:/data/slime_ci \
-            -v /mnt/nvme0n1/slime_ci/models:/root/models \
-            -v /mnt/nvme0n1/slime_ci/datasets:/root/datasets \
+            -v /mnt/nvme0n1/vime_ci:/data/vime_ci \
+            -v /mnt/nvme0n1/vime_ci/models:/root/models \
+            -v /mnt/nvme0n1/vime_ci/datasets:/root/datasets \
             -w "$GITHUB_WORKSPACE" \
             inferactinc/public:vime-vllm-cu129-latest \
             bash -lc '
@@ -315,10 +315,10 @@ jobs:
     env:
       GITHUB_COMMIT_NAME: ${{ github.sha }}_${{ github.event.pull_request.number || 'non-pr' }}
       WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
-      SLIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
-      SLIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
-      SLIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
-      SLIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
+      VIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
+      VIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
+      VIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
+      VIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
 
     steps:
       - name: Checkout repository
@@ -348,17 +348,17 @@ jobs:
             -e HTTPS_PROXY \
             -e GITHUB_COMMIT_NAME \
             -e WANDB_API_KEY \
-            -e SLIME_TEST_ENABLE_INFINITE_RUN \
-            -e SLIME_TEST_USE_DEEPEP \
-            -e SLIME_TEST_USE_FP8_ROLLOUT \
-            -e SLIME_TEST_ENABLE_EVAL \
+            -e VIME_TEST_ENABLE_INFINITE_RUN \
+            -e VIME_TEST_USE_DEEPEP \
+            -e VIME_TEST_USE_FP8_ROLLOUT \
+            -e VIME_TEST_ENABLE_EVAL \
             -e TEST_FILE="${{ matrix.info.test_file }}" \
             -e TEST_ARGS="${{ matrix.info.test_args || '' }}" \
             -e NUM_GPUS="${{ matrix.info.num_gpus }}" \
             -v "$GITHUB_WORKSPACE:$GITHUB_WORKSPACE" \
-            -v /mnt/nvme0n1/slime_ci:/data/slime_ci \
-            -v /mnt/nvme0n1/slime_ci/models:/root/models \
-            -v /mnt/nvme0n1/slime_ci/datasets:/root/datasets \
+            -v /mnt/nvme0n1/vime_ci:/data/vime_ci \
+            -v /mnt/nvme0n1/vime_ci/models:/root/models \
+            -v /mnt/nvme0n1/vime_ci/datasets:/root/datasets \
             -w "$GITHUB_WORKSPACE" \
             inferactinc/public:vime-vllm-cu129-latest \
             bash -lc '
@@ -399,10 +399,10 @@ jobs:
     env:
       GITHUB_COMMIT_NAME: ${{ github.sha }}_${{ github.event.pull_request.number || 'non-pr' }}
       WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
-      SLIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
-      SLIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
-      SLIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
-      SLIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
+      VIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
+      VIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
+      VIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
+      VIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
 
     steps:
       - name: Checkout repository
@@ -432,17 +432,17 @@ jobs:
             -e HTTPS_PROXY \
             -e GITHUB_COMMIT_NAME \
             -e WANDB_API_KEY \
-            -e SLIME_TEST_ENABLE_INFINITE_RUN \
-            -e SLIME_TEST_USE_DEEPEP \
-            -e SLIME_TEST_USE_FP8_ROLLOUT \
-            -e SLIME_TEST_ENABLE_EVAL \
+            -e VIME_TEST_ENABLE_INFINITE_RUN \
+            -e VIME_TEST_USE_DEEPEP \
+            -e VIME_TEST_USE_FP8_ROLLOUT \
+            -e VIME_TEST_ENABLE_EVAL \
             -e TEST_FILE="${{ matrix.info.test_file }}" \
             -e TEST_ARGS="${{ matrix.info.test_args || '' }}" \
             -e NUM_GPUS="${{ matrix.info.num_gpus }}" \
             -v "$GITHUB_WORKSPACE:$GITHUB_WORKSPACE" \
-            -v /mnt/nvme0n1/slime_ci:/data/slime_ci \
-            -v /mnt/nvme0n1/slime_ci/models:/root/models \
-            -v /mnt/nvme0n1/slime_ci/datasets:/root/datasets \
+            -v /mnt/nvme0n1/vime_ci:/data/vime_ci \
+            -v /mnt/nvme0n1/vime_ci/models:/root/models \
+            -v /mnt/nvme0n1/vime_ci/datasets:/root/datasets \
             -w "$GITHUB_WORKSPACE" \
             inferactinc/public:vime-vllm-cu129-latest \
             bash -lc '
@@ -483,10 +483,10 @@ jobs:
     env:
       GITHUB_COMMIT_NAME: ${{ github.sha }}_${{ github.event.pull_request.number || 'non-pr' }}
       WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
-      SLIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
-      SLIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
-      SLIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
-      SLIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
+      VIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
+      VIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
+      VIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
+      VIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
 
     steps:
       - name: Checkout repository
@@ -549,10 +549,10 @@ jobs:
     env:
       GITHUB_COMMIT_NAME: ${{ github.sha }}_${{ github.event.pull_request.number || 'non-pr' }}
       WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
-      SLIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
-      SLIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
-      SLIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
-      SLIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
+      VIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
+      VIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
+      VIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
+      VIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
 
     steps:
       - name: Checkout repository
@@ -582,17 +582,17 @@ jobs:
             -e HTTPS_PROXY \
             -e GITHUB_COMMIT_NAME \
             -e WANDB_API_KEY \
-            -e SLIME_TEST_ENABLE_INFINITE_RUN \
-            -e SLIME_TEST_USE_DEEPEP \
-            -e SLIME_TEST_USE_FP8_ROLLOUT \
-            -e SLIME_TEST_ENABLE_EVAL \
+            -e VIME_TEST_ENABLE_INFINITE_RUN \
+            -e VIME_TEST_USE_DEEPEP \
+            -e VIME_TEST_USE_FP8_ROLLOUT \
+            -e VIME_TEST_ENABLE_EVAL \
             -e TEST_FILE="${{ matrix.info.test_file }}" \
             -e TEST_ARGS="${{ matrix.info.test_args || '' }}" \
             -e NUM_GPUS="${{ matrix.info.num_gpus }}" \
             -v "$GITHUB_WORKSPACE:$GITHUB_WORKSPACE" \
-            -v /mnt/nvme0n1/slime_ci:/data/slime_ci \
-            -v /mnt/nvme0n1/slime_ci/models:/root/models \
-            -v /mnt/nvme0n1/slime_ci/datasets:/root/datasets \
+            -v /mnt/nvme0n1/vime_ci:/data/vime_ci \
+            -v /mnt/nvme0n1/vime_ci/models:/root/models \
+            -v /mnt/nvme0n1/vime_ci/datasets:/root/datasets \
             -w "$GITHUB_WORKSPACE" \
             inferactinc/public:vime-vllm-cu129-latest \
             bash -lc '
@@ -707,10 +707,10 @@ jobs:
     env:
       GITHUB_COMMIT_NAME: ${{ github.sha }}_${{ github.event.pull_request.number || 'non-pr' }}
       WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
-      SLIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
-      SLIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
-      SLIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
-      SLIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
+      VIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
+      VIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
+      VIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
+      VIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
 
     steps:
       - name: Checkout repository
@@ -737,17 +737,17 @@ jobs:
             -e HTTPS_PROXY \
             -e GITHUB_COMMIT_NAME \
             -e WANDB_API_KEY \
-            -e SLIME_TEST_ENABLE_INFINITE_RUN \
-            -e SLIME_TEST_USE_DEEPEP \
-            -e SLIME_TEST_USE_FP8_ROLLOUT \
-            -e SLIME_TEST_ENABLE_EVAL \
+            -e VIME_TEST_ENABLE_INFINITE_RUN \
+            -e VIME_TEST_USE_DEEPEP \
+            -e VIME_TEST_USE_FP8_ROLLOUT \
+            -e VIME_TEST_ENABLE_EVAL \
             -e TEST_FILE="${{ matrix.info.test_file }}" \
             -e TEST_ARGS="${{ matrix.info.test_args || '' }}" \
             -e NUM_GPUS="${{ matrix.info.num_gpus }}" \
             -v "$GITHUB_WORKSPACE:$GITHUB_WORKSPACE" \
-            -v /mnt/nvme0n1/slime_ci:/data/slime_ci \
-            -v /mnt/nvme0n1/slime_ci/models:/root/models \
-            -v /mnt/nvme0n1/slime_ci/datasets:/root/datasets \
+            -v /mnt/nvme0n1/vime_ci:/data/vime_ci \
+            -v /mnt/nvme0n1/vime_ci/models:/root/models \
+            -v /mnt/nvme0n1/vime_ci/datasets:/root/datasets \
             -w "$GITHUB_WORKSPACE" \
             inferactinc/public:vime-vllm-cu129-latest \
             bash -lc '
diff --git a/.github/workflows/pr-test.yml.j2 b/.github/workflows/pr-test.yml.j2
index adab45a63..17e96fad2 100644
--- a/.github/workflows/pr-test.yml.j2
+++ b/.github/workflows/pr-test.yml.j2
@@ -147,10 +147,10 @@ jobs:
     env:
       GITHUB_COMMIT_NAME: ${{ github.sha }}_${{ github.event.pull_request.number || 'non-pr' }}
       WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
-      SLIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
-      SLIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
-      SLIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
-      SLIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
+      VIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
+      VIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
+      VIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
+      VIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
 
     steps:
       - name: Checkout repository
@@ -213,17 +213,17 @@ jobs:
             -e HTTPS_PROXY \
             -e GITHUB_COMMIT_NAME \
             -e WANDB_API_KEY \
-            -e SLIME_TEST_ENABLE_INFINITE_RUN \
-            -e SLIME_TEST_USE_DEEPEP \
-            -e SLIME_TEST_USE_FP8_ROLLOUT \
-            -e SLIME_TEST_ENABLE_EVAL \
+            -e VIME_TEST_ENABLE_INFINITE_RUN \
+            -e VIME_TEST_USE_DEEPEP \
+            -e VIME_TEST_USE_FP8_ROLLOUT \
+            -e VIME_TEST_ENABLE_EVAL \
             -e TEST_FILE="${{ matrix.info.test_file }}" \
             -e TEST_ARGS="${{ matrix.info.test_args || '' }}" \
             -e NUM_GPUS="${{ matrix.info.num_gpus }}" \
             -v "$GITHUB_WORKSPACE:$GITHUB_WORKSPACE" \
-            -v /mnt/nvme0n1/slime_ci:/data/slime_ci \
-            -v /mnt/nvme0n1/slime_ci/models:/root/models \
-            -v /mnt/nvme0n1/slime_ci/datasets:/root/datasets \
+            -v /mnt/nvme0n1/vime_ci:/data/vime_ci \
+            -v /mnt/nvme0n1/vime_ci/models:/root/models \
+            -v /mnt/nvme0n1/vime_ci/datasets:/root/datasets \
             -w "$GITHUB_WORKSPACE" \
             << config.image if config.image else 'inferactinc/public:vime-vllm-cu129-latest' >> \
             bash -lc '
@@ -338,10 +338,10 @@ jobs:
     env:
       GITHUB_COMMIT_NAME: ${{ github.sha }}_${{ github.event.pull_request.number || 'non-pr' }}
       WANDB_API_KEY: ${{ secrets.WANDB_API_KEY }}
-      SLIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
-      SLIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
-      SLIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
-      SLIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
+      VIME_TEST_ENABLE_INFINITE_RUN: ${{ (github.event_name == 'workflow_dispatch' && github.event.inputs.infinite_run) || 'false' }}
+      VIME_TEST_USE_DEEPEP: ${{ matrix.info.use_deepep || '0' }}
+      VIME_TEST_USE_FP8_ROLLOUT: ${{ matrix.info.use_fp8_rollout || '0' }}
+      VIME_TEST_ENABLE_EVAL: ${{ matrix.info.enable_eval || '1' }}
 
     steps:
       - name: Checkout repository
@@ -368,17 +368,17 @@ jobs:
             -e HTTPS_PROXY \
             -e GITHUB_COMMIT_NAME \
             -e WANDB_API_KEY \
-            -e SLIME_TEST_ENABLE_INFINITE_RUN \
-            -e SLIME_TEST_USE_DEEPEP \
-            -e SLIME_TEST_USE_FP8_ROLLOUT \
-            -e SLIME_TEST_ENABLE_EVAL \
+            -e VIME_TEST_ENABLE_INFINITE_RUN \
+            -e VIME_TEST_USE_DEEPEP \
+            -e VIME_TEST_USE_FP8_ROLLOUT \
+            -e VIME_TEST_ENABLE_EVAL \
             -e TEST_FILE="${{ matrix.info.test_file }}" \
             -e TEST_ARGS="${{ matrix.info.test_args || '' }}" \
             -e NUM_GPUS="${{ matrix.info.num_gpus }}" \
             -v "$GITHUB_WORKSPACE:$GITHUB_WORKSPACE" \
-            -v /mnt/nvme0n1/slime_ci:/data/slime_ci \
-            -v /mnt/nvme0n1/slime_ci/models:/root/models \
-            -v /mnt/nvme0n1/slime_ci/datasets:/root/datasets \
+            -v /mnt/nvme0n1/vime_ci:/data/vime_ci \
+            -v /mnt/nvme0n1/vime_ci/models:/root/models \
+            -v /mnt/nvme0n1/vime_ci/datasets:/root/datasets \
             -w "$GITHUB_WORKSPACE" \
             inferactinc/public:vime-vllm-cu129-latest \
             bash -lc '
diff --git a/.github/workflows/release-docs.yaml b/.github/workflows/release-docs.yaml
index 818e8f0e8..36ef99607 100644
--- a/.github/workflows/release-docs.yaml
+++ b/.github/workflows/release-docs.yaml
@@ -17,7 +17,7 @@ concurrency:
 jobs:
   deploy:
     runs-on: ubuntu-latest
-    if: github.repository == 'THUDM/slime'
+    if: github.repository == 'vllm-project/vime'
     permissions:
       contents: write
     steps:
diff --git a/README.md b/README.md
index c33021be9..c171b80f6 100644
--- a/README.md
+++ b/README.md
@@ -45,10 +45,10 @@ We also provide examples for some use cases not covered in the quick start guide
 Arguments in Vime are divided into three categories:
 
 1. **Megatron arguments**: Vime reads all arguments in Megatron. You can configure Megatron by passing arguments like `--tensor-model-parallel-size 2`.
-2. **vLLM arguments**: vLLM server and engine options are exposed with a `--vllm-` prefix (for example, `--vllm-gpu-memory-utilization`). Router options live under two prefixes: vllm-router's native options are passed with `--router-` (for example, `--router-policy round_robin`, `--router-request-timeout-secs`), while Vime-side orchestration knobs that tell Vime *where* the router lives use `--vllm-router-` (`--vllm-router-ip`, `--vllm-router-port`). See [slime/backends/vllm_utils/arguments.py](slime/backends/vllm_utils/arguments.py) for the full surface.
-3. **Framework-specific arguments**: Shared slime/Vime orchestration flags (rollout GPUs, data paths, RL algorithms, etc.). Please refer to [slime/utils/arguments.py](slime/utils/arguments.py).
+2. **vLLM arguments**: vLLM server and engine options are exposed with a `--vllm-` prefix (for example, `--vllm-gpu-memory-utilization`). Router options live under two prefixes: vllm-router's native options are passed with `--router-` (for example, `--router-policy round_robin`, `--router-request-timeout-secs`), while Vime-side orchestration knobs that tell Vime *where* the router lives use `--vllm-router-` (`--vllm-router-ip`, `--vllm-router-port`). See [vime/backends/vllm_utils/arguments.py](vime/backends/vllm_utils/arguments.py) for the full surface.
+3. **Framework-specific arguments**: Shared Vime orchestration flags (rollout GPUs, data paths, RL algorithms, etc.). Please refer to [vime/utils/arguments.py](vime/utils/arguments.py).
 
-`--rollout-num-gpus-per-engine` sets the tensor parallel size of each vLLM engine. The default rollout entry is `slime.rollout.vllm_rollout.generate_rollout`.
+`--rollout-num-gpus-per-engine` sets the tensor parallel size of each vLLM engine. The default rollout entry is `vime.rollout.vllm_rollout.generate_rollout`.
 
 For complete usage instructions, please refer to the [Usage Documentation](docs/en/get_started/usage.md).
 
@@ -82,7 +82,7 @@ Vime is derived from slime. The following upstream resources and in-repo guides
 ## FAQ & Acknowledgements
 
 - For frequently asked questions, please see the [Q&A](docs/en/get_started/qa.md)
-- Special thanks to the **vLLM** project and the **slime** community, as well as Megatron-LM and other open-source projects that Vime builds upon.
+- Special thanks to the **slime** community and the open-source projects that slime depends on, including **SGLang**, **Megatron-LM**, and others that Vime builds upon.
 
 Citation:
 
diff --git a/README_zh.md b/README_zh.md
index 2804a7728..95a8c03e8 100644
--- a/README_zh.md
+++ b/README_zh.md
@@ -7,7 +7,7 @@
 1. **高性能训练**：通过连接 Megatron 与 vLLM，支持各种模式的高效训练；
 2. **灵活的数据生成**：通过自定义数据生成接口以及 server based engine，实现任意的训练数据生成流程。
 
-Vime 继承 slime 的广泛模型支持，包括：
+Vime 继承了 slime 广泛的模型支持，包括：
 
 - Qwen 系列（Qwen3.6、Qwen3.5、Qwen3Next、Qwen3MoE、Qwen3、Qwen2.5）；
 - DeepSeek V3 系列（DeepSeek V3、V3.1、DeepSeek R1）；
@@ -45,10 +45,10 @@ Vime 继承 slime 的广泛模型支持，包括：
 Vime 的参数分为三类：
 
 1. **Megatron 参数**：Vime 会读取 Megatron 中的全部参数，可通过传入如 `--tensor-model-parallel-size 2` 的方式配置 Megatron；
-2. **vLLM 参数**：vLLM server 与 engine 相关选项以 `--vllm-` 为前缀（例如 `--vllm-gpu-memory-utilization`）。路由相关选项分两类前缀：vllm-router 自身的选项以 `--router-` 传入（例如 `--router-policy round_robin`、`--router-request-timeout-secs`），Vime 侧用于告诉 Vime *router 在哪里* 的编排参数则以 `--vllm-router-` 为前缀（`--vllm-router-ip`、`--vllm-router-port`）。完整参数见 [slime/backends/vllm_utils/arguments.py](slime/backends/vllm_utils/arguments.py)。
-3. **框架参数**：与 slime/Vime 编排相关的开关（rollout GPU、数据路径、RL 算法等），见 [slime/utils/arguments.py](slime/utils/arguments.py)。
+2. **vLLM 参数**：vLLM server 与 engine 相关选项以 `--vllm-` 为前缀（例如 `--vllm-gpu-memory-utilization`）。路由相关选项分两类前缀：vllm-router 自身的选项以 `--router-` 传入（例如 `--router-policy round_robin`、`--router-request-timeout-secs`），Vime 侧用于告诉 Vime *router 在哪里* 的编排参数则以 `--vllm-router-` 为前缀（`--vllm-router-ip`、`--vllm-router-port`）。完整参数见 [vime/backends/vllm_utils/arguments.py](vime/backends/vllm_utils/arguments.py)。
+3. **框架参数**：与 Vime 编排相关的开关（rollout GPU、数据路径、RL 算法等），见 [vime/utils/arguments.py](vime/utils/arguments.py)。
 
-`--rollout-num-gpus-per-engine` 对应每个 vLLM engine 的 tensor parallel size。默认 rollout 入口为 `slime.rollout.vllm_rollout.generate_rollout`。
+`--rollout-num-gpus-per-engine` 对应每个 vLLM engine 的 tensor parallel size。默认 rollout 入口为 `vime.rollout.vllm_rollout.generate_rollout`。
 
 完整使用说明请查阅 [使用文档](docs/zh/get_started/usage.md)。
 
@@ -82,7 +82,7 @@ Vime 由 slime 衍生而来。以下上游资源与本仓库文档仍沿用 slim
 ## 常见 Q&A 与致谢
 
 - 常见问题请见 [Q&A](docs/zh/get_started/qa.md)
-- 特别感谢 **vLLM** 项目与 **slime** 社区，以及 Vime 所依赖的 Megatron-LM 等开源项目。
+- 特别感谢 **slime** 社区，以及 slime 所依赖的 **SGLang**、**Megatron-LM** 等开源项目。
 
 引用 Vime 请使用：
 
diff --git a/docs/README.md b/docs/README.md
index 4402f36fe..781a5c262 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,6 +1,6 @@
-# slime Documentation
+# vime Documentation
 
-We recommend new contributors start from writing documentation, which helps you quickly understand slime codebase.
+We recommend new contributors start from writing documentation, which helps you quickly understand vime codebase.
 Most documentation files are located under the `docs/` folder.
 
 ## Docs Workflow
diff --git a/docs/_static/js/lang-toggle.js b/docs/_static/js/lang-toggle.js
index 39b716b67..99c86fef4 100644
--- a/docs/_static/js/lang-toggle.js
+++ b/docs/_static/js/lang-toggle.js
@@ -1,6 +1,6 @@
 // Inject a language toggle button into the topbar (sphinx-book-theme compatible)
 (function(){
-  const STORAGE_KEY = 'slime-doc-lang';
+  const STORAGE_KEY = 'vime-doc-lang';
   // Default language EN has no URL prefix; Chinese uses '/zh/' inserted after optional repo root.
   function detectCurrent(){
     const { zhIndex } = analyzePath();
@@ -11,15 +11,15 @@
    * Analyze current pathname to figure out repo root + language segment pattern.
    * Supports patterns:
    *  /en/…                (language as first segment)
-   *  /slime/en/…          (GitHub Pages project site repo root, language second)
-   *  /slime/ (no lang yet) -> insert /slime/zh/
+   *  /vime/en/…          (GitHub Pages project site repo root, language second)
+   *  /vime/ (no lang yet) -> insert /vime/zh/
    *  / (no lang) -> insert /zh/
    */
   function analyzePath(){
     const rawParts = window.location.pathname.split('/').filter(Boolean);
     const parts = rawParts.slice();
     let repoRoot = null;
-    if(parts.length > 0 && (window.location.host.endsWith('github.io') || parts[0] === 'slime')){
+    if(parts.length > 0 && (window.location.host.endsWith('github.io') || parts[0] === 'vime')){
       repoRoot = parts[0];
     }
     let zhIndex = -1;
diff --git a/docs/build.sh b/docs/build.sh
index e503a8023..64eb675fc 100755
--- a/docs/build.sh
+++ b/docs/build.sh
@@ -10,4 +10,4 @@ if [ "$LANG" != "en" ] && [ "$LANG" != "zh" ]; then
 fi
 
 cd $SCRIPT_DIR
-SLIME_DOC_LANG=$LANG sphinx-build -b html -D language=$LANG --conf-dir ./  ./$LANG ./build/$LANG 
\ No newline at end of file
+VIME_DOC_LANG=$LANG sphinx-build -b html -D language=$LANG --conf-dir ./  ./$LANG ./build/$LANG
diff --git a/docs/build_all.sh b/docs/build_all.sh
index ddf74f953..5651a7f1e 100755
--- a/docs/build_all.sh
+++ b/docs/build_all.sh
@@ -3,9 +3,9 @@ set -euo pipefail
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 cd "$SCRIPT_DIR"
 
-echo "[slime-docs] Building EN..."
+echo "[vime-docs] Building EN..."
 ./build.sh en
-echo "[slime-docs] Building ZH..."
+echo "[vime-docs] Building ZH..."
 ./build.sh zh
 
 # Create a lightweight root index with auto redirect based on localStorage (done client side)
@@ -15,7 +15,7 @@ cat > "$ROOT_INDEX" <<'EOF'
 <html lang="en">
 <head>
   <meta charset="utf-8" />
-  <title>slime docs</title>
+  <title>vime docs</title>
   <meta name="viewport" content="width=device-width,initial-scale=1" />
   <style>
     body{font:14px/1.4 system-ui,-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif;padding:40px;max-width:720px;margin:auto;color:#222}
@@ -26,14 +26,14 @@ cat > "$ROOT_INDEX" <<'EOF'
   <script>
     (function(){
       var stored = null;
-      try{stored = localStorage.getItem('slime-doc-lang');}catch(e){}
+      try{stored = localStorage.getItem('vime-doc-lang');}catch(e){}
       var path = (stored === 'zh') ? 'zh/' : (stored === 'en') ? 'en/' : null;
       if(path){ window.location.replace(path); }
     })();
   </script>
 </head>
 <body>
-  <h1>slime Documentation</h1>
+  <h1>vime Documentation</h1>
   <p>Select language:</p>
   <p class="lang-links"><a href="en/">English</a> <a href="zh/">中文</a></p>
   <p class="note">Auto-redirect uses your last choice if stored; else pick above.</p>
@@ -41,4 +41,4 @@ cat > "$ROOT_INDEX" <<'EOF'
 </html>
 EOF
 
-echo "[slime-docs] Done. Root landing page at build/index.html"
\ No newline at end of file
+echo "[vime-docs] Done. Root landing page at build/index.html"
\ No newline at end of file
diff --git a/docs/conf.py b/docs/conf.py
index 929cbe0d6..b06473c3d 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -8,9 +8,9 @@
 
 __version__ = "0.0.1"
 
-project = "slime"
-copyright = f"2025-{datetime.now().year}, slime"
-author = "slime Team"
+project = "Vime"
+copyright = f"2025-{datetime.now().year}, Vime"
+author = "Vime Team"
 
 version = __version__
 release = __version__
@@ -92,7 +92,7 @@
 
 master_doc = "index"
 
-language = os.environ.get("SLIME_DOC_LANG", "en")
+language = os.environ.get("VIME_DOC_LANG", "en")
 
 exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
 
@@ -106,7 +106,7 @@
 html_last_updated_fmt = ""
 
 html_theme_options = {
-    "repository_url": "https://github.com/THUDM/slime",
+    "repository_url": "https://github.com/vllm-project/vime",
     "repository_branch": "main",
     "show_navbar_depth": 3,
     "max_navbar_depth": 4,
@@ -202,23 +202,23 @@ def setup(app):
 ]
 myst_heading_anchors = 5
 
-htmlhelp_basename = "slimedoc"
+htmlhelp_basename = "vimedoc"
 
 latex_elements = {}
 
 latex_documents = [
-    (master_doc, "slime.tex", "slime Documentation", "slime Team", "manual"),
+    (master_doc, "vime.tex", "Vime Documentation", "Vime Team", "manual"),
 ]
 
-man_pages = [(master_doc, "slime", "slime Documentation", [author], 1)]
+man_pages = [(master_doc, "vime", "Vime Documentation", [author], 1)]
 
 texinfo_documents = [
     (
         master_doc,
-        "slime",
-        "slime Documentation",
+        "vime",
+        "Vime Documentation",
         author,
-        "slime",
+        "vime",
         "One line description of project.",
         "Miscellaneous",
     ),
diff --git a/docs/en/advanced/arch-support-beyond-megatron.md b/docs/en/advanced/arch-support-beyond-megatron.md
index 6b7187ee5..7b3239cd2 100644
--- a/docs/en/advanced/arch-support-beyond-megatron.md
+++ b/docs/en/advanced/arch-support-beyond-megatron.md
@@ -2,7 +2,7 @@
 
 While the Megatron-LM framework is highly efficient for parallel training, it can lack the flexibility to support rapidly evolving model architectures like Qwen3Next. Natively supporting the unique structures of these models, such as Gated-Delta-Net, often requires invasive and time-consuming modifications to Megatron's core codebase.
 
-To accelerate the adoption of these cutting-edge models, slime introduces a more agile approach: **instead of deeply re-engineering Megatron, we directly import and wrap the model's official HuggingFace implementation**, embedding it as a "black-box" module into Megatron's parallel training pipeline.
+To accelerate the adoption of these cutting-edge models, vime introduces a more agile approach: **instead of deeply re-engineering Megatron, we directly import and wrap the model's official HuggingFace implementation**, embedding it as a "black-box" module into Megatron's parallel training pipeline.
 
 This document uses Qwen3Next 80B-A3B as an example to illustrate this concept.
 
@@ -10,20 +10,20 @@ This document uses Qwen3Next 80B-A3B as an example to illustrate this concept.
 
 Megatron's model instantiation is a two-step process: first, it generates a "layer specification" (`ModuleSpec`) based on the configuration, and then it instantiates the actual PyTorch modules according to that spec.
 
-slime leverages this mechanism by **hijacking the spec generation stage to replace Megatron's native modules** with an external implementation (in this case, from HuggingFace). This process involves the coordination of three core components:
+vime leverages this mechanism by **hijacking the spec generation stage to replace Megatron's native modules** with an external implementation (in this case, from HuggingFace). This process involves the coordination of three core components:
 
 1.  **Replacing the Megatron Module Spec**
     This is the entry point for our solution. We use a custom function (e.g., `get_qwen3_next_spec`) to modify the standard `ModuleSpec`, swapping out Megatron's native Attention layer with our custom wrapper.
     * **Implementation**: It retrieves the standard Decoder Block Spec, points its `self_attention` field to our custom module, and enables model-specific configurations like `qk_layernorm` as needed.
-    * **Corresponding File**: `slime_plugins/models/qwen3_next.py`
+    * **Corresponding File**: `vime_plugins/models/qwen3_next.py`
 
 2.  **Wrapping the HuggingFace Implementation**
     The spec modified in the previous step now points to a wrapper layer, such as `HuggingfaceAttention`. This layer inherits from Megatron's `MegatronModule`. Its core responsibility is to act as a bridge, handling the data alignment required by parallelism strategies (like sequence parallelism), and then internally calling the native `Qwen3NextAttention` module loaded from HuggingFace.
-    * **Corresponding File**: `slime_plugins/models/hf_attention.py`
+    * **Corresponding File**: `vime_plugins/models/hf_attention.py`
 
 3.  **Aligning Model Weights**
     Once the model architecture is integrated, we must ensure that the weights can be loaded correctly. We use the [mbridge](https://github.com/ISEEKYAN/mbridge) library, through our `Qwen3NextBridge`, to establish a naming map between the HuggingFace checkpoint and Megatron's parameters, enabling seamless, bidirectional conversion.
-    * **Corresponding File**: `slime_plugins/mbridge/qwen3_next.py`
+    * **Corresponding File**: `vime_plugins/mbridge/qwen3_next.py`
 
 Through the coordination of these three components, we can successfully run a complex model architecture not natively supported by Megatron—using its HuggingFace implementation as the vehicle—on top of Megatron's parallel framework. This is achieved while fully retaining all key capabilities like model parallelism, MoE acceleration, and pipeline scheduling.
 
diff --git a/docs/en/advanced/fault-tolerance.md b/docs/en/advanced/fault-tolerance.md
index da10c372b..2106c037a 100644
--- a/docs/en/advanced/fault-tolerance.md
+++ b/docs/en/advanced/fault-tolerance.md
@@ -1,13 +1,13 @@
 # Fault Tolerance
 
-To ensure long-term, stable RL training, slime enables a certain level of fault tolerance by default. This section introduces the design philosophy behind fault tolerance in slime.
+To ensure long-term, stable RL training, vime enables a certain level of fault tolerance by default. This section introduces the design philosophy behind fault tolerance in vime.
 
-To enable the fault tolerance function in slime, please set `--use-fault-tolerance`.
+To enable the fault tolerance function in vime, please set `--use-fault-tolerance`.
 
 ## Rollout Fault Tolerance
 
-During the rollout process, slime periodically sends heartbeat requests (`/health`) to all vLLM engines. If a heartbeat times out, that vLLM engine will be stopped. After the current rollout round is complete, the engine will be restarted and its parameters will be correctly updated.
+During the rollout process, vime periodically sends heartbeat requests (`/health`) to all vLLM engines. If a heartbeat times out, that vLLM engine will be stopped. After the current rollout round is complete, the engine will be restarted and its parameters will be correctly updated.
 
-- `--rollout-health-check-first-wait`: Since some large MoE models require compilation on their first run, slime will wait for `rollout_health_check_first_wait` seconds before the first rollout to start sending heartbeats. Defaults to 300s.
+- `--rollout-health-check-first-wait`: Since some large MoE models require compilation on their first run, vime will wait for `rollout_health_check_first_wait` seconds before the first rollout to start sending heartbeats. Defaults to 300s.
 - `--rollout-health-check-interval`: The interval between heartbeat checks. Defaults to 10s.
 - `--rollout-health-check-timeout`: The timeout limit for a heartbeat request. Defaults to 5s.
diff --git a/docs/en/advanced/megatron-config.md b/docs/en/advanced/megatron-config.md
index fb9f1b68d..42a8ad445 100644
--- a/docs/en/advanced/megatron-config.md
+++ b/docs/en/advanced/megatron-config.md
@@ -8,7 +8,7 @@ Unlike `--vllm-config`, `--megatron-config-path` does not manage deployment, rou
 
 ## Design Overview
 
-By default, when `--megatron-config-path` is not used, both actor and critic inherit the Megatron / slime CLI arguments directly.
+By default, when `--megatron-config-path` is not used, both actor and critic inherit the Megatron / vime CLI arguments directly.
 
 With `--megatron-config-path`, the configuration is split into two layers:
 
@@ -17,7 +17,7 @@ With `--megatron-config-path`, the configuration is split into two layers:
 
 **Key design principles:**
 
-- **CLI remains the shared baseline.** slime first parses the normal CLI arguments, then applies the YAML role overrides.
+- **CLI remains the shared baseline.** vime first parses the normal CLI arguments, then applies the YAML role overrides.
 - **Missing roles inherit automatically.** If a role is absent from the YAML file, it simply keeps the CLI arguments unchanged.
 - **Resource allocation is still controlled by CLI.** `num_nodes` and `num_gpus_per_node` in YAML are ignored; placement is still controlled by `--actor-num-*` / `--critic-num-*`.
 
diff --git a/docs/en/advanced/pd-disaggregation.md b/docs/en/advanced/pd-disaggregation.md
index fdfc9f166..263dcc614 100644
--- a/docs/en/advanced/pd-disaggregation.md
+++ b/docs/en/advanced/pd-disaggregation.md
@@ -1,6 +1,6 @@
 # PD Disaggregation
 
-slime supports Prefill and Decode disaggregation (PD Disaggregation).
+vime supports Prefill and Decode disaggregation (PD Disaggregation).
 
 You can set the number of servers used for Prefill by setting the `--prefill-num-servers` argument.
 
diff --git a/docs/en/advanced/reproducibility.md b/docs/en/advanced/reproducibility.md
index da87cd7c5..0036512a4 100644
--- a/docs/en/advanced/reproducibility.md
+++ b/docs/en/advanced/reproducibility.md
@@ -1,6 +1,6 @@
 # Reproducibility
 
-Reproducibility is a bedrock of scientific progress. By combining vLLM's [batch-invariant deterministic inference](https://vllm.ai/blog/2025-11-10-bitwise-consistent-train-inference) with Megatron-LM's deterministic mode, slime supports bitwise experiment reproduction.
+Reproducibility is a bedrock of scientific progress. By combining vLLM's [batch-invariant deterministic inference](https://vllm.ai/blog/2025-11-10-bitwise-consistent-train-inference) with Megatron-LM's deterministic mode, vime supports bitwise experiment reproduction.
 
 To enable deterministic training, you need to first uninstall the flash attention 3 in the docker with `pip uninstall flash_attn_3 -y` and set:
 ```bash
@@ -33,7 +33,7 @@ hf download --repo-type dataset zhuzilin/gsm8k --local-dir /root/gsm8k
 hf download Qwen/Qwen2.5-0.5B-Instruct --local-dir /root/Qwen2.5-0.5B-Instruct
 
 # convert ckpt
-cd slime/
+cd vime/
 source scripts/models/qwen2.5-0.5B.sh
 PYTHONPATH=/root/Megatron-LM/ python \
    tools/convert_hf_to_torch_dist.py \
diff --git a/docs/en/advanced/speculative-decoding.md b/docs/en/advanced/speculative-decoding.md
index a98d01d1a..1d1e34636 100644
--- a/docs/en/advanced/speculative-decoding.md
+++ b/docs/en/advanced/speculative-decoding.md
@@ -5,7 +5,7 @@ Speculative decoding is a key optimization for speeding up rollouts. Instead of
 ## Accelerating Inference with Speculative Decoding
 
 vLLM exposes speculative decoding as a single JSON config (`SpeculativeConfig`),
-which slime forwards via `--vllm-speculative-config`. For models with MTP layers
+which vime forwards via `--vllm-speculative-config`. For models with MTP layers
 (e.g., GLM-4.7, DeepSeek-V3/R1), pass:
 
 ```bash
@@ -34,7 +34,7 @@ For the full list of `SpeculativeConfig` fields (including `disable_by_batch_siz
 
 As RL progresses, the sampling distributions of the draft and target models can drift apart. Fewer draft tokens pass verification, and speculative decoding can even yield negative returns.
 
-slime currently supports online training of the MTP layers during RL, updating the draft model in sync with training to consistently improve sampling speed. See the related rationale in this [blog](https://www.notion.so/jiajunli-guapisolo/Power-Up-Speculative-Decoding-In-Reinforcement-Learning-2a92d24a293b802d9c73dbae429e581e). Use it as follows:
+vime currently supports online training of the MTP layers during RL, updating the draft model in sync with training to consistently improve sampling speed. See the related rationale in this [blog](https://www.notion.so/jiajunli-guapisolo/Power-Up-Speculative-Decoding-In-Reinforcement-Learning-2a92d24a293b802d9c73dbae429e581e). Use it as follows:
 
 ```bash
 --mtp-num-layers 1
diff --git a/docs/en/advanced/vllm-config.md b/docs/en/advanced/vllm-config.md
index bd6949f08..21b7975c6 100644
--- a/docs/en/advanced/vllm-config.md
+++ b/docs/en/advanced/vllm-config.md
@@ -1,12 +1,12 @@
 # vLLM Config: Advanced Engine Deployment
 
-`--vllm-config` is a YAML-based configuration system for fine-grained control over vLLM engine deployment in slime. It enables **multi-model serving**, **Prefill-Decode (PD) disaggregation**, **heterogeneous server groups**, and can even serve as a **standalone vLLM launcher** for complex inference topologies.
+`--vllm-config` is a YAML-based configuration system for fine-grained control over vLLM engine deployment in vime. It enables **multi-model serving**, **Prefill-Decode (PD) disaggregation**, **heterogeneous server groups**, and can even serve as a **standalone vLLM launcher** for complex inference topologies.
 
 ---
 
 ## Architecture Overview
 
-In the default setup (without `--vllm-config`), slime deploys a single model behind a single router with uniform server groups:
+In the default setup (without `--vllm-config`), vime deploys a single model behind a single router with uniform server groups:
 
 ![architecture overview](../../../imgs/arch.png)
 
@@ -170,8 +170,8 @@ python train.py \
 **Accessing models in custom rollout functions:**
 
 ```python
-from slime.rollout.vllm_rollout import get_model_url
-from slime.utils.http_utils import post
+from vime.rollout.vllm_rollout import get_model_url
+from vime.utils.http_utils import post
 
 async def my_generate(args, sample, sampling_params):
     # Route to the actor model (default)
@@ -257,25 +257,25 @@ Overrides take **highest priority**, overriding both the base `--vllm-*` CLI arg
 
 ### 7. Standalone vLLM Launcher
 
-While `--vllm-config` is designed for slime's training pipeline, it also works as a powerful launcher for pure inference scenarios using the `--rollout-external` pattern or by configuring slime to focus solely on serving.
+While `--vllm-config` is designed for vime's training pipeline, it also works as a powerful launcher for pure inference scenarios using the `--rollout-external` pattern or by configuring vime to focus solely on serving.
 
 **Using external engines with a pre-launched topology:**
 
-For complex production deployments, you may want to pre-launch vLLM engines independently and connect them to slime:
+For complex production deployments, you may want to pre-launch vLLM engines independently and connect them to vime:
 
 ```bash
 # Step 1: Launch vLLM engines externally
 vllm serve /path/to/model --port 10090 ...
 vllm serve /path/to/model --port 10091 ...
 
-# Step 2: Connect slime to external engines
+# Step 2: Connect vime to external engines
 python train.py \
   --rollout-external \
   --rollout-external-engine-addrs host1:10090 host2:10091 \
   ...
 ```
 
-> **Note:** `--vllm-config` and `--rollout-external` are mutually exclusive. Use `--vllm-config` when you want slime to manage the full engine lifecycle; use `--rollout-external` when engines are pre-deployed.
+> **Note:** `--vllm-config` and `--rollout-external` are mutually exclusive. Use `--vllm-config` when you want vime to manage the full engine lifecycle; use `--rollout-external` when engines are pre-deployed.
 
 ---
 
@@ -297,7 +297,7 @@ You can configure the routing policy:
 
 For multi-turn dialogues and agentic workloads, session affinity ensures that all requests belonging to the same conversation are routed to the same backend worker. This significantly improves prefix cache hit rates because the worker already has the conversation history cached.
 
-slime automatically assigns each sample a unique `session_id` (stored in `sample.session_id`). When the router policy is `consistent_hash`, this ID is passed as the `x-session-id` header, and vllm-router uses it to deterministically route all turns of the same session to the same worker.
+vime automatically assigns each sample a unique `session_id` (stored in `sample.session_id`). When the router policy is `consistent_hash`, this ID is passed as the `x-session-id` header, and vllm-router uses it to deterministically route all turns of the same session to the same worker.
 
 ```bash
 --router-policy consistent_hash
@@ -306,7 +306,7 @@ slime automatically assigns each sample a unique `session_id` (stored in `sample
 **How it works:**
 
 1. Each sample is assigned a unique `session_id` via UUID
-2. On each request, slime passes `x-session-id: <session_id>` in the HTTP header
+2. On each request, vime passes `x-session-id: <session_id>` in the HTTP header
 3. vllm-router's consistent-hash policy maps this key to a specific worker
 4. Subsequent turns reuse the same `session_id`, ensuring they hit the same worker
 
@@ -314,7 +314,7 @@ slime automatically assigns each sample a unique `session_id` (stored in `sample
 
 ## Resolution Rules
 
-When the config is loaded, slime applies the following resolution cascade:
+When the config is loaded, vime applies the following resolution cascade:
 
 1. **GPU per engine fallback:** Group `num_gpus_per_engine` → Model `num_gpus_per_engine` → `args.rollout_num_gpus_per_engine`
 2. **Model path fallback:** Group `overrides.model_path` → Model `model_path` → `args.hf_checkpoint`
@@ -392,8 +392,8 @@ python train.py \
 **Custom rollout function (`my_agent/rollout.py`):**
 
 ```python
-from slime.rollout.vllm_rollout import get_model_url
-from slime.utils.http_utils import post
+from vime.rollout.vllm_rollout import get_model_url
+from vime.utils.http_utils import post
 
 async def generate_with_models(args, sample, sampling_params):
     """Generate using actor, score with reward model, compare with reference."""
@@ -442,11 +442,11 @@ No. All server groups within a model must share the same `model_path`. This is v
 
 ### Q: How do I access the router address for a specific model at runtime?
 
-Use `get_model_url(args, "model_name", "/endpoint")` from `slime.rollout.vllm_rollout`. It reads from `args.vllm_model_routers`, which is a dict `{ model_name: (ip, port) }` populated automatically.
+Use `get_model_url(args, "model_name", "/endpoint")` from `vime.rollout.vllm_rollout`. It reads from `args.vllm_model_routers`, which is a dict `{ model_name: (ip, port) }` populated automatically.
 
 ### Q: Can I use `--vllm-config` without training (inference only)?
 
-While `--vllm-config` is designed for slime's training loop, you can effectively use it for inference-only scenarios by configuring a rollout-only run. For fully standalone vLLM serving, consider using vLLM's native `vllm serve` directly or the `--rollout-external` mode for connecting to pre-deployed engines.
+While `--vllm-config` is designed for vime's training loop, you can effectively use it for inference-only scenarios by configuring a rollout-only run. For fully standalone vLLM serving, consider using vLLM's native `vllm serve` directly or the `--rollout-external` mode for connecting to pre-deployed engines.
 
 ### Q: What is the relationship between `--vllm-config` and `--prefill-num-servers`?
 
diff --git a/docs/en/developer_guide/ci.md b/docs/en/developer_guide/ci.md
index 700daf8ce..000e94859 100644
--- a/docs/en/developer_guide/ci.md
+++ b/docs/en/developer_guide/ci.md
@@ -1,13 +1,13 @@
 # CI (Continuous Integration)
 
-slime uses GitHub Actions for CI. Tests are triggered by **PR labels** — adding a specific label to a PR will run the corresponding test suite.
+vime uses GitHub Actions for CI. Tests are triggered by **PR labels** — adding a specific label to a PR will run the corresponding test suite.
 
 ## How It Works
 
 The workflow is defined in `.github/workflows/pr-test.yml` (auto-generated from `pr-test.yml.j2`). Each CI job:
 
 1. Runs on a self-hosted GPU runner via `docker run`; most tests use `inferactinc/public:vime-vllm-cu129-latest`, while image validation uses `inferactinc/public:vime-vllm-cu129-latest`.
-2. Installs slime with `pip install -e . --no-deps`.
+2. Installs vime with `pip install -e . --no-deps`.
 3. Acquires the required GPUs via `tests/ci/gpu_lock_exec.py --count <num_gpus>`.
 4. Executes the test file: `python <test_path>.py` or `python tests/<test_file>.py`, depending on whether the test lives under `tests/` or a subdirectory such as `tests/plugin_contracts/`.
 
@@ -20,7 +20,7 @@ Add a label to your PR to trigger the corresponding test suite:
 | Label | Job | Description |
 |---|---|---|
 | `run-ci-short` | `e2e-test-short` | Lightweight smoke tests with Qwen2.5-0.5B (4 GPUs). Fast feedback loop. |
-| `run-ci-megatron` | `e2e-test-megatron` | Core Megatron training tests covering dense, MoE, PPO, OPD, etc. |
+| `run-ci-megatron` | `e2e-test-megatron` | Core Megatron training tests covering dense, MoE, PPO, MTP, etc. |
 | `run-ci-precision` | `e2e-test-precision` | Numerical precision validation (parallel check). |
 | `run-ci-ckpt` | `e2e-test-ckpt` | Checkpoint save/load correctness (sync and async-save). |
 | `run-ci-image` | `e2e-test-image` | Full test suite run on `inferactinc/public:vime-vllm-cu129-latest` image (for image validation). |
@@ -40,7 +40,7 @@ This is the most useful label for development. When you add a new test file or m
 
 This means you don't need to manually register your new test in the workflow — just make sure your test file has a top-level `NUM_GPUS = <N>` constant and `run-ci-changed` will pick it up.
 
-**Example**: If your PR adds `tests/test_qwen3_8B_opd_vllm.py` with `NUM_GPUS = 8`, adding the `run-ci-changed` label will automatically run that test on 8 GPUs.
+**Example**: If your PR adds `tests/test_mimo_7B_mtp_only_grad.py` with `NUM_GPUS = 8`, adding the `run-ci-changed` label will automatically run that test on 8 GPUs.
 
 ### `run-ci-image` — Full Suite on Test Image
 
@@ -56,8 +56,8 @@ Since this includes every test, it consumes significant GPU time — use it spar
 This is the primary label for validating Megatron-backend changes. It covers:
 
 - Dense models: GLM4-9B, Qwen3-4B (PPO)
-- MoE models: Qwen3-30B-A3B (with DeepEP + FP8), Qwen3.6-35B-A3B PD + Mooncake, Moonlight-16B-A3B
-- Specialized: Qwen2.5-0.5B debug rollout-then-train, OPD with vLLM teacher
+- MoE models: Qwen3-30B-A3B (with DeepEP), Qwen3.6-35B-A3B PD + Mooncake, Moonlight-16B-A3B
+- Specialized: MiMo-7B MTP, Qwen2.5-0.5B debug rollout-then-train
 
 All tests use 8 GPUs. If you are modifying Megatron training logic, loss computation, or checkpoint conversion, this is the label to use.
 
@@ -67,7 +67,7 @@ All tests use 8 GPUs. If you are modifying Megatron training logic, loss computa
 
 ```python
 import os
-import slime.utils.external_utils.command_utils as U
+import vime.utils.external_utils.command_utils as U
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/docs/en/developer_guide/debug.md b/docs/en/developer_guide/debug.md
index ec8f33478..784a357e8 100644
--- a/docs/en/developer_guide/debug.md
+++ b/docs/en/developer_guide/debug.md
@@ -2,7 +2,7 @@
 
 ## Aligning Precision
 
-During the development of slime, it is often necessary to check if the model's precision is correct. This can be verified in the following ways:
+During the development of vime, it is often necessary to check if the model's precision is correct. This can be verified in the following ways:
 
 1.  **First Training Step**
     1.  Check if the generated `rollout` is coherent. If not, there are two possible reasons:
@@ -27,20 +27,20 @@ During the development of slime, it is often necessary to check if the model's p
 
 ## Separate Debugging for Training and Inference
 
-slime supports debugging the training and inference parts separately, which allows for the following:
+vime supports debugging the training and inference parts separately, which allows for the following:
 
 * When tuning/debugging the inference part, you can start the task with only a few GPUs.
 * When tuning/debugging the training part, you can ensure the model input is fixed, removing the randomness of rollouts.
 
-Specifically, slime currently provides the following parameters for separate debugging:
+Specifically, vime currently provides the following parameters for separate debugging:
 
 1.  `--debug-rollout-only`
 
-    When enabled, slime will not load Megatron and will only initialize vLLM. You can use this method to debug the inference part.
+    When enabled, vime will not load Megatron and will only initialize vLLM. You can use this method to debug the inference part.
 
 2.  `--debug-train-only`
 
-    When enabled, slime will not load vLLM and will only initialize Megatron. You can use this method to debug the training part.
+    When enabled, vime will not load vLLM and will only initialize Megatron. You can use this method to debug the training part.
 
 3.  `--save-debug-rollout-data /your/saved/debug/data_{rollout_id}.pt`
 
@@ -50,48 +50,6 @@ Specifically, slime currently provides the following parameters for separate deb
 
     When enabled, data will be loaded from `args.load_debug_rollout_data.format(rollout_id=rollout_id)`, and vLLM will not be initialized (automatically setting `debug_train_only=True`). This method allows you to fix the input for the training part to tune it, for example, by switching between different parallelization strategies.
 
-## INT4 / Compressed-Tensors Quantization Checkpoint Issues
-
-When using INT4-quantized models (e.g., `compressed-tensors` with `W4A16`), the checkpoint's `config.json` contains a `quantization_config.ignore` list that specifies which parameters should **not** be quantized. During online weight updates (Megatron → vLLM), slime also reads this ignore list to decide which parameters to INT4-quantize. An incorrect ignore list can cause silent errors:
-
-1. **MoE router weights (`mlp.gate.weight`) become all zeros**
-
-   The MoE router weight (`mlp.gate.weight`, shape `[num_experts, hidden_size]`) is a plain 2D weight tensor, but it is **not** a Linear layer weight. If it is not in the ignore list, the online quantizer will INT4-quantize it into `weight_packed`, `weight_scale`, `weight_zero_point`, etc. However, vLLM does not expect quantized names for the router, so these parameters are silently skipped during `load_weights`, resulting in all-zero gate weights.
-
-   **Fix**: Ensure `config.json` contains `"re:.*mlp\\.gate\\..*"` in the ignore list.
-
-2. **Other non-Linear 2D weights**
-
-   Similar issues can occur with any 2D `.weight` tensor that is not a true Linear layer, such as `model.embed_tokens.weight`. Always verify the ignore list covers all non-Linear weights.
-
-   **Recommended ignore patterns** (for GLM-style MoE models):
-   ```json
-   "ignore": [
-     "lm_head",
-     "model.embed_tokens.weight",
-     "re:.*self_attn.*",
-     "re:.*mlp\\.shared_experts.*",
-     "re:.*mlp\\.gate_up_proj.*",
-     "re:.*mlp\\.gate_proj.*",
-     "re:.*mlp\\.up_proj.*",
-     "re:.*mlp\\.down_proj.*",
-     "re:.*eh_proj.*",
-     "re:.*mlp\\.gate\\..*"
-   ]
-   ```
-
-3. **Missing safetensors shards**
-
-   Conversion tools may occasionally produce an incomplete checkpoint (e.g., a missing `model-00010-of-00093.safetensors`). After conversion, always verify:
-   - The number of `.safetensors` files matches the expected count.
-   - The `model.safetensors.index.json` contains entries for every layer.
-   - Spot-check that critical layers (e.g., the first MoE layer) have the expected number of keys.
-
-4. **How to diagnose**
-
-   - Use `--check-weight-update-equal` to verify that weights after a Megatron → vLLM sync match the expected values. If a parameter shows all zeros on the vLLM side, it was likely incorrectly quantized or missing from the checkpoint.
-   - Use `--debug-rollout-only` with a small number of GPUs to quickly test whether vLLM can generate coherent text from the quantized checkpoint alone.
-
 ## Debug vllm illegal memory access (IMA)
 
 When running large scale RL, we will occationally meet the IMA in vLLM, there are some debug suggestions based on our experience:
diff --git a/docs/en/developer_guide/trace.md b/docs/en/developer_guide/trace.md
index 5d24a6c4b..b1066b09a 100644
--- a/docs/en/developer_guide/trace.md
+++ b/docs/en/developer_guide/trace.md
@@ -1,6 +1,6 @@
 # Trace Viewer
 
-slime can attach lightweight execution traces to each rollout sample. These traces capture span-style events such as generation and reward-model calls, and they can be inspected later from a saved rollout debug dump.
+vime can attach lightweight execution traces to each rollout sample. These traces capture span-style events such as generation and reward-model calls, and they can be inspected later from a saved rollout debug dump.
 
 ![trace timeline viewer](../../_static/image/trace.png)
 
@@ -41,7 +41,7 @@ By default it also starts a local static server so you can open the generated HT
 
 ## Instrument custom code
 
-For custom rollout or reward code, reuse helpers from `slime.utils.trace_utils`:
+For custom rollout or reward code, reuse helpers from `vime.utils.trace_utils`:
 
 - `trace_span(target, name, attrs=...)`: record a duration span.
 - `trace_event(target, name, attrs=...)`: record an instant event.
@@ -54,10 +54,10 @@ Use `trace_span(...)` when you only want to trace part of a function body, or wh
 
 Use `trace_function(...)` when the whole function should be represented as one span. Internally it resolves the trace target and then opens a `trace_span(...)` around the function call, so it works for both sync and async functions.
 
-The decorator is what slime uses for the main rollout pipeline. For example, `generate_and_rm(...)` is traced per sample and `generate_and_rm_group(...)` is traced per sample group:
+The decorator is what vime uses for the main rollout pipeline. For example, `generate_and_rm(...)` is traced per sample and `generate_and_rm_group(...)` is traced per sample group:
 
 ```python
-from slime.utils.trace_utils import trace_function
+from vime.utils.trace_utils import trace_function
 
 
 @trace_function("generate_and_rm", target="sample")
@@ -104,7 +104,7 @@ If you need to add attrs after part of the function has executed, use an inner `
 For per-turn attrs around an HTTP call, wrap it in `trace_span` directly:
 
 ```python
-from slime.utils.trace_utils import trace_span
+from vime.utils.trace_utils import trace_span
 
 with trace_span(sample, "vllm_generate", attrs={"max_tokens": params["max_new_tokens"]}):
     output = await post(url, payload)
diff --git a/docs/en/examples/qwen3-30B-A3B.md b/docs/en/examples/qwen3-30B-A3B.md
index b5724cf64..bca56238d 100644
--- a/docs/en/examples/qwen3-30B-A3B.md
+++ b/docs/en/examples/qwen3-30B-A3B.md
@@ -8,7 +8,7 @@ The environment setup, model download, data, and checkpoint conversion are the s
 To convert huggingface checkpoint to torch_dist, please try:
 
 ```bash
-cd slime/
+cd vime/
 pip install -e . --no-deps
 source scripts/models/qwen3-30B-A3B.sh
 PYTHONPATH=/root/Megatron-LM/ torchrun --nproc-per-node 8 \
@@ -23,13 +23,13 @@ PYTHONPATH=/root/Megatron-LM/ torchrun --nproc-per-node 8 \
 Execute the training script:
 
 ```bash
-cd /root/slime
+cd /root/vime
 bash scripts/run-qwen3-30B-A3B.sh
 ```
 
 ### Parameter Introduction
 
-Here, we will briefly introduce the MoE-related parts in the [run-qwen3-30B-A3B.sh](https://github.com/THUDM/slime/blob/main/scripts/run-qwen3-30B-A3B.sh) script.
+Here, we will briefly introduce the MoE-related parts in the [run-qwen3-30B-A3B.sh](https://github.com/vllm-project/vime/blob/main/scripts/run-qwen3-30B-A3B.sh) script.
 
 1.  To support running Qwen3-30B-A3B in an 8xH800 environment, we need to enable Megatron's CPU Adam to save GPU memory. The corresponding configuration is:
 
@@ -72,25 +72,6 @@ Here, we will briefly introduce the MoE-related parts in the [run-qwen3-30B-A3B.
     For DP on the attention block plus EP on the experts, combine
     `--vllm-data-parallel-size N` with `--vllm-enable-expert-parallel`.
 
-### BF16 Training with FP8 Inference
-
-slime also supports BF16 training with FP8 inference. For the Qwen3-30B-A3B model, you just need to download the following model:
-
-```bash
-hf download Qwen/Qwen3-30B-A3B-FP8 --local-dir /root/Qwen3-30B-A3B-FP8
-```
-
-And replace `--hf-checkpoint` with:
-
-```bash
-#--hf-checkpoint /root/Qwen3-30B-A3B
---hf-checkpoint /root/Qwen3-30B-A3B-FP8
-```
-
-This will trigger FP8 inference. Currently, we directly cast the BF16 weights to FP8. In the future, we will gradually add more sophisticated quantization schemes that have less impact on precision.
-
-⚠️ The Megatron checkpoint for training still needs to be the one that was originally converted from the BF16 Hugging Face model.
-
 ### Multi-Node Support
 
 The following uses **two machines with 8 GPUs each (16 GPUs total)** as the starting example; scripts and parameters scale to **N nodes**. Key differences from single-node:
diff --git a/docs/en/examples/qwen3-4B.md b/docs/en/examples/qwen3-4B.md
index 11ec73957..b544a54ca 100644
--- a/docs/en/examples/qwen3-4B.md
+++ b/docs/en/examples/qwen3-4B.md
@@ -6,8 +6,8 @@ After pulling the `inferactinc/public:vime-vllm-cu129-latest` image, initialize
 
 ```bash
 cd /root/
-git clone https://github.com/THUDM/slime.git
-cd slime/
+git clone https://github.com/vllm-project/vime.git
+cd vime/
 pip install -e . --no-deps
 ```
 
@@ -30,7 +30,7 @@ Convert the Hugging Face checkpoint into a format that Megatron can load:
 
 ```bash
 # mcore checkpoint
-cd /root/slime
+cd /root/vime
 source scripts/models/qwen3-4B.sh
 PYTHONPATH=/root/Megatron-LM python tools/convert_hf_to_torch_dist.py \
     ${MODEL_ARGS[@]} \
@@ -43,13 +43,13 @@ PYTHONPATH=/root/Megatron-LM python tools/convert_hf_to_torch_dist.py \
 Execute the training script:
 
 ```bash
-cd /root/slime
+cd /root/vime
 bash scripts/run-qwen3-4B.sh
 ```
 
 ### Parameter Introduction
 
-Here, we will briefly introduce the various components of the [run-qwen3-4B.sh](https://github.com/THUDM/slime/blob/main/scripts/run-qwen3-4B.sh) script:
+Here, we will briefly introduce the various components of the [run-qwen3-4B.sh](https://github.com/vllm-project/vime/blob/main/scripts/run-qwen3-4B.sh) script:
 
 #### MODEL\_ARGS
 
@@ -58,7 +58,7 @@ SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
 source "${SCRIPT_DIR}/models/qwen3-4B.sh"
 ```
 
-This reads the model's configuration from [scripts/models/qwen3-4B.sh](https://github.com/THUDM/slime/blob/main/scripts/models/qwen3-4B.sh). These are all Megatron parameters. When training with Megatron, it cannot read the model config from the checkpoint, so we need to configure it ourselves. We provide some examples in [scripts/models](https://github.com/THUDM/slime/tree/main/scripts/models/).
+This reads the model's configuration from [scripts/models/qwen3-4B.sh](https://github.com/vllm-project/vime/blob/main/scripts/models/qwen3-4B.sh). These are all Megatron parameters. When training with Megatron, it cannot read the model config from the checkpoint, so we need to configure it ourselves. We provide some examples in [scripts/models](https://github.com/vllm-project/vime/tree/main/scripts/models/).
 
 ⚠️  Ensure that settings such as `--rotary-base` in the model configuration file match the settings of the model you are currently training. This is because different models, even with the same architecture, might use different values. If needed, you can override these parameters in your script after loading the model weights. For instance:
 
@@ -77,8 +77,8 @@ CKPT_ARGS=(
    # Checkpoint for the reference model
    --ref-load /root/Qwen3-4B_torch_dist
    # Load directory for the actor; if empty, it will be loaded from `ref_load`
-   --load /root/Qwen3-4B_slime/
-   --save /root/Qwen3-4B_slime/
+   --load /root/Qwen3-4B_vime/
+   --save /root/Qwen3-4B_vime/
    --save-interval 20
 )
 ```
@@ -98,7 +98,7 @@ ROLLOUT_ARGS=(
    --rollout-shuffle
 
    # Reward model type.
-   # slime provides many types and --custom-rm-path for custom models
+   # vime provides many types and --custom-rm-path for custom models
    --rm-type deepscaler
 
    # Total number of rollouts to train
@@ -135,13 +135,13 @@ EVAL_ARGS=(
 
 #### PERF\_ARGS
 
-This is a set of Megatron's parallelism parameters. Only `--use-dynamic-batch-size` and `--max-tokens-per-gpu` are added by slime.
+This is a set of Megatron's parallelism parameters. Only `--use-dynamic-batch-size` and `--max-tokens-per-gpu` are added by vime.
 
 `max_tokens_per_gpu` specifies the maximum number of tokens each GPU can process. When `use_dynamic_batch_size` is enabled, it attempts to pack data of varying lengths within a batch as close to `max_tokens_per_gpu` as possible, thus forming a dynamic micro-batch size. If a single data item exceeds `max_tokens_per_gpu`, it forms its own batch without being truncated. When context parallelism (CP) is enabled, it allows the CP GPUs to share a total of `CP * max_tokens_per_gpu` tokens.
 
 When `dynamic_batch_size` is enabled, the traditional `micro_batch_size` is ignored.
 
-⚠️ slime always trains the model using data packing and strictly guarantees per-sample or per-token loss. This means enabling dynamic batch size will not affect the loss calculation. It is recommended to enable it.
+⚠️ vime always trains the model using data packing and strictly guarantees per-sample or per-token loss. This means enabling dynamic batch size will not affect the loss calculation. It is recommended to enable it.
 
 ```bash
 PERF_ARGS=(
@@ -193,7 +193,7 @@ OPTIMIZER_ARGS=(
 
 #### VLLM\_ARGS
 
-Parameters for vLLM inference. vime uses vLLM as the rollout backend by default (`rollout.py` launches `VLLMEngine`; the default rollout function is `slime.rollout.vllm_rollout.generate_rollout`), so no extra backend flag is needed. `--rollout-num-gpus-per-engine` corresponds to each vLLM engine's `tensor_parallel_size`. Other vLLM parameters are passed to slime with a `--vllm-` prefix (for example, `--vllm-max-model-len`).
+Parameters for vLLM inference. vime uses vLLM as the rollout backend by default (`rollout.py` launches `VLLMEngine`; the default rollout function is `vime.rollout.vllm_rollout.generate_rollout`), so no extra backend flag is needed. `--rollout-num-gpus-per-engine` corresponds to each vLLM engine's `tensor_parallel_size`. Other vLLM parameters are passed to vime with a `--vllm-` prefix (for example, `--vllm-max-model-len`).
 
 ```bash
 VLLM_ARGS=(
@@ -204,16 +204,16 @@ VLLM_ARGS=(
 
 When rollout concurrency is high, tune the vLLM scheduler via the `--vllm-` prefix—for example, `--vllm-max-num-seqs` and `--vllm-max-num-batched-tokens`. Add `--vllm-enforce-eager` for debugging or to work around CUDA graph limits.
 
-⚠️  slime uses the vLLM router to schedule multiple vLLM servers. With co-located training and inference (`--colocate`), weights are synchronized via CUDA IPC; with decoupled training and inference, the trainer synchronizes weights with vLLM engines over NCCL.
+⚠️  vime uses the vLLM router to schedule multiple vLLM servers. With co-located training and inference (`--colocate`), weights are synchronized via CUDA IPC; with decoupled training and inference, the trainer synchronizes weights with vLLM engines over NCCL.
 
 ### Dynamic Sampling
 
-slime supports more complex sampling schemes, such as the dynamic sampling in [DAPO](https://dapo-sia.github.io/). To enable dynamic sampling, you need to configure:
+vime supports more complex sampling schemes, such as the dynamic sampling in [DAPO](https://dapo-sia.github.io/). To enable dynamic sampling, you need to configure:
 
 ```bash
    --over-sampling-batch-size ${OVER_SAMPLING_BS} \
    --dynamic-sampling-filter-path \
-     slime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std \
+     vime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std \
 ```
 
 Here, `over_sampling_batch_size` needs to be greater than `rollout_batch_size`. For example, you can configure it as:
@@ -224,7 +224,7 @@ Here, `over_sampling_batch_size` needs to be greater than `rollout_batch_size`.
    --over-sampling-batch-size 64 \
 ```
 
-In this case, the sampling process will directly sample 64 prompts, with 8 samples per prompt. Since slime performs asynchronous sampling internally, we will receive the 8 responses for each prompt sequentially. Upon receiving the responses, the function specified by `dynamic_sampling_filter_path` is used for filtering. If the samples pass the filter, these 8 data points are kept; otherwise, they are discarded. The function in the example checks if the rewards for the samples are not all identical (i.e., not all correct or all incorrect):
+In this case, the sampling process will directly sample 64 prompts, with 8 samples per prompt. Since vime performs asynchronous sampling internally, we will receive the 8 responses for each prompt sequentially. Upon receiving the responses, the function specified by `dynamic_sampling_filter_path` is used for filtering. If the samples pass the filter, these 8 data points are kept; otherwise, they are discarded. The function in the example checks if the rewards for the samples are not all identical (i.e., not all correct or all incorrect):
 
 ```python
 def check_reward_nonzero_std(args, samples: list[Sample], **kwargs):
@@ -278,7 +278,7 @@ ray job submit ... \
    ...
 ```
 
-In this case, 2 GPUs will be allocated for training, and 6 GPUs will be allocated for inference. Like `--actor-num-gpus-per-node`, `--rollout-num-gpus` is a **Ray resource argument** passed to `train.py`: the framework uses it to build the placement group and assign the first bundles to training actors and the remaining bundles to rollout engines (see `slime/ray/placement_group.py`). **Under co-located mode (`--colocate`), this argument is ignored** and is set automatically to `actor_num_gpus_per_node * actor_num_nodes`. Do not put `--rollout-num-gpus` in `VLLM_ARGS`.
+In this case, 2 GPUs will be allocated for training, and 6 GPUs will be allocated for inference. Like `--actor-num-gpus-per-node`, `--rollout-num-gpus` is a **Ray resource argument** passed to `train.py`: the framework uses it to build the placement group and assign the first bundles to training actors and the remaining bundles to rollout engines (see `vime/ray/placement_group.py`). **Under co-located mode (`--colocate`), this argument is ignored** and is set automatically to `actor_num_gpus_per_node * actor_num_nodes`. Do not put `--rollout-num-gpus` in `VLLM_ARGS`.
 
 For decoupled training and inference, `VLLM_ARGS` only needs inference-backend settings, for example:
 
@@ -297,6 +297,6 @@ Add `--vllm-enforce-eager` when debugging or to work around CUDA graph limits.
 
 ### Asynchronous Training
 
-When you separate training and inference, you may notice that the training and inference GPUs are always waiting for each other. To prevent these resources from being idle, we can enable asynchronous training. This can be done by changing `train.py` to `train_async.py` in the startup script. By doing this, slime will generate data for the next rollout while training on the current one.
+When you separate training and inference, you may notice that the training and inference GPUs are always waiting for each other. To prevent these resources from being idle, we can enable asynchronous training. This can be done by changing `train.py` to `train_async.py` in the startup script. By doing this, vime will generate data for the next rollout while training on the current one.
 
 The only difference between `train.py` and `train_async.py` lies in the synchronization logic of the training loop. We achieve this by using Ray's asynchronous features (`.remote`, `ray.get`).
diff --git a/docs/en/get_started/customization.md b/docs/en/get_started/customization.md
index c913958f8..0d2016f03 100644
--- a/docs/en/get_started/customization.md
+++ b/docs/en/get_started/customization.md
@@ -1,6 +1,6 @@
 # Customization Guide
 
-slime provides extensive customization capabilities through function path arguments. These allow you to inject custom logic at various stages of the training and rollout pipeline without modifying the core codebase.
+vime provides extensive customization capabilities through function path arguments. These allow you to inject custom logic at various stages of the training and rollout pipeline without modifying the core codebase.
 
 ## Overview of Customization Interfaces
 
@@ -33,7 +33,7 @@ Below is a summary of all available customization interfaces and their purposes.
 
 ### 1. Rollout Function (`--rollout-function-path`)
 
-**Default**: `slime.rollout.vllm_rollout.generate_rollout`
+**Default**: `vime.rollout.vllm_rollout.generate_rollout`
 
 **Purpose**: Override the entire rollout generation logic.
 
@@ -127,7 +127,7 @@ class DynamicFilterOutput:
 - Implementing curriculum learning strategies
 - Quality-based sample selection
 
-**Example**: `slime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std`
+**Example**: `vime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std`
 
 ---
 
@@ -295,7 +295,6 @@ dict: {
     "rollout_routed_experts": list,       # Routed experts (for MoE)
     "metadata": list,                     # Train metadata
     "multimodal_train_inputs": list,      # Multimodal tensors (for VLM)
-    "teacher_log_probs": list,            # Teacher log probs (for distillation)
 }
 ```
 
@@ -329,11 +328,11 @@ def log_eval_rollout_data(rollout_id, args, data, extra_metrics) -> bool
 
 ### 15. Data Source (`--data-source-path`)
 
-**Default**: `slime.rollout.data_source.RolloutDataSourceWithBuffer`
+**Default**: `vime.rollout.data_source.RolloutDataSourceWithBuffer`
 
 **Purpose**: Override the data source for rollout prompts.
 
-**Base Class**: `slime.rollout.data_source.DataSource`
+**Base Class**: `vime.rollout.data_source.DataSource`
 
 **Required Methods**:
 ```python
@@ -406,11 +405,11 @@ Stabilize MoE RL training by recording and replaying expert routing decisions to
 | Argument | Description |
 | --- | --- |
 | `--use-routing-replay` | Forward-backward routing consistency in training. ([arXiv:2507.18071](https://arxiv.org/abs/2507.18071)) |
-| `--use-rollout-routing-replay` | R3: Replay routing from rollout during training. Supported by slime's default `vllm_rollout` path. ([arXiv:2510.11370](https://arxiv.org/abs/2510.11370)) |
+| `--use-rollout-routing-replay` | R3: Replay routing from rollout during training. Supported by vime's default `vllm_rollout` path. ([arXiv:2510.11370](https://arxiv.org/abs/2510.11370)) |
 
 ## Testing Custom Function Paths
 
-slime also provides CPU-only contract tests for customization interfaces. These tests resolve components through import-path strings, so they can validate both built-in hooks and user-defined implementations passed through the same CLI arguments used by training.
+vime also provides CPU-only contract tests for customization interfaces. These tests resolve components through import-path strings, so they can validate both built-in hooks and user-defined implementations passed through the same CLI arguments used by training.
 
 The tests live under `tests/plugin_contracts/` and are grouped by hook shape:
 
@@ -437,7 +436,7 @@ Each test file can also be executed directly with `python tests/plugin_contracts
 
 A dedicated `run-ci-plugin-contracts` CI label is also available. Adding it to a PR triggers all four contract test files in parallel (no GPU required).
 
-For user-defined implementations, you can either export environment variables such as `SLIME_CONTRACT_ROLLOUT_FUNCTION_PATH` and `SLIME_CONTRACT_CUSTOM_RM_PATH`, or pass overrides directly when running a test file, for example:
+For user-defined implementations, you can either export environment variables such as `VIME_CONTRACT_ROLLOUT_FUNCTION_PATH` and `VIME_CONTRACT_CUSTOM_RM_PATH`, or pass overrides directly when running a test file, for example:
 
 ```bash
 python tests/plugin_contracts/test_plugin_rollout_contracts.py \
diff --git a/docs/en/get_started/qa.md b/docs/en/get_started/qa.md
index 78611282e..53d6ab62c 100644
--- a/docs/en/get_started/qa.md
+++ b/docs/en/get_started/qa.md
@@ -39,13 +39,13 @@
 
     You can use `--num-steps-per-rollout` to determine how many steps to run per rollout. This is equivalent to setting the `global_batch_size` to `rollout_batch_size * n_samples_per_prompt // num_steps_per_rollout`.
 
-7.  **Does slime perform data packing / variable-length (varlen) processing?**
+7.  **Does vime perform data packing / variable-length (varlen) processing?**
 
-    Yes. Data packing refers to the process of concatenating samples of varying lengths during training to improve GPU utilization. slime performs this operation by default.
+    Yes. Data packing refers to the process of concatenating samples of varying lengths during training to improve GPU utilization. vime performs this operation by default.
 
 8.  **What should I do if the vLLM component shows a `Max retries exceeded with url: /health (Caused by NewConnectionError)` error?**
 
-    slime probes `GET /health` to wait for each vLLM engine to come up; this error means the readiness probe never connected. The most common cause is port conflicts when multiple vLLM engines share a single machine. A temporary workaround is to minimize the number of vLLM engines per machine, for example, by setting `tp=8`.
+    vime probes `GET /health` to wait for each vLLM engine to come up; this error means the readiness probe never connected. The most common cause is port conflicts when multiple vLLM engines share a single machine. A temporary workaround is to minimize the number of vLLM engines per machine, for example, by setting `tp=8`.
 
 9.  **My gradient norm is very high and the training crashes. What should I do?**
 
diff --git a/docs/en/get_started/quick_start.md b/docs/en/get_started/quick_start.md
index 98560198a..eceae45d9 100644
--- a/docs/en/get_started/quick_start.md
+++ b/docs/en/get_started/quick_start.md
@@ -1,15 +1,15 @@
 # Quick Start
 
 
-This document will guide you through setting up the environment and getting started with slime within one hour, covering environment configuration, data preparation, training startup, and key code analysis and modifications.
+This document will guide you through setting up the environment and getting started with vime within one hour, covering environment configuration, data preparation, training startup, and key code analysis and modifications.
 
 ## Basic Environment Setup
 
-Since slime may contain temporary patches for vllm/megatron, to avoid potential environment configuration issues, we strongly recommend **users to use our latest Docker image**, which comes pre-configured with all dependencies.
+Since vime may contain temporary patches for vllm/megatron, to avoid potential environment configuration issues, we strongly recommend **users to use our latest Docker image**, which comes pre-configured with all dependencies.
 
 ### Hardware Support
 
-**slime** supports multiple NVIDIA GPU hardware platforms:
+**vime** supports multiple NVIDIA GPU hardware platforms:
 
 - **B200 Series**: Fully supported with identical setup steps as H-series GPUs
 - **H-Series (H100/H200)**: Official support with comprehensive CI testing and stable performance
@@ -20,7 +20,7 @@ Since slime may contain temporary patches for vllm/megatron, to avoid potential
 - B-series basic functionality is stable and suitable for development/testing, but currently lacks CI protection
 - Both hardware platforms use identical installation and startup procedures
 
-- For scenarios where Docker is not convenient, please refer to [build_conda.sh](https://github.com/THUDM/slime/blob/main/build_conda.sh).
+- For scenarios where Docker is not convenient, please refer to [build_conda.sh](https://github.com/vllm-project/vime/blob/main/build_conda.sh).
 
 ### Pull and Start Docker Container
 
@@ -36,13 +36,13 @@ docker run --rm --gpus all --ipc=host --shm-size=16g \
   -it inferactinc/public:vime-vllm-cu129-latest /bin/bash
 ```
 
-### Install slime
+### Install vime
 
-slime is already installed in the docker image. To update to the latest verison, please execute the following command:
+vime is already installed in the docker image. To update to the latest verison, please execute the following command:
 
 ```bash
 # Path can be adjusted according to actual situation
-cd /root/slime
+cd /root/vime
 git pull
 pip install -e . --no-deps
 ```
@@ -52,7 +52,7 @@ pip install -e . --no-deps
 You can download required models and datasets from platforms like Hugging Face, ModelScope, etc. Here are the commands to download example resources using `huggingface_hub`:
 
 ```bash
-# Download model weights (GLM-Z1-9B)
+# Download model weights (Qwen3-4B)
 hf download zai-org/Qwen3-4B --local-dir /root/Qwen3-4B
 
 # Download training dataset (dapo-math-17k)
@@ -70,10 +70,10 @@ hf download --repo-type dataset zhuzilin/aime-2024 \
 
 When using Megatron as the training backend, you need to first convert Hugging Face format model weights to Megatron `torch_dist` format.
 
-First, load the configuration file of the target model. The `slime/scripts/models` directory contains configuration files for supported models. You need to `source` the corresponding model script to load the configuration parameters into the current environment. Here we use Qwen3-4B model as an example.
+First, load the configuration file of the target model. The `vime/scripts/models` directory contains configuration files for supported models. You need to `source` the corresponding model script to load the configuration parameters into the current environment. Here we use Qwen3-4B model as an example.
 
 ```bash
-cd /root/slime
+cd /root/vime
 source scripts/models/qwen3-4B.sh
 ```
 
@@ -108,7 +108,7 @@ Note that as Megatron will do padding to embedding for better performance, it ma
 After completing the above preparation work, you can run the training script.
 
 ```bash
-cd /root/slime
+cd /root/vime
 bash scripts/run-qwen3-4B.sh
 ```
 
@@ -140,9 +140,9 @@ CKPT_ARGS=(
    --ref-load /root/Qwen3-4B_torch_dist
    # Actor model loading path. Should typically match --save for checkpoint resumption
    # If empty or doesn't contain a valid checkpoint, loads from --ref-load instead
-   --load /root/Qwen3-4B_slime/
+   --load /root/Qwen3-4B_vime/
    # Model save path during training
-   --save /root/Qwen3-4B_slime/
+   --save /root/Qwen3-4B_vime/
    # Model save interval (steps)
    --save-interval 20
 )
@@ -169,7 +169,7 @@ The entire training process can be viewed as a closed loop of **"Data Sampling 
 In this process, the "output" and "consumption" of each round must be equal, following this constraint:
 **`(rollout-batch-size × n-samples-per-prompt) = (global-batch-size × num-steps-per-rollout)`**
 
-- In slime, if `--num-steps-per-rollout` is set, `--global-batch-size` will be automatically set if not set, and if set, it will be validated using the above formula.
+- In vime, if `--num-steps-per-rollout` is set, `--global-batch-size` will be automatically set if not set, and if set, it will be validated using the above formula.
 
 **Training Process Count Control**
 - `--num-rollout`: Controls the **total number of execution rounds** of the entire **"sampling→training"** loop.
@@ -185,7 +185,7 @@ ROLLOUT_ARGS=(
    # Whether to shuffle data in Rollout phase
    --rollout-shuffle
 
-   # Reward Model type. slime has built-in multiple types, also supports custom through --custom-rm-path
+   # Reward Model type. vime has built-in multiple types, also supports custom through --custom-rm-path
    --rm-type deepscaler
 
    # These five parameters control the relationship between rollout and train
@@ -225,13 +225,13 @@ EVAL_ARGS=(
 
 ### PERF_ARGS: Performance and Parallelism Parameters
 
-This part mainly contains Megatron's parallel configuration. `--use-dynamic-batch-size` and `--max-tokens-per-gpu` are slime-specific optimizations.
+This part mainly contains Megatron's parallel configuration. `--use-dynamic-batch-size` and `--max-tokens-per-gpu` are vime-specific optimizations.
 
 - `--max-tokens-per-gpu`: Maximum number of tokens processed per GPU. After enabling dynamic batching (`use_dynamic_batch_size`), the system will intelligently pack samples of varying lengths so that the total token count of each micro-batch approaches this limit, thereby improving training efficiency. If a single sample length exceeds this value, it will form an independent batch. In context parallel (CP) mode, `N` CP cards share the total length of `N * max_tokens_per_gpu`.
 - `--use-dynamic-batch-size`: Enable dynamic batching. At this time, `--micro-batch-size` will be ignored.
 
 > 💡 **Tip**:
-> slime always trains models through data packing methods and strictly ensures that per sample loss or per token loss is correct. Therefore, enabling dynamic batch size will not affect loss calculation, and it is strongly recommended to enable it.
+> vime always trains models through data packing methods and strictly ensures that per sample loss or per token loss is correct. Therefore, enabling dynamic batch size will not affect loss calculation, and it is strongly recommended to enable it.
 
 ```bash
 PERF_ARGS=(
@@ -268,8 +268,8 @@ GRPO_ARGS=(
 )
 ```
 
-- `--advantage-estimator`: In addition to [GRPO](https://arxiv.org/abs/2402.03300), slime also supports several other training algorithms, such as [GSPO](https://arxiv.org/abs/2507.18071), [Reinforce++](https://arxiv.org/abs/2501.03262) and [Reinforce++ Baseline](https://arxiv.org/abs/2501.03262), and [PPO](https://arxiv.org/abs/1707.06347).
-- `--calculate-per-token-loss`: By default, slime calculates the loss on a per-sample basis, i.e., `mean(sum(sample_i) / len(sample_i))`. To calculate the loss on a per-token basis, i.e., `sum(sum(sample_i)) / sum(len(sample_i))`, you can enable this flag.
+- `--advantage-estimator`: In addition to [GRPO](https://arxiv.org/abs/2402.03300), vime also supports several other training algorithms, such as [GSPO](https://arxiv.org/abs/2507.18071), [Reinforce++](https://arxiv.org/abs/2501.03262) and [Reinforce++ Baseline](https://arxiv.org/abs/2501.03262), and [PPO](https://arxiv.org/abs/1707.06347).
+- `--calculate-per-token-loss`: By default, vime calculates the loss on a per-sample basis, i.e., `mean(sum(sample_i) / len(sample_i))`. To calculate the loss on a per-token basis, i.e., `sum(sum(sample_i)) / sum(len(sample_i))`, you can enable this flag.
 - `--use-tis`: Enable this setting to use TIS (Truncated Importance Sampling), which is introduced by this [blog](https://fengyao.notion.site/off-policy-rl).
 
 ### OPTIMIZER_ARGS: Optimizer Parameters
@@ -289,10 +289,10 @@ OPTIMIZER_ARGS=(
 
 This part of parameters is used to configure the vLLM inference service.
 - `--rollout-num-gpus-per-engine`: Equivalent to vLLM's `tp_size`.
-- Other vLLM parameters can be passed to slime by adding the `--vllm-` prefix, and slime will automatically forward them to vLLM. For example, to set vLLM's `--log-level INFO` parameter, just use `--vllm-log-level INFO`.
+- Other vLLM parameters can be passed to vime by adding the `--vllm-` prefix, and vime will automatically forward them to vLLM. For example, to set vLLM's `--log-level INFO` parameter, just use `--vllm-log-level INFO`.
 
 > ⚠️ **Note**:
-> slime uses `vllm-router` to schedule multiple vLLM engines. `dp_size` is calculated through `rollout-num-gpus / rollout-num-gpus-per-engine`.
+> vime uses `vllm-router` to schedule multiple vLLM engines. `dp_size` is calculated through `rollout-num-gpus / rollout-num-gpus-per-engine`.
 
 ```bash
 VLLM_ARGS=(
@@ -335,12 +335,12 @@ At this time, training and inference will share all 8 GPUs.
 
 ### Dynamic Sampling
 
-slime supports more complex sampling strategies, such as dynamic sampling used in [DAPO](https://dapo-sia.github.io/). To enable this feature, you need to configure the following parameters:
+vime supports more complex sampling strategies, such as dynamic sampling used in [DAPO](https://dapo-sia.github.io/). To enable this feature, you need to configure the following parameters:
 
 ```bash
    --over-sampling-batch-size 64 \
    --dynamic-sampling-filter-path \
-     slime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std
+     vime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std
 ```
 
 Here `over_sampling_batch_size` needs to be greater than `rollout_batch_size`, for example, configured as:
@@ -351,7 +351,7 @@ Here `over_sampling_batch_size` needs to be greater than `rollout_batch_size`, f
    --over-sampling-batch-size 64 \
 ```
 
-Then each sampling will directly sample 64 prompts, and each prompt will be sampled 8 times. Because slime performs asynchronous sampling internally, we will successively obtain 8 responses for each prompt. When receiving responses, the function corresponding to `dynamic_sampling_filter_path` will be used for filtering. If it passes, these 8 pieces of data will be kept; otherwise, they will be discarded.
+Then each sampling will directly sample 64 prompts, and each prompt will be sampled 8 times. Because vime performs asynchronous sampling internally, we will successively obtain 8 responses for each prompt. When receiving responses, the function corresponding to `dynamic_sampling_filter_path` will be used for filtering. If it passes, these 8 pieces of data will be kept; otherwise, they will be discarded.
 
 The filtering function `check_reward_nonzero_std` in the example will check whether the standard deviation of rewards for a group of samples is greater than zero, ensuring that the reward scores of each group of samples left have differences, thereby avoiding overly homogeneous data and improving data diversity.
 
@@ -386,39 +386,17 @@ That is, take out the first `num_samples` prompts corresponding to `num_samples
 > 💡 **Tip**:
 > The `sample.metadata` of each partial rollout sample stores the rollout id of the first generation, which can be used for data filtering.
 
-### bf16 Training fp8 Inference
-
-slime directly supports bf16 training and fp8 inference. For Qwen3-4B model, you only need to download the following model:
-
-```bash
-hf download Qwen/Qwen3-4B-FP8 --local-dir /root/Qwen3-4B-FP8
-```
-
-And replace `--hf-checkpoint` with:
-
-```bash
-   # Used to load tokenizer and other information, actually won't use model weight parameters from hf path
-   --hf-checkpoint /root/Qwen3-4B-FP8
-
-   # The megatron checkpoint still needs to be the dist weights converted from bf16 huggingface at the beginning, not modified because of FP8 rollout.
-   --ref-load /root/Qwen3-4B_torch_dist
-```
-
-This will trigger fp8 inference. Currently, we will directly cast bf16 weights to fp8, and we will gradually add quantization schemes with less impact on accuracy in the future.
-
-⚠️ The training megatron checkpoint still needs to be the one converted from bf16 huggingface at the beginning.
-
 ## Multiturn Adaptation
 
-The slime framework is highly extensible and supports complex Agent scenarios (such as multi-turn interaction and tool calling). Its core mechanism is to rewrite the default data generation (Rollout) and reward calculation (Reward) logic through custom functions.
+The vime framework is highly extensible and supports complex Agent scenarios (such as multi-turn interaction and tool calling). Its core mechanism is to rewrite the default data generation (Rollout) and reward calculation (Reward) logic through custom functions.
 
-This section uses an implementation based on [Search-R1](https://github.com/PeterGriffinJin/Search-R1) as an example to illustrate how to adapt slime to support multi-turn interaction.
+This section uses an implementation based on [Search-R1](https://github.com/PeterGriffinJin/Search-R1) as an example to illustrate how to adapt vime to support multi-turn interaction.
 
 ### Adaptation Strategy Summary
 
-Adapting slime to support multi-turn interaction mainly includes three steps:
+Adapting vime to support multi-turn interaction mainly includes three steps:
 
-1. **Data Preparation**: Adapt the multi-turn interaction dataset to slime's `Sample` objects. Map conversation history, real labels, etc. to `prompt` and `label` fields, and store additional information such as tool definitions and intermediate states in the `metadata` field for subsequent function calls.
+1. **Data Preparation**: Adapt the multi-turn interaction dataset to vime's `Sample` objects. Map conversation history, real labels, etc. to `prompt` and `label` fields, and store additional information such as tool definitions and intermediate states in the `metadata` field for subsequent function calls.
 
 2. **Implement Custom Generation Function**: Write functions to simulate the interaction loop of "model generates action → executes tool → concatenates observation results", and correctly handle Loss Masking.
 
@@ -446,7 +424,7 @@ You need to convert it to:
 
 ### Step Two: Specify Mapping in Training Script
 
-After completing data preparation, in the training script, map this preprocessed `metadata` column to slime's `Sample.metadata` field through `ROLLOUT_ARGS`.
+After completing data preparation, in the training script, map this preprocessed `metadata` column to vime's `Sample.metadata` field through `ROLLOUT_ARGS`.
 
 ```bash
 ROLLOUT_ARGS=(
@@ -460,7 +438,7 @@ ROLLOUT_ARGS=(
    --label-key final_answer
 
    # 4. Load the pre-constructed "metadata" column into Sample.metadata
-   #    slime will automatically parse it as a Python dictionary
+   #    vime will automatically parse it as a Python dictionary
    --metadata-key metadata
 )
 ```
@@ -564,18 +542,18 @@ ray job submit --address="http://127.0.0.1:8265" \
      }
    }' \
    -- python3 train.py \
-   --... # Other Megatron/vLLM/slime arguments
+   --... # Other Megatron/vLLM/vime arguments
 ```
 
 Optionally, the following environment variables may be needed based on your environment. For example, when there are multiple IPs and the wrong one is chosen in a Docker or SLURM envionment. We provide an example used in a SLURM + enroot multi-node system as follows:
 
 ```
-export SLIME_HOST_IP=$(hostname -I | awk '{print $1}')
+export VIME_HOST_IP=$(hostname -I | awk '{print $1}')
 export GLOO_SOCKET_IFNAME=$(ip -o -4 addr show | awk '$4 ~ /^10\\./ {print $2}')
 export NCCL_SOCKET_IFNAME=$(ip -o -4 addr show | awk '$4 ~ /^10\\./ {print $2}')
 export NVSHMEM_BOOTSTRAP_UID_SOCK_IFNAME=$(ip -o -4 addr show | awk '$4 ~ /^10\./ {print $2}')
 ```
 
-slime has been deeply optimized for distributed training of large-scale Mixture of Experts (MoE) models. We provide an end-to-end training case for reference:
+vime has been deeply optimized for distributed training of large-scale Mixture of Experts (MoE) models. We provide some end-to-end training cases for reference:
 
 - [Example: Qwen3-30B-A3B with 8xH100](../examples/qwen3-30B-A3B.md)
diff --git a/docs/en/get_started/usage.md b/docs/en/get_started/usage.md
index 4afa17588..84fafe43f 100644
--- a/docs/en/get_started/usage.md
+++ b/docs/en/get_started/usage.md
@@ -1,9 +1,9 @@
 # Usage Guide
 
 
-## Introduction to slime Parameters
+## Introduction to vime Parameters
 
-When using slime, parameters are primarily passed for the following purposes:
+When using vime, parameters are primarily passed for the following purposes:
 
 1.  To allocate a portion of the GPUs in the cluster for training and another portion for inference.
 2.  To load Megatron for the training portion.
@@ -27,11 +27,11 @@ For co-located training and inference, you also need to configure:
 
   - `--colocate`: Enables co-located training and inference. When enabled, it ignores `--rollout-num-gpus` and makes the number of GPUs for training and inference equal.
 
-Additionally, slime supports Prefill and Decode disaggregation (PD Disaggregation). You can set the number of servers used for Prefill by setting the `--prefill-num-servers` argument.
+Additionally, vime supports Prefill and Decode disaggregation (PD Disaggregation). You can set the number of servers used for Prefill by setting the `--prefill-num-servers` argument.
 
 ### Choosing Training Backend
 
-slime supports multiple training backends, which can be selected via the `--train-backend` parameter:
+vime supports multiple training backends, which can be selected via the `--train-backend` parameter:
 
 - `megatron` (default): Uses Megatron-LM as the training backend, supporting efficient training of large-scale models.
 
@@ -45,7 +45,7 @@ Generally, we need to perform three preparatory steps:
   - Configure parallelism and other optimizations.
   - Configure the checkpoint to be loaded.
 
-For details on some of Megatron's customizations and the principles behind how slime incorporates Megatron, please see the "How to Use Megatron" section.
+For details on some of Megatron's customizations and the principles behind how vime incorporates Megatron, please see the "How to Use Megatron" section.
 
 #### Configuring Model Parameters
 
@@ -78,8 +78,8 @@ We provide configurations for common models in [scripts/models](../../../scripts
 
 Note:
 
-  - slime will load all parameters of Megatron found in the `PYTHONPATH`, so you can find parameters and their descriptions within the Megatron in your environment.
-  - slime uses data packing (also known as varlen or thd) for training. There is no need to configure `--seq-length` or `--max-positional-embedding`, as these parameters do not affect the maximum context length of the trained model.
+  - vime will load all parameters of Megatron found in the `PYTHONPATH`, so you can find parameters and their descriptions within the Megatron in your environment.
+  - vime uses data packing (also known as varlen or thd) for training. There is no need to configure `--seq-length` or `--max-positional-embedding`, as these parameters do not affect the maximum context length of the trained model.
 
 #### Setting Up Parallelism and Recomputation
 
@@ -124,7 +124,7 @@ In terms of storage structure, a Megatron checkpoint typically looks like this,
 
 The `latest_checkpointed_iteration.txt` file records the latest training step. When loading a model, you should not directly pass `/ckpt/iter_xxxxxxx`, but rather pass `/ckpt/` and use `--ckpt-step` to select the corresponding training step (if `--ckpt-step` is not used, the step will be read from `latest_checkpointed_iteration.txt`).
 
-When using slime, there are three parameters for loading and saving checkpoints:
+When using vime, there are three parameters for loading and saving checkpoints:
 
   - `--ref-load`: The Megatron checkpoint for the reference model.
   - `--load`: The Megatron checkpoint for the actor. If `--load` is not set, or if the specified directory does not exist or does not contain `latest_checkpointed_iteration.txt`, the actor will be initialized from the `--ref-load` checkpoint.
@@ -142,16 +142,16 @@ Loading vLLM is very simple. You only need:
 
 Note:
 
-  - Before the first training step, slime will synchronize the parameters from Megatron to vLLM. Therefore, the `--hf-checkpoint` does not need to contain the latest training parameters, and you do not need to change the HF checkpoint when resuming training.
+  - Before the first training step, vime will synchronize the parameters from Megatron to vLLM. Therefore, the `--hf-checkpoint` does not need to contain the latest training parameters, and you do not need to change the HF checkpoint when resuming training.
   - By default, vLLM reads the maximum context length from the `config.json` in the Hugging Face checkpoint. You can use the `--vllm-max-model-len` parameter to override this value to support longer inference.
   - During co-located training and inference, although Megatron and vLLM will offload sequentially, they still need to leave some memory for each other. You need to adjust vLLM's total VRAM usage by reducing `--vllm-gpu-memory-utilization`.
-  - slime supports passing through vllm-router parameters by adding a `router` prefix to the original parameter name. For example, vllm-router's `--balance-abs-threshold` parameter should be set as `--router-balance-abs-threshold`. Since vllm-router uses cache-aware routing by default, it may cause uneven request distribution. You can set `--router-balance-abs-threshold 0` to force balanced distribution, but this may affect prefix cache hit rate in multi-turn conversation scenarios.
+  - vime supports passing through vllm-router parameters by adding a `router` prefix to the original parameter name. For example, vllm-router's `--balance-abs-threshold` parameter should be set as `--router-balance-abs-threshold`. Since vllm-router uses cache-aware routing by default, it may cause uneven request distribution. You can set `--router-balance-abs-threshold 0` to force balanced distribution, but this may affect prefix cache hit rate in multi-turn conversation scenarios.
 
-For details on some of vLLM's customizations and the principles behind how slime incorporates vLLM, please see the "How to Use vLLM" section.
+For details on some of vLLM's customizations and the principles behind how vime incorporates vLLM, please see the "How to Use vLLM" section.
 
 ### Data Format
 
-Currently, slime only supports loading files in `.jsonl` format, where each line of the file is a JSON object. An example of a single data entry (expanded) is as follows:
+Currently, vime only supports loading files in `.jsonl` format, where each line of the file is a JSON object. An example of a single data entry (expanded) is as follows:
 
 ```json
 {
@@ -174,8 +174,8 @@ This corresponds to the following configuration:
   --apply-chat-template
 ```
 
-Please note that the `step_loss_mask` (default=1) here is for SFT phase. If it is set to 0, the turn will not contibute to the final loss; if it is set to 1, slime will use the normal `loss_mask`.
-Additionally, we provide a `metadata_key`, which defaults to `"metadata"`. When read, slime will load the metadata from the data, which can be helpful for custom data generation or creating custom reward models.
+Please note that the `step_loss_mask` (default=1) here is for SFT phase. If it is set to 0, the turn will not contibute to the final loss; if it is set to 1, vime will use the normal `loss_mask`.
+Additionally, we provide a `metadata_key`, which defaults to `"metadata"`. When read, vime will load the metadata from the data, which can be helpful for custom data generation or creating custom reward models.
 
 ### Hyperparameters for RL Training
 
@@ -184,9 +184,7 @@ Additionally, we provide a `metadata_key`, which defaults to `"metadata"`. When
     - `gspo` ([https://arxiv.org/abs/2507.18071](https://arxiv.org/abs/2507.18071))
     - `reinforce_plus_plus` and `reinforce_plus_plus_baseline` ([https://arxiv.org/abs/2501.03262](https://arxiv.org/abs/2501.03262))
     - `ppo` ([https://arxiv.org/abs/1707.06347](https://arxiv.org/abs/1707.06347))
-
-  Note: On-policy distillation (OPD) is now orthogonal to the advantage estimator. Use `--use-opd` and `--opd-kl-coef` to enable OPD on top of any estimator.
-- `--calculate-per-token-loss`: By default, slime calculates loss on a per-sample basis, i.e., `mean(sum(sample_i) / len(sample_i))`. Enable this flag to calculate loss on a per-token basis, i.e., `sum(sum(sample_i)) / sum(len(sample_i))`.
+- `--calculate-per-token-loss`: By default, vime calculates loss on a per-sample basis, i.e., `mean(sum(sample_i) / len(sample_i))`. Enable this flag to calculate loss on a per-token basis, i.e., `sum(sum(sample_i)) / sum(len(sample_i))`.
 - `--use-tis`: Enable this setting to use TIS (Truncated Importance Sampling) (https://fengyao.notion.site/off-policy-rl).
 
 #### GRPO Algorithm
@@ -275,9 +273,9 @@ megatron:
 
 ## Custom Rollout Function
 
-slime supports customizing data generation (rollout) to various degrees.
+vime supports customizing data generation (rollout) to various degrees.
 
-  - By default, it uses the `generate_rollout` function from [slime/rollout/vllm_rollout.py](https://github.com/vllm-project/vime/blob/main/slime/rollout/vllm_rollout.py) for data generation. This file implements an asynchronous (asyncio) data generation flow based on vLLM and supports features like dynamic sampling and partial rollout.
+  - By default, it uses the `generate_rollout` function from [vime/rollout/vllm_rollout.py](https://github.com/vllm-project/vime/blob/main/vime/rollout/vllm_rollout.py) for data generation. This file implements an asynchronous (asyncio) data generation flow based on vLLM and supports features like dynamic sampling and partial rollout.
 
   - You can completely replace the default `generate_rollout` by using the `--rollout-function-path` parameter. You just need to ensure that the function signature passed via `--rollout-function-path` is as follows:
 
@@ -299,15 +297,15 @@ slime supports customizing data generation (rollout) to various degrees.
 
     Where:
 
-      - `args`: The complete arguments used for the slime run.
+      - `args`: The complete arguments used for the vime run.
 
       - `rollout_id`: The ID of the current data generation round, used to ensure data order when resuming training.
 
-      - `data_source`: A globally unique data source in slime, which can be used to get initial prompts, data IDs, and store partially generated samples for later use.
+      - `data_source`: A globally unique data source in vime, which can be used to get initial prompts, data IDs, and store partially generated samples for later use.
 
       - `evaluation`: A boolean indicating if the rollout is for evaluation. You can configure a separate evaluation function using `--eval-function-path`.
 
-      - The returned `Sample` type is defined in [slime/utils/types.py](https://github.com/THUDM/slime/blob/main/slime/utils/types.py). When implementing, you need to ensure the following fields are correctly set:
+      - The returned `Sample` type is defined in [vime/utils/types.py](https://github.com/vllm-project/vime/blob/main/vime/utils/types.py). When implementing, you need to ensure the following fields are correctly set:
 
           - `tokens`: The tokens for the prompt + response.
           - `response_length`: The total length of the response. For multi-turn tasks, this is the length of the tokens remaining after the first-turn prompt.
@@ -352,36 +350,36 @@ slime supports customizing data generation (rollout) to various degrees.
         return sample
     ```
 
-    For a more complete version, please refer to [slime/rollout/vllm_rollout.py](https://github.com/vllm-project/vime/blob/main/slime/rollout/vllm_rollout.py).
+    For a more complete version, please refer to [vime/rollout/vllm_rollout.py](https://github.com/vllm-project/vime/blob/main/vime/rollout/vllm_rollout.py).
 
   - Sometimes, you may also need to support a custom reward model. This can be configured by setting `--custom-rm-path`.
 
 ## How to Use vLLM
 
-slime runs vLLM in server mode and talks to it over HTTP.
+vime runs vLLM in server mode and talks to it over HTTP.
 
 ### Parameter Configuration
 
-slime incorporates almost all vLLM parameters by forwarding vLLM's `EngineArgs` CLI flags. When setting a vLLM parameter, you need to add the `--vllm-` prefix. For example:
+vime incorporates almost all vLLM parameters by forwarding vLLM's `EngineArgs` CLI flags. When setting a vLLM parameter, you need to add the `--vllm-` prefix. For example:
 
   - In co-located training and inference, you often need to limit GPU memory utilization. Pass it as `--vllm-gpu-memory-utilization`.
-  - During training, if you want vLLM to infer beyond the maximum context length specified in the Hugging Face checkpoint's `config.json`, you need to use `--max-model-len`, which becomes `--vllm-max-model-len` in slime.
+  - During training, if you want vLLM to infer beyond the maximum context length specified in the Hugging Face checkpoint's `config.json`, you need to use `--max-model-len`, which becomes `--vllm-max-model-len` in vime.
   - For multi-node large EP inference, you might need `--enable-expert-parallel`, `--data-parallel-size`, etc. These can be passed as `--vllm-enable-expert-parallel` and `--vllm-data-parallel-size` respectively.
 
-Some parameters related to slime's resource scheduling are configured by slime itself, for example:
+Some parameters related to vime's resource scheduling are configured by vime itself, for example:
 
-  - `--tensor-parallel-size` in slime is set using `--rollout-num-gpus-per-engine`.
-  - `--model` in slime is set using `--hf-checkpoint`.
+  - `--tensor-parallel-size` in vime is set using `--rollout-num-gpus-per-engine`.
+  - `--model` in vime is set using `--hf-checkpoint`.
 
-The way vLLM parameters are integrated into slime can be found in [slime/backends/vllm_utils/arguments.py](https://github.com/vllm-project/vime/blob/main/slime/backends/vllm_utils/arguments.py).
+The way vLLM parameters are integrated into vime can be found in [vime/backends/vllm_utils/arguments.py](https://github.com/vllm-project/vime/blob/main/vime/backends/vllm_utils/arguments.py).
 
 ### How to Use the Router
 
-slime uses [vllm-router](https://github.com/vllm-project/router) to manage the vLLM engines during the training process. You can configure the address of the router using `--vllm-router-ip` and `--vllm-router-port`. If not configured, a router will be started by default within the cluster.
+vime uses [vllm-router](https://github.com/vllm-project/router) to manage the vLLM engines during the training process. You can configure the address of the router using `--vllm-router-ip` and `--vllm-router-port`. If not configured, a router will be started by default within the cluster.
 
 After starting, all vLLM engines will register with the router. When actually generating data, you only need to send HTTP requests to the router, which will perform load balancing and forward the requests to the engines.
 
-When you configure an external router using `--vllm-router-ip` and `--vllm-router-port`, slime will not start an internal router. Instead, it will register all its engines with this external router. You can then use this external router's address to implement more complex data generation workflows. Note that the router supports OpenAI-compatible APIs.
+When you configure an external router using `--vllm-router-ip` and `--vllm-router-port`, vime will not start an internal router. Instead, it will register all its engines with this external router. You can then use this external router's address to implement more complex data generation workflows. Note that the router supports OpenAI-compatible APIs.
 
 ### Advanced Engine Configuration (--vllm-config)
 
@@ -406,7 +404,7 @@ vllm:
         num_gpus_per_engine: 2
 ```
 
-Each model gets its own router. The per-model router info is accessible via `args.vllm_model_routers` (a dict mapping model name to `(ip, port)` tuples). Custom rollout functions can use `get_model_url(args, "ref")` from `slime.rollout.vllm_rollout` to route requests to a specific model.
+Each model gets its own router. The per-model router info is accessible via `args.vllm_model_routers` (a dict mapping model name to `(ip, port)` tuples). Custom rollout functions can use `get_model_url(args, "ref")` from `vime.rollout.vllm_rollout` to route requests to a specific model.
 
 **Server group features:**
 - `worker_type`: `regular`, `prefill`, `decode`, or `placeholder` (reserves GPU slots without creating engines)
@@ -415,11 +413,11 @@ Each model gets its own router. The per-model router info is accessible via `arg
 
 ## How to Use Megatron
 
-slime supports different and lightly modified versions of Megatron by reusing common functions from the `megatron.training` directory, such as `parse_args`, `save_checkpoint`, and `load_checkpoint`. Therefore, when using it, you must ensure that Megatron is accessible in the `PYTHONPATH`, for example, by adding `export PYTHONPATH=/root/Megatron-LM` at runtime.
+vime supports different and lightly modified versions of Megatron by reusing common functions from the `megatron.training` directory, such as `parse_args`, `save_checkpoint`, and `load_checkpoint`. Therefore, when using it, you must ensure that Megatron is accessible in the `PYTHONPATH`, for example, by adding `export PYTHONPATH=/root/Megatron-LM` at runtime.
 
 ### Parameter Configuration
 
-slime directly imports all parameters of the Megatron in the current environment by using `from megatron.training.arguments import parse_args`. If the version of Megatron you are using has parameters defined outside of `parse_args`, you can configure them by passing them in, similar to how it's done in [train.py](https://github.com/THUDM/slime/blob/main/train.py), for example:
+vime directly imports all parameters of the Megatron in the current environment by using `from megatron.training.arguments import parse_args`. If the version of Megatron you are using has parameters defined outside of `parse_args`, you can configure them by passing them in, similar to how it's done in [train.py](https://github.com/vllm-project/vime/blob/main/train.py), for example:
 
 ```python
 if __name__ == "__main__":
diff --git a/docs/en/index.rst b/docs/en/index.rst
index b63632636..c78aa0753 100644
--- a/docs/en/index.rst
+++ b/docs/en/index.rst
@@ -1,12 +1,12 @@
-slime Documentation
+vime Documentation
 ====================
 
-slime is an LLM post-training framework for RL scaling, providing two core capabilities:
+vime is an LLM post-training framework for RL scaling, providing two core capabilities:
 
 - High-Performance Training: Supports efficient training in various modes by connecting Megatron with vLLM;
 - Flexible Data Generation: Enables arbitrary training data generation workflows through custom data generation interfaces and server-based engines.
 
-slime is the RL-framework behind GLM-4.7, GLM-4.6 and GLM-4.5. Apart from models from Z.ai, we also supports the following models:
+vime is the RL-framework behind GLM-4.7, GLM-4.6 and GLM-4.5. Apart from models from Z.ai, we also supports the following models:
 
 - Qwen3 series (Qwen3Next, Qwen3MoE, Qwen3), Qwen2.5 series;
 - DeepSeek V3 series (DeepSeek V3, V3.1, DeepSeek R1);
diff --git a/docs/zh/advanced/arch-support-beyond-megatron.md b/docs/zh/advanced/arch-support-beyond-megatron.md
index 9d116a2ff..a749e7208 100644
--- a/docs/zh/advanced/arch-support-beyond-megatron.md
+++ b/docs/zh/advanced/arch-support-beyond-megatron.md
@@ -2,7 +2,7 @@
 
 Megatron-LM 框架虽然并行效率高，但在支持日新月异的新模型架构（如 Qwen3Next）时，其灵活性有所欠缺。若要原生支持这些模型的特殊结构（例如 Gated-Delta-Net），往往需要对 Megatron 的核心代码进行侵入性较大、开发周期较长的改造。
 
-为了能快速跟进这些前沿模型，`slime` 提出了一种更敏捷的方案：**与其深度改造 Megatron，不如直接引入并封装模型官方的 HuggingFace 实现**，将其作为一个“黑盒模块”无缝嵌入到 Megatron 的并行训练流程中。
+为了能快速跟进这些前沿模型，`vime` 提出了一种更敏捷的方案：**与其深度改造 Megatron，不如直接引入并封装模型官方的 HuggingFace 实现**，将其作为一个“黑盒模块”无缝嵌入到 Megatron 的并行训练流程中。
 
 本文以 Qwen3Next 80B-A3B 为例，介绍这一实现思路。
 
@@ -10,20 +10,20 @@ Megatron-LM 框架虽然并行效率高，但在支持日新月异的新模型
 
 Megatron 的模型实例化分为两步：首先根据配置生成“层规格”（`ModuleSpec`），再依据该规格实例化具体的 PyTorch 模块。
 
-`slime` 正是利用这一机制，在**生成 Spec 的阶段“劫持”并替换掉 Megatron 的原生模块**，从而将外部实现（此处为 HuggingFace 模块）无缝嵌入。这一过程主要涉及三个核心组件的协同：
+`vime` 正是利用这一机制，在**生成 Spec 的阶段“劫持”并替换掉 Megatron 的原生模块**，从而将外部实现（此处为 HuggingFace 模块）无缝嵌入。这一过程主要涉及三个核心组件的协同：
 
 1.  **替换 Megatron 模块规格 (Spec)**
     这是整个方案的入口。我们通过一个自定义函数（例如 `get_qwen3_next_spec`）来修改标准的 `ModuleSpec`，用我们自己的封装层换掉 Megatron 的原生 Attention 层。
     * **具体操作**：获取标准的 Decoder Block Spec，将其 `self_attention` 字段指向我们的自定义模块，并按需开启 `qk_layernorm` 等模型特有配置。
-    * **对应文件**: `slime_plugins/models/qwen3_next.py`
+    * **对应文件**: `vime_plugins/models/qwen3_next.py`
 
 2.  **封装 HuggingFace 实现**
     上一步的 Spec 会指向一个封装层，例如 `HuggingfaceAttention`。它继承了 Megatron 的 `MegatronModule`，核心职责是作为桥梁，处理好并行策略所需的数据对齐（如序列并行），然后在内部直接调用从 HuggingFace 加载的原生 `Qwen3NextAttention` 模块。
-    * **对应文件**: `slime_plugins/models/hf_attention.py`
+    * **对应文件**: `vime_plugins/models/hf_attention.py`
 
 3.  **对齐模型权重**
     模型结构跑通后，还需要确保权重能正确加载。我们借助 [mbridge](https://github.com/ISEEKYAN/mbridge) 库，通过 `Qwen3NextBridge` 建立了 HuggingFace Checkpoint 与 Megatron 参数之间的命名映射关系，实现双向互通。
-    * **对应文件**: `slime_plugins/mbridge/qwen3_next.py`
+    * **对应文件**: `vime_plugins/mbridge/qwen3_next.py`
 
 通过这三层协同，我们成功地将一个 Megatron 原本不支持的复杂模型结构（以其 HuggingFace 实现为载体），运行在了 Megatron 的并行框架之上，并完整保留了模型并行、MoE 加速、流水线调度等全部关键能力。
 
diff --git a/docs/zh/advanced/fault-tolerance.md b/docs/zh/advanced/fault-tolerance.md
index 0dd79efd1..30f247009 100644
--- a/docs/zh/advanced/fault-tolerance.md
+++ b/docs/zh/advanced/fault-tolerance.md
@@ -1,12 +1,12 @@
 # 容灾
 
-为了保证长期稳定的 RL 训练，slime 会默认开始一定程度的容灾机制。这里主要介绍一下 slime 中容灾的一些设计思路。
+为了保证长期稳定的 RL 训练，vime 会默认开始一定程度的容灾机制。这里主要介绍一下 vime 中容灾的一些设计思路。
 
 可以通过 `--use-fault-tolerance` 开启容灾机制。
 
 ## rollout 容灾
 
-slime 会在 rollout 过程中，定期向所有 vLLM 引擎发送心跳请求（`/health`），如果心跳超时，则会停止这个 vLLM 引擎。并在这轮 rollout 完成之后进行重启和正确的参数更新。
+vime 会在 rollout 过程中，定期向所有 vLLM 引擎发送心跳请求（`/health`），如果心跳超时，则会停止这个 vLLM 引擎。并在这轮 rollout 完成之后进行重启和正确的参数更新。
 
 - `--rollout-health-check-first-wait`：由于一些大的 MoE 模型在第一次运行时需要处理一些编译，我们会在第一次 rollout 前等待 `rollout_health_check_first_wait` 秒再开始发送心跳，默认为 300s；
 - `--rollout-health-check-interval`：心跳检查间隔，默认为 10s；
diff --git a/docs/zh/advanced/megatron-config.md b/docs/zh/advanced/megatron-config.md
index 02acaadab..224592e8e 100644
--- a/docs/zh/advanced/megatron-config.md
+++ b/docs/zh/advanced/megatron-config.md
@@ -8,7 +8,7 @@
 
 ## 设计概览
 
-默认情况下（不使用 `--megatron-config-path`），actor 和 critic 都直接继承命令行中的 Megatron / slime 参数。
+默认情况下（不使用 `--megatron-config-path`），actor 和 critic 都直接继承命令行中的 Megatron / vime 参数。
 
 使用 `--megatron-config-path` 后，配置会分成两层：
 
@@ -17,7 +17,7 @@
 
 **核心设计原则：**
 
-- **CLI 是公共基线。** slime 会先解析普通命令行参数，再应用 YAML 中的角色覆盖。
+- **CLI 是公共基线。** vime 会先解析普通命令行参数，再应用 YAML 中的角色覆盖。
 - **缺失角色自动继承。** 如果某个 role 没有出现在 YAML 中，该角色会直接继承 CLI 参数。
 - **资源申请仍由 CLI 控制。** YAML 中的 `num_nodes` 和 `num_gpus_per_node` 会被忽略；资源分配仍由 `--actor-num-*` / `--critic-num-*` 决定。
 
diff --git a/docs/zh/advanced/pd-disaggregation.md b/docs/zh/advanced/pd-disaggregation.md
index 036a19c43..e5c07b9c2 100644
--- a/docs/zh/advanced/pd-disaggregation.md
+++ b/docs/zh/advanced/pd-disaggregation.md
@@ -1,6 +1,6 @@
 # PD 分离
 
-slime 支持 Prefill 和 Decode 的分离部署 (PD Disaggregation)。
+vime 支持 Prefill 和 Decode 的分离部署 (PD Disaggregation)。
 
 可以通过设置 `--prefill-num-servers` 参数来指定用于 Prefill 的服务器数量。
 
diff --git a/docs/zh/advanced/reproducibility.md b/docs/zh/advanced/reproducibility.md
index 3502034f6..0822ff1a3 100644
--- a/docs/zh/advanced/reproducibility.md
+++ b/docs/zh/advanced/reproducibility.md
@@ -1,6 +1,6 @@
 # 可复现性
 
-可复现性是科研进展的基础。slime 通过结合 vLLM 的 [batch-invariant 确定性推理](https://vllm.ai/blog/2025-11-10-bitwise-consistent-train-inference) 与 Megatron-LM 的 deterministic 模式，支持 bitwise 级的实验复现。
+可复现性是科研进展的基础。vime 通过结合 vLLM 的 [batch-invariant 确定性推理](https://vllm.ai/blog/2025-11-10-bitwise-consistent-train-inference) 与 Megatron-LM 的 deterministic 模式，支持 bitwise 级的实验复现。
 
 为了开启确定性训练，你需要通过 `pip uninstall flash_attn_3 -y` 卸载 flash attention 3，并设置：
 
@@ -34,7 +34,7 @@ hf download --repo-type dataset zhuzilin/gsm8k --local-dir /root/gsm8k
 hf download Qwen/Qwen2.5-0.5B-Instruct --local-dir /root/Qwen2.5-0.5B-Instruct
 
 # convert ckpt
-cd slime/
+cd vime/
 source scripts/models/qwen2.5-0.5B.sh
 PYTHONPATH=/root/Megatron-LM/ python \
    tools/convert_hf_to_torch_dist.py \
diff --git a/docs/zh/advanced/speculative-decoding.md b/docs/zh/advanced/speculative-decoding.md
index f65fcc6af..9e3cb9569 100644
--- a/docs/zh/advanced/speculative-decoding.md
+++ b/docs/zh/advanced/speculative-decoding.md
@@ -4,7 +4,7 @@
 
 ## 使用投机采样加速推理
 
-vLLM 把投机采样的所有配置收敛到一个 JSON（`SpeculativeConfig`），slime 通过
+vLLM 把投机采样的所有配置收敛到一个 JSON（`SpeculativeConfig`），vime 通过
 `--vllm-speculative-config` 透传。对于有 MTP 层的模型（例如 GLM-4.7、DeepSeek-V3/R1），传入：
 
 ```bash
@@ -31,7 +31,7 @@ draft TP 等）请参考 vLLM 的 speculative decoding [文档](https://docs.vll
 
 随着 RL 流程的进行，draft model 和 target model 的采样概率差异逐渐增大，能通过验证的 draft token 逐渐减少，spec 甚至可能造成负收益。
 
-目前，slime 支持了在 RL 流程中在线训练 MTP 层，随着训练的进行同步更新 draft model，稳定提高了采样速度，相关原理可参见 [blog](https://www.notion.so/jiajunli-guapisolo/Power-Up-Speculative-Decoding-In-Reinforcement-Learning-2a92d24a293b802d9c73dbae429e581e)。使用方法如下：
+目前，vime 支持了在 RL 流程中在线训练 MTP 层，随着训练的进行同步更新 draft model，稳定提高了采样速度，相关原理可参见 [blog](https://www.notion.so/jiajunli-guapisolo/Power-Up-Speculative-Decoding-In-Reinforcement-Learning-2a92d24a293b802d9c73dbae429e581e)。使用方法如下：
 
 ```bash
 --mtp-num-layers 1
diff --git a/docs/zh/advanced/vllm-config.md b/docs/zh/advanced/vllm-config.md
index 10bfb3fd5..2e6e2c9e3 100644
--- a/docs/zh/advanced/vllm-config.md
+++ b/docs/zh/advanced/vllm-config.md
@@ -1,12 +1,12 @@
 # vLLM Config：高级引擎部署
 
-`--vllm-config` 是一个基于 YAML 的配置系统，用于在 slime 中精细控制 vLLM 引擎的部署。它支持**多模型服务**、**Prefill-Decode (PD) 分离**、**异构服务器组**，甚至可以作为复杂推理拓扑的**独立 vLLM 启动器**。
+`--vllm-config` 是一个基于 YAML 的配置系统，用于在 vime 中精细控制 vLLM 引擎的部署。它支持**多模型服务**、**Prefill-Decode (PD) 分离**、**异构服务器组**，甚至可以作为复杂推理拓扑的**独立 vLLM 启动器**。
 
 ---
 
 ## 架构概览
 
-在默认配置（不使用 `--vllm-config`）下，slime 部署单个模型，放在单个 router 后面，使用统一的服务器组：
+在默认配置（不使用 `--vllm-config`）下，vime 部署单个模型，放在单个 router 后面，使用统一的服务器组：
 
 ![架构概览](../../../imgs/arch.png)
 
@@ -170,8 +170,8 @@ python train.py \
 **在自定义 rollout 函数中访问模型：**
 
 ```python
-from slime.rollout.vllm_rollout import get_model_url
-from slime.utils.http_utils import post
+from vime.rollout.vllm_rollout import get_model_url
+from vime.utils.http_utils import post
 
 async def my_generate(args, sample, sampling_params):
     # 路由到 actor 模型（默认）
@@ -257,25 +257,25 @@ vllm:
 
 ### 7. 独立 vLLM 启动器
 
-虽然 `--vllm-config` 是为 slime 的训练流水线设计的，但它也可以作为纯推理场景的强大启动器，通过 `--rollout-external` 模式或配置 slime 仅关注推理服务。
+虽然 `--vllm-config` 是为 vime 的训练流水线设计的，但它也可以作为纯推理场景的强大启动器，通过 `--rollout-external` 模式或配置 vime 仅关注推理服务。
 
 **使用预启动的外部引擎：**
 
-对于复杂的生产部署，你可能希望独立预启动 vLLM 引擎，然后将其连接到 slime：
+对于复杂的生产部署，你可能希望独立预启动 vLLM 引擎，然后将其连接到 vime：
 
 ```bash
 # 步骤 1：外部启动 vLLM 引擎
 vllm serve /path/to/model --port 10090 ...
 vllm serve /path/to/model --port 10091 ...
 
-# 步骤 2：将 slime 连接到外部引擎
+# 步骤 2：将 vime 连接到外部引擎
 python train.py \
   --rollout-external \
   --rollout-external-engine-addrs host1:10090 host2:10091 \
   ...
 ```
 
-> **注意：** `--vllm-config` 和 `--rollout-external` 互斥。当你希望 slime 管理完整的引擎生命周期时，使用 `--vllm-config`；当引擎已预部署时，使用 `--rollout-external`。
+> **注意：** `--vllm-config` 和 `--rollout-external` 互斥。当你希望 vime 管理完整的引擎生命周期时，使用 `--vllm-config`；当引擎已预部署时，使用 `--rollout-external`。
 
 ---
 
@@ -297,7 +297,7 @@ python train.py \
 
 对于多轮对话和 agentic 场景，会话亲和确保同一对话的所有请求路由到同一个 backend worker。这可以显著提升 prefix cache 命中率，因为 worker 已经缓存了对话历史。
 
-slime 自动为每个 sample 分配一个唯一的 `session_id`（存储在 `sample.session_id` 中）。当 router 策略为 `consistent_hash` 时，该 ID 通过 `x-session-id` header 传递，vllm-router 使用它将同一会话的所有轮次确定性地路由到同一个 worker。
+vime 自动为每个 sample 分配一个唯一的 `session_id`（存储在 `sample.session_id` 中）。当 router 策略为 `consistent_hash` 时，该 ID 通过 `x-session-id` header 传递，vllm-router 使用它将同一会话的所有轮次确定性地路由到同一个 worker。
 
 ```bash
 --router-policy consistent_hash
@@ -306,7 +306,7 @@ slime 自动为每个 sample 分配一个唯一的 `session_id`（存储在 `sam
 **工作原理：**
 
 1. 每个 sample 通过 UUID 分配唯一的 `session_id`
-2. 每次请求时，slime 在 HTTP header 中传递 `x-session-id: <session_id>`
+2. 每次请求时，vime 在 HTTP header 中传递 `x-session-id: <session_id>`
 3. vllm-router 的 consistent-hash 策略将该 key 映射到特定的 worker
 4. 后续轮次复用相同的 `session_id`，确保命中同一个 worker
 
@@ -314,7 +314,7 @@ slime 自动为每个 sample 分配一个唯一的 `session_id`（存储在 `sam
 
 ## 解析规则
 
-加载配置时，slime 按以下优先级顺序解析：
+加载配置时，vime 按以下优先级顺序解析：
 
 1. **每引擎 GPU 数回退：** 组 `num_gpus_per_engine` → 模型 `num_gpus_per_engine` → `args.rollout_num_gpus_per_engine`
 2. **模型路径回退：** 组 `overrides.model_path` → 模型 `model_path` → `args.hf_checkpoint`
@@ -392,8 +392,8 @@ python train.py \
 **自定义 rollout 函数 (`my_agent/rollout.py`)：**
 
 ```python
-from slime.rollout.vllm_rollout import get_model_url
-from slime.utils.http_utils import post
+from vime.rollout.vllm_rollout import get_model_url
+from vime.utils.http_utils import post
 
 async def generate_with_models(args, sample, sampling_params):
     """使用 actor 生成，用 reward 模型打分，与 reference 比较。"""
@@ -442,11 +442,11 @@ async def generate_with_models(args, sample, sampling_params):
 
 ### Q: 运行时如何获取特定模型的 router 地址？
 
-使用 `slime.rollout.vllm_rollout` 中的 `get_model_url(args, "model_name", "/endpoint")`。它从 `args.vllm_model_routers`（一个 `{ model_name: (ip, port) }` 字典）中读取，该字典在引擎启动后自动填充。
+使用 `vime.rollout.vllm_rollout` 中的 `get_model_url(args, "model_name", "/endpoint")`。它从 `args.vllm_model_routers`（一个 `{ model_name: (ip, port) }` 字典）中读取，该字典在引擎启动后自动填充。
 
 ### Q: 可以不训练，只用 `--vllm-config` 做推理吗？
 
-虽然 `--vllm-config` 是为 slime 的训练循环设计的，但你可以通过配置仅 rollout 的运行来实现纯推理场景。对于完全独立的 vLLM 推理服务，建议直接使用 vLLM 原生的 `launch_server`，或使用 `--rollout-external` 模式连接预部署的引擎。
+虽然 `--vllm-config` 是为 vime 的训练循环设计的，但你可以通过配置仅 rollout 的运行来实现纯推理场景。对于完全独立的 vLLM 推理服务，建议直接使用 vLLM 原生的 `launch_server`，或使用 `--rollout-external` 模式连接预部署的引擎。
 
 ### Q: `--vllm-config` 和 `--prefill-num-servers` 是什么关系？
 
diff --git a/docs/zh/developer_guide/ci.md b/docs/zh/developer_guide/ci.md
index f1993b470..d71728141 100644
--- a/docs/zh/developer_guide/ci.md
+++ b/docs/zh/developer_guide/ci.md
@@ -1,13 +1,13 @@
 # CI（持续集成）
 
-slime 使用 GitHub Actions 进行 CI。测试通过 **PR label** 触发——给 PR 添加特定 label 即可运行对应的测试套件。
+vime 使用 GitHub Actions 进行 CI。测试通过 **PR label** 触发——给 PR 添加特定 label 即可运行对应的测试套件。
 
 ## 工作原理
 
 工作流定义在 `.github/workflows/pr-test.yml`（由 `pr-test.yml.j2` 自动生成）。每个 CI 任务会：
 
 1. 在自托管 GPU runner 上通过 `docker run` 运行；大多数测试使用 `inferactinc/public:vime-vllm-cu129-latest`，镜像验证使用 `inferactinc/public:vime-vllm-cu129-latest`。
-2. 通过 `pip install -e . --no-deps` 安装 slime。
+2. 通过 `pip install -e . --no-deps` 安装 vime。
 3. 通过 `tests/ci/gpu_lock_exec.py --count <num_gpus>` 获取所需数量的 GPU。
 4. 执行测试文件：`python <test_path>.py` 或 `python tests/<test_file>.py`。如果测试位于 `tests/plugin_contracts/` 这样的子目录，CI 也会自动处理。
 
@@ -20,7 +20,7 @@ slime 使用 GitHub Actions 进行 CI。测试通过 **PR label** 触发——
 | Label | Job | 说明 |
 |---|---|---|
 | `run-ci-short` | `e2e-test-short` | Qwen2.5-0.5B 轻量级冒烟测试（4 GPU），用于快速反馈。 |
-| `run-ci-megatron` | `e2e-test-megatron` | 核心 Megatron 训练测试，覆盖 Dense、MoE、PPO、OPD 等。 |
+| `run-ci-megatron` | `e2e-test-megatron` | 核心 Megatron 训练测试，覆盖 Dense、MoE、PPO、MTP 等。 |
 | `run-ci-precision` | `e2e-test-precision` | 数值精度校验（并行一致性检查）。 |
 | `run-ci-ckpt` | `e2e-test-ckpt` | Checkpoint 保存/加载正确性（同步和异步保存）。 |
 | `run-ci-image` | `e2e-test-image` | 在 `inferactinc/public:vime-vllm-cu129-latest` 镜像上运行**全部**测试（用于镜像验证）。 |
@@ -40,7 +40,7 @@ slime 使用 GitHub Actions 进行 CI。测试通过 **PR label** 触发——
 
 这意味着你不需要手动在 workflow 中注册新测试——只需确保测试文件顶部有 `NUM_GPUS = <N>` 常量，`run-ci-changed` 就会自动识别并运行。
 
-**示例**：如果你的 PR 新增了 `tests/test_qwen3_8B_opd_vllm.py`（其中 `NUM_GPUS = 8`），添加 `run-ci-changed` label 后会自动在 8 张 GPU 上运行该测试。
+**示例**：如果你的 PR 新增了 `tests/test_mimo_7B_mtp_only_grad.py`（其中 `NUM_GPUS = 8`），添加 `run-ci-changed` label 后会自动在 8 张 GPU 上运行该测试。
 
 ### `run-ci-image` — 在测试镜像上运行全部测试
 
@@ -56,8 +56,8 @@ slime 使用 GitHub Actions 进行 CI。测试通过 **PR label** 触发——
 这是验证 Megatron 后端改动的主要 label，覆盖：
 
 - Dense 模型：GLM4-9B、Qwen3-4B（PPO）
-- MoE 模型：Qwen3-30B-A3B（DeepEP + FP8）、Qwen3.6-35B-A3B PD + Mooncake、Moonlight-16B-A3B
-- 特殊场景：Qwen2.5-0.5B debug rollout-then-train、OPD（vLLM teacher 模式）
+- MoE 模型：Qwen3-30B-A3B（DeepEP）、Qwen3.6-35B-A3B PD + Mooncake、Moonlight-16B-A3B
+- 特殊场景：MiMo-7B MTP、Qwen2.5-0.5B debug rollout-then-train
 
 所有测试使用 8 张 GPU。如果你正在修改 Megatron 训练逻辑、loss 计算或 checkpoint 转换，应该使用这个 label。
 
@@ -67,7 +67,7 @@ slime 使用 GitHub Actions 进行 CI。测试通过 **PR label** 触发——
 
 ```python
 import os
-import slime.utils.external_utils.command_utils as U
+import vime.utils.external_utils.command_utils as U
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/docs/zh/developer_guide/debug.md b/docs/zh/developer_guide/debug.md
index d21e95087..6823e54ef 100644
--- a/docs/zh/developer_guide/debug.md
+++ b/docs/zh/developer_guide/debug.md
@@ -2,7 +2,7 @@
 
 ## 对齐精度
 
-在开发 slime 的过程中，经常会需要检查模型的精度是否正确，可以通过以下方式检查：
+在开发 vime 的过程中，经常会需要检查模型的精度是否正确，可以通过以下方式检查：
 
 1. 训练第一步
    1. rollout 的生成是否是人话，如果不是，有以下 2 种可能：
@@ -25,20 +25,20 @@
 
 ## 训练推理单独 debug
 
-slime 支持将训练部分和推理部分分开进行调试，从而实现：
+vime 支持将训练部分和推理部分分开进行调试，从而实现：
 
 - 在调优/debug 推理部分时，只用少量卡就可以启动任务；
 - 在调优/debug 训练部分时，可以保证模型输入固定，去除 rollout 的随机性。
 
-具体来说，目前 slime 提供了如下的参数来进行分离调试：
+具体来说，目前 vime 提供了如下的参数来进行分离调试：
 
 1. `--debug-rollout-only`
 
-   开启后，slime 将不会加载 megatron，只初始化 vllm ，可以用这个方法来进行推理部分的调试。
+   开启后，vime 将不会加载 megatron，只初始化 vllm ，可以用这个方法来进行推理部分的调试。
 
 1. `--debug-train-only`
 
-   开启后，slime 将不会加载 vllm，只初始化 megatron ，可以用这个方法来进行训练部分的调试。
+   开启后，vime 将不会加载 vllm，只初始化 megatron ，可以用这个方法来进行训练部分的调试。
 
 2. `--save-debug-rollout-data /your/saved/debug/data_{rollout_id}.pt`
 
@@ -48,48 +48,6 @@ slime 支持将训练部分和推理部分分开进行调试，从而实现：
 
    开启后，会从 `args.load_debug_rollout_data.format(rollout_id=rollout_id)` 来加载数据，并且不会初始化 vllm（自动设置 `debug_train_only=True`）。可以以这种方式来固定训练部分的输入，对训练部分进行调优，例如切换各种并行。
 
-## INT4 / Compressed-Tensors 量化 Checkpoint 问题
-
-使用 INT4 量化模型（如 `compressed-tensors` 的 `W4A16`）时，checkpoint 的 `config.json` 中有一个 `quantization_config.ignore` 列表，指定哪些参数**不**做量化。在线权重更新（Megatron → vLLM）时，slime 也会读取这个 ignore list 来决定哪些参数需要 INT4 量化。ignore list 不正确会导致静默错误：
-
-1. **MoE 路由权重（`mlp.gate.weight`）变成全零**
-
-   MoE 的路由权重（`mlp.gate.weight`，shape `[num_experts, hidden_size]`）是一个普通的 2D weight tensor，但它**不是** Linear 层的权重。如果它不在 ignore list 中，在线量化器会把它 INT4 量化为 `weight_packed`、`weight_scale`、`weight_zero_point` 等。然而 vLLM 不会以量化名称来加载路由权重，因此这些参数在 `load_weights` 时被静默跳过，导致 gate 权重全零。
-
-   **修复方法**：确保 `config.json` 的 ignore list 中包含 `"re:.*mlp\\.gate\\..*"`。
-
-2. **其他非 Linear 的 2D 权重**
-
-   类似问题可能出现在任何不是真正 Linear 层的 2D `.weight` tensor 上，例如 `model.embed_tokens.weight`。务必检查 ignore list 覆盖了所有非 Linear 权重。
-
-   **推荐的 ignore 配置**（以 GLM 系 MoE 模型为例）：
-   ```json
-   "ignore": [
-     "lm_head",
-     "model.embed_tokens.weight",
-     "re:.*self_attn.*",
-     "re:.*mlp\\.shared_experts.*",
-     "re:.*mlp\\.gate_up_proj.*",
-     "re:.*mlp\\.gate_proj.*",
-     "re:.*mlp\\.up_proj.*",
-     "re:.*mlp\\.down_proj.*",
-     "re:.*eh_proj.*",
-     "re:.*mlp\\.gate\\..*"
-   ]
-   ```
-
-3. **safetensors 分片缺失**
-
-   转换工具偶尔可能产出不完整的 checkpoint（例如缺少 `model-00010-of-00093.safetensors`）。转换完成后，务必检查：
-   - `.safetensors` 文件数量是否与预期一致。
-   - `model.safetensors.index.json` 中是否包含所有 layer 的条目。
-   - 抽查关键 layer（如第一个 MoE layer）的 key 数量是否正确。
-
-4. **如何排查**
-
-   - 使用 `--check-weight-update-equal` 验证 Megatron → vLLM 权重同步后的值是否正确。如果某个参数在 vLLM 侧全为零，说明它可能被错误量化或在 checkpoint 中缺失。
-   - 使用 `--debug-rollout-only` 配合少量 GPU，快速测试 vLLM 能否从量化 checkpoint 正常生成文本。
-
 ## Debug vllm illegal memory access (IMA)
 
 在进行大规模 RL 时，不时会遇到 vLLM IMA 的问题，以下是我们的一些 debug 建议：
diff --git a/docs/zh/developer_guide/trace.md b/docs/zh/developer_guide/trace.md
index a5e24f93c..8f9877b98 100644
--- a/docs/zh/developer_guide/trace.md
+++ b/docs/zh/developer_guide/trace.md
@@ -1,6 +1,6 @@
 # Trace 可视化
 
-slime 可以为每条 rollout sample 挂上轻量级执行 trace。它会记录生成、奖励模型等 span 事件，并且可以在保存下来的 rollout debug dump 中离线查看。
+vime 可以为每条 rollout sample 挂上轻量级执行 trace。它会记录生成、奖励模型等 span 事件，并且可以在保存下来的 rollout debug dump 中离线查看。
 
 ![trace 时间线查看器](../../_static/image/trace.png)
 
@@ -41,7 +41,7 @@ python tools/trace_timeline_viewer.py /path/to/debug/rollout_0.pt
 
 ## 给自定义代码打点
 
-在自定义 rollout 或 reward 逻辑中，可以直接复用 `slime.utils.trace_utils` 里的工具：
+在自定义 rollout 或 reward 逻辑中，可以直接复用 `vime.utils.trace_utils` 里的工具：
 
 - `trace_span(target, name, attrs=...)`：记录一段持续时间。
 - `trace_event(target, name, attrs=...)`：记录一个瞬时事件。
@@ -54,10 +54,10 @@ python tools/trace_timeline_viewer.py /path/to/debug/rollout_0.pt
 
 如果整个函数调用都应该对应一个 span，就用 `trace_function(...)`。它本质上会先解析 trace target，然后在函数调用外层自动套一层 `trace_span(...)`，因此同步函数和异步函数都能直接用。
 
-slime 主 rollout 流程里就是这样用的。例如 `generate_and_rm(...)` 按 sample 打点，而 `generate_and_rm_group(...)` 按 group 打点：
+vime 主 rollout 流程里就是这样用的。例如 `generate_and_rm(...)` 按 sample 打点，而 `generate_and_rm_group(...)` 按 group 打点：
 
 ```python
-from slime.utils.trace_utils import trace_function
+from vime.utils.trace_utils import trace_function
 
 
 @trace_function("generate_and_rm", target="sample")
@@ -104,7 +104,7 @@ async def custom_rollout_batch(samples, **kwargs):
 如果想在某个 HTTP 调用周围记录每轮的 attrs，可以直接套一层 `trace_span`：
 
 ```python
-from slime.utils.trace_utils import trace_span
+from vime.utils.trace_utils import trace_span
 
 with trace_span(sample, "vllm_generate", attrs={"max_tokens": params["max_new_tokens"]}):
     output = await post(url, payload)
diff --git a/docs/zh/examples/qwen3-30B-A3B.md b/docs/zh/examples/qwen3-30B-A3B.md
index b7239ea93..039b3920b 100644
--- a/docs/zh/examples/qwen3-30B-A3B.md
+++ b/docs/zh/examples/qwen3-30B-A3B.md
@@ -7,7 +7,7 @@
 可以用如下方法把 huggingface checkpoint 转化为 torch_dist 格式：
 
 ```bash
-cd slime/
+cd vime/
 pip install -e . --no-deps
 source scripts/models/qwen3-30B-A3B.sh
 PYTHONPATH=/root/Megatron-LM/ torchrun --nproc-per-node 8 \
@@ -22,13 +22,13 @@ PYTHONPATH=/root/Megatron-LM/ torchrun --nproc-per-node 8 \
 执行训练：
 
 ```bash
-cd /root/slime
+cd /root/vime
 bash scripts/run-qwen3-30B-A3B.sh
 ```
 
 ### 参数简介
 
-这里我们简单介绍一下脚本 [run-qwen3-30B-A3B.sh](https://github.com/THUDM/slime/blob/main/scripts/run-qwen3-30B-A3B.sh) 中与 MoE 相关的部分。
+这里我们简单介绍一下脚本 [run-qwen3-30B-A3B.sh](https://github.com/vllm-project/vime/blob/main/scripts/run-qwen3-30B-A3B.sh) 中与 MoE 相关的部分。
 
 1. 为了支持在 8xH800 环境中运行 Qwen3-30B-A3B，我们需要开启 megatron 的 CPU Adam 以节省显存，对应配置为：
 
@@ -71,25 +71,6 @@ bash scripts/run-qwen3-30B-A3B.sh
    如果要在 attention 上做 DP 同时在 expert 上做 EP，可以加 `--vllm-data-parallel-size N`
    配合 `--vllm-enable-expert-parallel`。
 
-### bf16 训练 fp8 推理
-
-slime 还支持 bf16 训练，fp8 推理。对于 Qwen3-30B-A3B 模型，只需要下载如下模型：
-
-```bash
-hf download Qwen/Qwen3-30B-A3B-FP8 --local-dir /root/Qwen3-30B-A3B-FP8
-```
-
-并将 `--hf-checkpoint` 替换为：
-
-```bash
-#--hf-checkpoint /root/Qwen3-30B-A3B
---hf-checkpoint /root/Qwen3-30B-A3B-FP8
-```
-
-即可触发 fp8 训练。目前我们会将 bf16 权重直接 cast 为 fp8，后续会逐渐添加对精度影响更小的量化方案。
-
-⚠️  训练的 megatron checkpoint 还需要是最开始用 bf16 的 huggingface 转换的。
-
 ### 多机支持
 
 以下以 **2台机器、每台8卡（共16GPU）** 为入门示例；脚本与参数可扩展到 **N节点**。多机与单机的主要差异：
diff --git a/docs/zh/examples/qwen3-4B.md b/docs/zh/examples/qwen3-4B.md
index c02301cb5..f17e28ce5 100644
--- a/docs/zh/examples/qwen3-4B.md
+++ b/docs/zh/examples/qwen3-4B.md
@@ -6,8 +6,8 @@
 
 ```bash
 cd /root/
-git clone https://github.com/THUDM/slime.git
-cd slime/
+git clone https://github.com/vllm-project/vime.git
+cd vime/
 pip install -e . --no-deps
 ```
 
@@ -30,7 +30,7 @@ hf download --repo-type dataset zhuzilin/aime-2024 \
 
 ```bash
 # mcore checkpoint
-cd /root/slime
+cd /root/vime
 source scripts/models/qwen3-4B.sh
 PYTHONPATH=/root/Megatron-LM python tools/convert_hf_to_torch_dist.py \
     ${MODEL_ARGS[@]} \
@@ -43,13 +43,13 @@ PYTHONPATH=/root/Megatron-LM python tools/convert_hf_to_torch_dist.py \
 执行训练：
 
 ```bash
-cd /root/slime
+cd /root/vime
 bash scripts/run-qwen3-4B.sh
 ```
 
 ### 参数简介
 
-这里我们简单介绍一下脚本 [run-qwen3-4B.sh](https://github.com/THUDM/slime/blob/main/scripts/run-qwen3-4B.sh) 中的各个组成部分：
+这里我们简单介绍一下脚本 [run-qwen3-4B.sh](https://github.com/vllm-project/vime/blob/main/scripts/run-qwen3-4B.sh) 中的各个组成部分：
 
 #### MODEL_ARGS
 
@@ -58,7 +58,7 @@ SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
 source "${SCRIPT_DIR}/models/qwen3-4B.sh"
 ```
 
-从 [scripts/models/qwen3-4B.sh](https://github.com/THUDM/slime/blob/main/scripts/models/qwen3-4B.sh) 读取模型的 config。这些 config 都是 megatron 的参数。在使用 megatron 进行训练的时候，megatron 无法从 ckpt 中读取模型 config，需要我们自行配置。我们在 [scripts/models](https://github.com/THUDM/slime/tree/main/scripts/models/) 中提供了一些样例。
+从 [scripts/models/qwen3-4B.sh](https://github.com/vllm-project/vime/blob/main/scripts/models/qwen3-4B.sh) 读取模型的 config。这些 config 都是 megatron 的参数。在使用 megatron 进行训练的时候，megatron 无法从 ckpt 中读取模型 config，需要我们自行配置。我们在 [scripts/models](https://github.com/vllm-project/vime/tree/main/scripts/models/) 中提供了一些样例。
 
 ⚠️  注意检查模型文件中的 `--rotary-base` 等配置是否对应你当前训练模型的配置，因为同一个模型结构的不同模型可能有不同的取值。在这种情况下，你可以在导入模型参数后在脚本里进行覆盖，例如：
 
@@ -77,8 +77,8 @@ CKPT_ARGS=(
    # reference model 的 ckp
    --ref-load /root/Qwen3-4B_torch_dist
    # actor 的 load dir，如果是空的，会从 `ref_load` 里面读
-   --load /root/Qwen3-4B_slime/
-   --save /root/Qwen3-4B_slime/
+   --load /root/Qwen3-4B_vime/
+   --save /root/Qwen3-4B_vime/
    --save-interval 20
 )
 ```
@@ -98,7 +98,7 @@ ROLLOUT_ARGS=(
    --rollout-shuffle
 
    # reward model 类型，
-   # slime 提供了很多类型以及用于自定义的 --custom-rm-path
+   # vime 提供了很多类型以及用于自定义的 --custom-rm-path
    --rm-type deepscaler
 
    # 一共要训练多少 rollout
@@ -135,13 +135,13 @@ EVAL_ARGS=(
 
 #### PERF_ARGS
 
-一堆 megatron 的并行参数，只有 `--use-dynamic-batch-size` 与 `--max-tokens-per-gpu` 是 slime 添加的。
+一堆 megatron 的并行参数，只有 `--use-dynamic-batch-size` 与 `--max-tokens-per-gpu` 是 vime 添加的。
 
 `max_tokens_per_gpu` 是指每张卡最多跑多少 token，在开启 `use_dynamic_batch_size` 之后，会尽可能将一个 batch 内部长短不一的数据拼到 `max_tokens_per_gpu`，从而组成动态的 micro batch size，如果有一条数据长度超过了 `max_tokens_per_gpu`，则自成一条，不会对数据进行截断。在开启 context parallel (CP) 时，会让 CP 张卡去上的数据去共享总长为 `CP * max_tokens_per_gpu` 的 token。
 
 在开启 dynamic_batch_size，会忽略传统的 `micro_batch_size`。
 
-⚠️  slime 总是会通过 data packing 的方法训练模型，并且严格保证 per sample loss 或 per token loss，也就是开启 dynamic batch size 不会对 loss 计算有影响，推荐开启。
+⚠️  vime 总是会通过 data packing 的方法训练模型，并且严格保证 per sample loss 或 per token loss，也就是开启 dynamic batch size 不会对 loss 计算有影响，推荐开启。
 
 ```bash
 PERF_ARGS=(
@@ -164,7 +164,7 @@ PERF_ARGS=(
 
 #### GRPO_ARGS
 
-目前 slime 这是一些 grpo 相关的参数：
+目前 vime 这是一些 grpo 相关的参数：
 
 ```bash
 GRPO_ARGS=(
@@ -193,7 +193,7 @@ OPTIMIZER_ARGS=(
 
 #### VLLM_ARGS
 
-vLLM 推理所需的参数。vime 默认使用 vLLM 作为 rollout 后端（`rollout.py` 启动 `VLLMEngine`，默认 rollout 函数为 `slime.rollout.vllm_rollout.generate_rollout`），无需额外指定 backend。`--rollout-num-gpus-per-engine` 对应每个 vLLM engine 的 `tensor_parallel_size`；除此之外的 vLLM 参数均通过添加 `--vllm-` 前缀传给 slime（例如 `--vllm-max-model-len`）。
+vLLM 推理所需的参数。vime 默认使用 vLLM 作为 rollout 后端（`rollout.py` 启动 `VLLMEngine`，默认 rollout 函数为 `vime.rollout.vllm_rollout.generate_rollout`），无需额外指定 backend。`--rollout-num-gpus-per-engine` 对应每个 vLLM engine 的 `tensor_parallel_size`；除此之外的 vLLM 参数均通过添加 `--vllm-` 前缀传给 vime（例如 `--vllm-max-model-len`）。
 
 ```bash
 VLLM_ARGS=(
@@ -204,16 +204,16 @@ VLLM_ARGS=(
 
 rollout 并发较高时，还可以通过 `--vllm-` 前缀调节 vLLM scheduler，例如 `--vllm-max-num-seqs`、`--vllm-max-num-batched-tokens`；调试或规避 CUDA graph 相关限制时可加 `--vllm-enforce-eager`。
 
-⚠️  slime 会用 vLLM router 来调度多个 vLLM server。训推一体（`--colocate`）时，训练与推理权重经 CUDA IPC 同步；训推分离时，训练侧经 NCCL 与 vLLM engine 同步权重。
+⚠️  vime 会用 vLLM router 来调度多个 vLLM server。训推一体（`--colocate`）时，训练与推理权重经 CUDA IPC 同步；训推分离时，训练侧经 NCCL 与 vLLM engine 同步权重。
 
 ### dynamic sampling
 
-slime 支持了更复杂的 sampling 方案，例如 [DAPO](https://dapo-sia.github.io/) 中的 dynamic sampling。如果要开启 dynamic sampling，需要配置：
+vime 支持了更复杂的 sampling 方案，例如 [DAPO](https://dapo-sia.github.io/) 中的 dynamic sampling。如果要开启 dynamic sampling，需要配置：
 
 ```bash
    --over-sampling-batch-size ${OVER_SAMPLING_BS} \
    --dynamic-sampling-filter-path \
-     slime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std \
+     vime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std \
 ```
 
 这里 `over_sampling_batch_size` 需要大于 ``rollout_batch_size`，例如配置为：
@@ -224,7 +224,7 @@ slime 支持了更复杂的 sampling 方案，例如 [DAPO](https://dapo-sia.git
    --over-sampling-batch-size 64 \
 ```
 
-那么 sampling 会直接采样 64 条 prompt，每条 prompt 采样 8 次。因为 slime 内部进行的是异步采样，所以我们会先后获得每个 prompt 的 8 条回复。在收到回复时，会用 `dynamic_sampling_filter_path` 对应的函数进行筛选，如果通过，则留下这 8 条数据，否则则丢掉。例子中的函数是判断回答是否全对或全错：
+那么 sampling 会直接采样 64 条 prompt，每条 prompt 采样 8 次。因为 vime 内部进行的是异步采样，所以我们会先后获得每个 prompt 的 8 条回复。在收到回复时，会用 `dynamic_sampling_filter_path` 对应的函数进行筛选，如果通过，则留下这 8 条数据，否则则丢掉。例子中的函数是判断回答是否全对或全错：
 
 ```python
 def check_reward_nonzero_std(args, samples: list[Sample], **kwargs):
@@ -278,7 +278,7 @@ ray job submit ... \
    ...
 ```
 
-此时，就会分配 2 张卡给训练，6 张卡给推理。`--rollout-num-gpus` 与 `--actor-num-gpus-per-node` 一样，是传给 `train.py` 的 **Ray 资源参数**：框架据此创建 placement group，并把前若干 bundle 分给训练 actor、后续 bundle 分给 rollout engine（见 `slime/ray/placement_group.py`）。**共卡模式（`--colocate`）下该参数会被忽略**，并自动设为 `actor_num_gpus_per_node * actor_num_nodes`。请勿把 `--rollout-num-gpus` 写在 `VLLM_ARGS` 中。
+此时，就会分配 2 张卡给训练，6 张卡给推理。`--rollout-num-gpus` 与 `--actor-num-gpus-per-node` 一样，是传给 `train.py` 的 **Ray 资源参数**：框架据此创建 placement group，并把前若干 bundle 分给训练 actor、后续 bundle 分给 rollout engine（见 `vime/ray/placement_group.py`）。**共卡模式（`--colocate`）下该参数会被忽略**，并自动设为 `actor_num_gpus_per_node * actor_num_nodes`。请勿把 `--rollout-num-gpus` 写在 `VLLM_ARGS` 中。
 
 训推分离时，`VLLM_ARGS` 仅需配置推理后端相关参数，例如：
 
@@ -297,6 +297,6 @@ VLLM_ARGS=(
 
 ### 异步训练
 
-当进行训推分离时，你会发现训练和推理的 GPU 总是相互等待着，为了避免这种资源空闲，我们可以开启异步训练。开启的方式即为将启动脚本中的 `train.py` 改变为 `train_async.py`。这样 slime 就会在进行当前 rollout 的训练时进行下一个 rollout 的数据生成了。
+当进行训推分离时，你会发现训练和推理的 GPU 总是相互等待着，为了避免这种资源空闲，我们可以开启异步训练。开启的方式即为将启动脚本中的 `train.py` 改变为 `train_async.py`。这样 vime 就会在进行当前 rollout 的训练时进行下一个 rollout 的数据生成了。
 
 `train.py` 和 `train_async.py` 的差别只在于 train loop 的同步逻辑，我们通过 ray 的异步（`.remote`, `ray.get`）实现了这点。
\ No newline at end of file
diff --git a/docs/zh/get_started/customization.md b/docs/zh/get_started/customization.md
index b885ca58b..0ab2d333c 100644
--- a/docs/zh/get_started/customization.md
+++ b/docs/zh/get_started/customization.md
@@ -1,6 +1,6 @@
 # 自定义指南
 
-slime 通过函数路径参数提供了广泛的自定义能力。这些参数允许你在训练和推理流程的各个阶段注入自定义逻辑，而无需修改核心代码库。
+vime 通过函数路径参数提供了广泛的自定义能力。这些参数允许你在训练和推理流程的各个阶段注入自定义逻辑，而无需修改核心代码库。
 
 ## 自定义接口概览
 
@@ -33,7 +33,7 @@ slime 通过函数路径参数提供了广泛的自定义能力。这些参数
 
 ### 1. Rollout 函数 (`--rollout-function-path`)
 
-**默认值**: `slime.rollout.vllm_rollout.generate_rollout`
+**默认值**: `vime.rollout.vllm_rollout.generate_rollout`
 
 **用途**: 覆盖整个 rollout 生成逻辑。
 
@@ -127,7 +127,7 @@ class DynamicFilterOutput:
 - 实现课程学习策略
 - 基于质量的样本选择
 
-**示例**: `slime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std`
+**示例**: `vime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std`
 
 ---
 
@@ -295,7 +295,6 @@ dict: {
     "rollout_routed_experts": list,       # 路由专家（用于 MoE）
     "metadata": list,                     # 训练元数据
     "multimodal_train_inputs": list,      # 多模态张量（用于 VLM）
-    "teacher_log_probs": list,            # 教师 log 概率（用于蒸馏）
 }
 ```
 
@@ -329,11 +328,11 @@ def log_eval_rollout_data(rollout_id, args, data, extra_metrics) -> bool
 
 ### 15. 数据源 (`--data-source-path`)
 
-**默认值**: `slime.rollout.data_source.RolloutDataSourceWithBuffer`
+**默认值**: `vime.rollout.data_source.RolloutDataSourceWithBuffer`
 
 **用途**: 覆盖 rollout 提示词的数据源。
 
-**基类**: `slime.rollout.data_source.DataSource`
+**基类**: `vime.rollout.data_source.DataSource`
 
 **必需方法**:
 ```python
@@ -408,11 +407,11 @@ def custom_hook(args, rollout_id, step_id, model, optimizer, opt_param_scheduler
 | 参数 | 说明 |
 | --- | --- |
 | `--use-routing-replay` | 训练中前向-反向路由一致性。([arXiv:2507.18071](https://arxiv.org/abs/2507.18071)) |
-| `--use-rollout-routing-replay` | R3：在训练时重放 rollout 阶段的路由。slime 默认的 `vllm_rollout` 路径支持该功能。([arXiv:2510.11370](https://arxiv.org/abs/2510.11370)) |
+| `--use-rollout-routing-replay` | R3：在训练时重放 rollout 阶段的路由。vime 默认的 `vllm_rollout` 路径支持该功能。([arXiv:2510.11370](https://arxiv.org/abs/2510.11370)) |
 
 ## 自定义函数路径的测试
 
-slime 现在也提供了一组 CPU 契约测试，用于校验这些 customization 接口。测试会通过字符串形式的导入路径来动态加载组件，因此既能回归仓库内置 hook，也能验证用户通过和训练时完全相同的 CLI 参数传入的自定义实现。
+vime 现在也提供了一组 CPU 契约测试，用于校验这些 customization 接口。测试会通过字符串形式的导入路径来动态加载组件，因此既能回归仓库内置 hook，也能验证用户通过和训练时完全相同的 CLI 参数传入的自定义实现。
 
 这些测试统一放在 `tests/plugin_contracts/` 目录下，并按 hook 形态归并成少数几个文件：
 
@@ -439,7 +438,7 @@ python -m pytest \
 
 CI 中也提供了独立的 `run-ci-plugin-contracts` label，给 PR 打上该标签后会并行运行上述全部四个契约测试（无需 GPU）。
 
-如果你要验证自己的自定义实现，可以直接设置环境变量，例如 `SLIME_CONTRACT_ROLLOUT_FUNCTION_PATH`、`SLIME_CONTRACT_CUSTOM_RM_PATH`，也可以在直接运行测试文件时传参，例如：
+如果你要验证自己的自定义实现，可以直接设置环境变量，例如 `VIME_CONTRACT_ROLLOUT_FUNCTION_PATH`、`VIME_CONTRACT_CUSTOM_RM_PATH`，也可以在直接运行测试文件时传参，例如：
 
 ```bash
 python tests/plugin_contracts/test_plugin_rollout_contracts.py \
diff --git a/docs/zh/get_started/qa.md b/docs/zh/get_started/qa.md
index ae722c0fe..072ee84c5 100644
--- a/docs/zh/get_started/qa.md
+++ b/docs/zh/get_started/qa.md
@@ -39,13 +39,13 @@
 
    可以用 `--num-steps-per-rollout` 来决定每一个 rollout 跑多少步。这相当于是把 `global_batch_size` 设置成 `rollout_batch_size * n_samples_per_prompt // num_steps_per_rollout`。
 
-1. **slime 是否进行了 data packing / varlen 处理？**
+1. **vime 是否进行了 data packing / varlen 处理？**
 
-   data packing 是指在训练过程中，将长短不一的 sample 拼接到一起，从而提升训练的利用率。slime 默认会进行这样的操作。
+   data packing 是指在训练过程中，将长短不一的 sample 拼接到一起，从而提升训练的利用率。vime 默认会进行这样的操作。
 
 1. **vLLM 部分出现 `Max retries exceeded with url: /health (Caused by NewConnectionError)` 的问题怎么办？**
 
-   slime 通过 `GET /health` 探测 vLLM engine 是否就绪;这个错误意味着 readiness 探测从未连通。最常见的原因是单机内多个 vLLM 引擎导致的端口冲突。一个临时的缓解方案是尽可能减少单机内的 vLLM 引擎数量，例如设置 tp=8。
+   vime 通过 `GET /health` 探测 vLLM engine 是否就绪;这个错误意味着 readiness 探测从未连通。最常见的原因是单机内多个 vLLM 引擎导致的端口冲突。一个临时的缓解方案是尽可能减少单机内的 vLLM 引擎数量，例如设置 tp=8。
 
 1. **grad norm 好高，训练训崩了怎么办？**
 
diff --git a/docs/zh/get_started/quick_start.md b/docs/zh/get_started/quick_start.md
index e8bc4458c..92cb0e285 100644
--- a/docs/zh/get_started/quick_start.md
+++ b/docs/zh/get_started/quick_start.md
@@ -1,14 +1,14 @@
 # 快速使用
 
-本文档从搭建环境开始，在一小时内带您快速上手 slime，涵盖环境配置，数据准备，训练启动和关键代码解析和魔改。
+本文档从搭建环境开始，在一小时内带您快速上手 vime，涵盖环境配置，数据准备，训练启动和关键代码解析和魔改。
 
 ## 基础环境搭建
 
-由于 slime 可能会包含针对 vllm/megatron 的临时补丁（patch）。为避免潜在的环境配置问题，强烈建议**用户使用我们提供的最新 Docker 镜像**，它已预置好所有依赖。
+由于 vime 可能会包含针对 vllm/megatron 的临时补丁（patch）。为避免潜在的环境配置问题，强烈建议**用户使用我们提供的最新 Docker 镜像**，它已预置好所有依赖。
 
 ### 硬件支持说明
 
-**slime** 支持多种 NVIDIA GPU 硬件平台：
+**vime** 支持多种 NVIDIA GPU 硬件平台：
 
 - **B200 系列**：完全支持，运行步骤与 H 系列完全相同
 - **H 系列 (H100/H200)**：官方支持，具有完整的 CI 测试保护，运行稳定可靠
@@ -19,7 +19,7 @@
 - B 卡基本功能稳定，可作为开发和测试参考，但暂无 CI 保护
 - 两种硬件平台使用完全相同的安装和启动流程
 
-- 对于不方便使用 docker 的场景，请参考 [build_conda.sh](https://github.com/THUDM/slime/blob/main/build_conda.sh)。
+- 对于不方便使用 docker 的场景，请参考 [build_conda.sh](https://github.com/vllm-project/vime/blob/main/build_conda.sh)。
 
 ### 拉取并启动 Docker 容器
 
@@ -35,13 +35,13 @@ docker run --rm --gpus all --ipc=host --shm-size=16g \
   -it inferactinc/public:vime-vllm-cu129-latest /bin/bash
 ```
 
-### 安装 slime
+### 安装 vime
 
-slime 已经安装在该 Docker 镜像中。如需更新到最新版本，请在 Docker 容器中执行以下命令：
+vime 已经安装在该 Docker 镜像中。如需更新到最新版本，请在 Docker 容器中执行以下命令：
 
 ```bash
 # 路径可根据实际情况调整
-cd /root/slime
+cd /root/vime
 git pull
 pip install -e . --no-deps
 ```
@@ -51,7 +51,7 @@ pip install -e . --no-deps
 可以从 Hugging Face、ModelScope 等平台下载所需的模型和数据集。以下是使用 `huggingface_hub` 下载示例资源的命令：
 
 ```bash
-# 下载模型权重 (GLM-Z1-9B)
+# 下载模型权重 (Qwen3-4B)
 hf download zai-org/Qwen3-4B --local-dir /root/Qwen3-4B
 
 # 下载训练数据集 (dapo-math-17k)
@@ -69,10 +69,10 @@ hf download --repo-type dataset zhuzilin/aime-2024 \
 
 当使用 Megatron 作为训练后端时，需要先将 Hugging Face 格式的模型权重转换为 Megatron `torch_dist` 格式。
 
-首先，加载目标模型的配置文件。`slime/scripts/models` 目录下包含了支持模型的配置文件。需要 `source` 对应模型的脚本，将配置参数加载到当前环境中。此处我们以 Qwen3-4B 模型为例子。
+首先，加载目标模型的配置文件。`vime/scripts/models` 目录下包含了支持模型的配置文件。需要 `source` 对应模型的脚本，将配置参数加载到当前环境中。此处我们以 Qwen3-4B 模型为例子。
 
 ```bash
-cd /root/slime
+cd /root/vime
 source scripts/models/qwen3-4B.sh
 ```
 
@@ -107,7 +107,7 @@ PYTHONPATH=/root/Megatron-LM python tools/convert_torch_dist_to_hf.py \
 完成上述准备工作后，即可运行训练脚本。
 
 ```bash
-cd /root/slime
+cd /root/vime
 bash scripts/run-qwen3-4B.sh
 ```
 
@@ -138,9 +138,9 @@ CKPT_ARGS=(
    # 参考模型 (Reference Model) 的 Megatron 格式检查点
    --ref-load /root/Qwen3-4B_torch_dist
    # Actor 模型的加载路径。若为空或不存在有效的checkpoint，则从 --ref-load 加载
-   --load /root/Qwen3-4B_slime/
+   --load /root/Qwen3-4B_vime/
    # 训练过程中模型的保存路径
-   --save /root/Qwen3-4B_slime/
+   --save /root/Qwen3-4B_vime/
    # 模型保存间隔（步数）
    --save-interval 20
 )
@@ -167,7 +167,7 @@ CKPT_ARGS=(
 在这个过程中，每轮的“产出”与“消耗”必须相等，遵循以下约束：
 **`(rollout-batch-size × n-samples-per-prompt) = (global-batch-size × num-steps-per-rollout)`**
 
-- 在 slime 中，如果设置了 `--num-steps-per-rollout` ，`--global-batch-size` 未设置则会被自动设置，设置了则会被用上述公式校验。
+- 在 vime 中，如果设置了 `--num-steps-per-rollout` ，`--global-batch-size` 未设置则会被自动设置，设置了则会被用上述公式校验。
 
 **训练流程次数控制**
 -   `--num-rollout`: 控制整个 **“采样→训练”** 循环的**总执行轮次**。
@@ -183,7 +183,7 @@ ROLLOUT_ARGS=(
    # 是否在 Rollout 阶段打乱数据
    --rollout-shuffle
 
-   # Reward Model 类型。slime 内置多种类型，也支持通过 --custom-rm-path 自定义
+   # Reward Model 类型。vime 内置多种类型，也支持通过 --custom-rm-path 自定义
    --rm-type deepscaler
 
    # 这五个参数来控制 rollout 与 train 的关系
@@ -223,14 +223,14 @@ EVAL_ARGS=(
 
 ### PERF_ARGS: 性能与并行参数
 
-这部分主要包含 Megatron 的并行配置。`--use-dynamic-batch-size` 和 `--max-tokens-per-gpu` 是 slime 添加的特有优化。
+这部分主要包含 Megatron 的并行配置。`--use-dynamic-batch-size` 和 `--max-tokens-per-gpu` 是 vime 添加的特有优化。
 
 -   `--max-tokens-per-gpu`: 每张 GPU 处理的最大 Token 数。启用动态批处理（`use_dynamic_batch_size`）后，系统会智能地将长短不一的样本打包，使每个 micro-batch 的总 Token 数接近此限制，从而提升训练效率。如果单个样本长度超过该值，它将独立形成一个 batch。在上下文并行（CP）模式下，`N` 张 CP 卡共享 `N * max_tokens_per_gpu` 的总长度。
 -   `--use-dynamic-batch-size`: 启用动态批处理。此时会忽略 `--micro-batch-size`。
 
 
 > 💡 **提示**：
->  slime 总是会通过 data packing 的方法训练模型，并且严格保证 per sample loss 或 per token loss 是正确的。因此，开启 dynamic batch size 不会对 loss 计算有影响，强烈推荐开启。
+>  vime 总是会通过 data packing 的方法训练模型，并且严格保证 per sample loss 或 per token loss 是正确的。因此，开启 dynamic batch size 不会对 loss 计算有影响，强烈推荐开启。
 
 ```bash
 PERF_ARGS=(
@@ -267,8 +267,8 @@ GRPO_ARGS=(
 )
 ```
 
-- `--advantage-estimator`: 除去 [GRPO](https://arxiv.org/abs/2402.03300)，slime 还支持丰富的其他训练算法，例如 [GSPO](https://arxiv.org/abs/2507.18071)、[Reinforce++](https://arxiv.org/abs/2501.03262) 与 [Reinforce++ Baseline](https://arxiv.org/abs/2501.03262)、以及 [PPO](https://arxiv.org/abs/1707.06347)；
-- `--calculate-per-token-loss`：slime 中默认的方案是 per sample loss，即 `mean(sum(sample_i) / len(sample_i))`，如果需要计算 per token loss，即 `sum(sum(sample_i)) / sum(len(sample_i))`，可以开启 `--calculate-per-token-loss`；
+- `--advantage-estimator`: 除去 [GRPO](https://arxiv.org/abs/2402.03300)，vime 还支持丰富的其他训练算法，例如 [GSPO](https://arxiv.org/abs/2507.18071)、[Reinforce++](https://arxiv.org/abs/2501.03262) 与 [Reinforce++ Baseline](https://arxiv.org/abs/2501.03262)、以及 [PPO](https://arxiv.org/abs/1707.06347)；
+- `--calculate-per-token-loss`：vime 中默认的方案是 per sample loss，即 `mean(sum(sample_i) / len(sample_i))`，如果需要计算 per token loss，即 `sum(sum(sample_i)) / sum(len(sample_i))`，可以开启 `--calculate-per-token-loss`；
 - `--use-tis`：如果需要开启 TIS (Truncated Importance Sampling)，可以开启这一设置。TIS 由此[博客](https://fengyao.notion.site/off-policy-rl)介绍。
 
 ### OPTIMIZER_ARGS: 优化器参数
@@ -288,10 +288,10 @@ OPTIMIZER_ARGS=(
 
 这部分参数用于配置 vLLM 推理服务。
 - `--rollout-num-gpus-per-engine`: 等同于 vLLM 的 `tp_size`。
-- 其他 vLLM 参数可以通过添加 `--vllm-` 前缀传递给 slime，slime 会自动透传给 vLLM。例如，要设置 vLLM 的 `--log-level INFO` 参数，只需使用 `--vllm-log-level INFO` 即可。
+- 其他 vLLM 参数可以通过添加 `--vllm-` 前缀传递给 vime，vime 会自动透传给 vLLM。例如，要设置 vLLM 的 `--log-level INFO` 参数，只需使用 `--vllm-log-level INFO` 即可。
 
 > ⚠️ **注意**：
-> slime 使用 `vllm-router` 调度多个 vLLM 引擎。`dp_size` 会通过 `rollout-num-gpus / rollout-num-gpus-per-engine` 计算得到。
+> vime 使用 `vllm-router` 调度多个 vLLM 引擎。`dp_size` 会通过 `rollout-num-gpus / rollout-num-gpus-per-engine` 计算得到。
 
 ```bash
 VLLM_ARGS=(
@@ -337,12 +337,12 @@ ray job submit ... \
 
 ### Dynamic Sampling
 
-slime 支持更复杂的采样策略，例如 [DAPO](https://dapo-sia.github.io/) 中使用的动态采样。要启用此功能，需配置以下参数：
+vime 支持更复杂的采样策略，例如 [DAPO](https://dapo-sia.github.io/) 中使用的动态采样。要启用此功能，需配置以下参数：
 
 ```bash
    --over-sampling-batch-size 64 \
    --dynamic-sampling-filter-path \
-     slime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std
+     vime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std
 ```
 
 这里 `over_sampling_batch_size` 需要大于 `rollout_batch_size`，例如配置为：
@@ -353,7 +353,7 @@ slime 支持更复杂的采样策略，例如 [DAPO](https://dapo-sia.github.io/
    --over-sampling-batch-size 64 \
 ```
 
-那么 sampling 会直接采样 64 条 prompt，每条 prompt 采样 8 次。因为 slime 内部进行的是异步采样，所以我们会先后获得每个 prompt 的 8 条回复。在收到回复时，会用 `dynamic_sampling_filter_path` 对应的函数进行筛选，如果通过，则留下这 8 条数据，否则则丢掉。
+那么 sampling 会直接采样 64 条 prompt，每条 prompt 采样 8 次。因为 vime 内部进行的是异步采样，所以我们会先后获得每个 prompt 的 8 条回复。在收到回复时，会用 `dynamic_sampling_filter_path` 对应的函数进行筛选，如果通过，则留下这 8 条数据，否则则丢掉。
 
 示例中的过滤函数 `check_reward_nonzero_std` 会检查一组样本的奖励（reward）标准差是否大于零，确保留下的每组样本其奖励分数都存在差异，从而避免数据过于单一，提升了数据的多样性。
 
@@ -390,40 +390,17 @@ def pop_first(args, rollout_id, buffer: list[list[Sample]], num_samples: int) ->
 
 
 
-### bf16 训练 fp8 推理
-
-slime 直接支持 bf16 训练，fp8 推理。对于 Qwen3-4B 模型，只需要下载如下模型：
-
-```bash
-hf download Qwen/Qwen3-4B-FP8 --local-dir /root/Qwen3-4B-FP8
-```
-
-并将 `--hf-checkpoint` 替换为：
-
-```bash
-   # 用于加载 tokenizer 等其他信息，实际上不会使用 hf 路径中的模型权重参数
-   --hf-checkpoint /root/Qwen3-4B-FP8
-
-   #  megatron checkpoint 还需要是最开始用 bf16 的 huggingface 转换的 dist 权重，不因为 FP8 rollout 而去做修改。
-   --ref-load /root/Qwen3-4B_torch_dist
-```
-
-即可触发 fp8 推理。目前我们会将 bf16 权重直接 cast 为 fp8，后续会逐渐添加对精度影响更小的量化方案。
-
-⚠️  训练的 megatron checkpoint 还需要是最开始用 bf16 的 huggingface 转换的。
-
-
 ## Multiturn 适配
 
-slime 框架高度可扩展，支持复杂的 Agent 场景（如多轮交互与工具调用）。其核心机制是通过自定义函数，重写默认的数据生成 (Rollout) 与奖励计算 (Reward) 逻辑。
+vime 框架高度可扩展，支持复杂的 Agent 场景（如多轮交互与工具调用）。其核心机制是通过自定义函数，重写默认的数据生成 (Rollout) 与奖励计算 (Reward) 逻辑。
 
-本部分以一个基于 [Search-R1](https://github.com/PeterGriffinJin/Search-R1) 的实现为例，说明如何适配 slime 以支持多轮交互。
+本部分以一个基于 [Search-R1](https://github.com/PeterGriffinJin/Search-R1) 的实现为例，说明如何适配 vime 以支持多轮交互。
 
 ### 适配思路总结
 
-适配 slime 以支持多轮交互主要包含三个步骤：
+适配 vime 以支持多轮交互主要包含三个步骤：
 
-1.  **数据准备**：将多轮交互数据集适配为 slime 的 `Sample` 对象。将对话历史、真实标签等映射到 `prompt` 和 `label` 字段，并将工具定义、中间状态等额外信息存入 `metadata` 字段，供后续函数调用。
+1.  **数据准备**：将多轮交互数据集适配为 vime 的 `Sample` 对象。将对话历史、真实标签等映射到 `prompt` 和 `label` 字段，并将工具定义、中间状态等额外信息存入 `metadata` 字段，供后续函数调用。
 
 2.  **实现自定义生成函数**：编写函数模拟“模型生成动作 → 执行工具 → 拼接观察结果”的交互循环，并正确处理 Loss Masking。
 
@@ -451,7 +428,7 @@ slime 框架高度可扩展，支持复杂的 Agent 场景（如多轮交互与
 
 ### 步骤二：在训练脚本中指定映射
 
-完成数据准备后，在训练脚本中，通过 `ROLLOUT_ARGS` 将这个预处理好的 `metadata` 列映射到 slime 的 `Sample.metadata` 字段。
+完成数据准备后，在训练脚本中，通过 `ROLLOUT_ARGS` 将这个预处理好的 `metadata` 列映射到 vime 的 `Sample.metadata` 字段。
 
 ```bash
 ROLLOUT_ARGS=(
@@ -465,7 +442,7 @@ ROLLOUT_ARGS=(
    --label-key final_answer
 
    # 4. 将预先构造好的 "metadata" 列加载到 Sample.metadata
-   #    slime 会自动将其解析为 Python 字典
+   #    vime 会自动将其解析为 Python 字典
    --metadata-key metadata
 )
 ```
@@ -570,9 +547,9 @@ ray job submit --address="http://127.0.0.1:8265" \
      }
    }' \
    -- python3 train.py \
-   --...（其他 Megatron/vLLM/slime 参数）
+   --...（其他 Megatron/vLLM/vime 参数）
 ```
 
-slime 针对大规模混合专家（MoE）模型的分布式训练进行了深度优化。我们提供了一个端到端的训练案例以供参考：
+vime 针对大规模混合专家（MoE）模型的分布式训练进行了深度优化。我们提供了一些端到端的训练案例以供参考：
 
 - [示例：8xH100 训练 Qwen3-30B-A3B](../examples/qwen3-30B-A3B.md)
diff --git a/docs/zh/get_started/usage.md b/docs/zh/get_started/usage.md
index 16b277480..6d6c63b66 100644
--- a/docs/zh/get_started/usage.md
+++ b/docs/zh/get_started/usage.md
@@ -1,8 +1,8 @@
 # 使用文档
 
-## slime 参数简介
+## vime 参数简介
 
-在使用 slime 时，传参主要是为了如下几件事：
+在使用 vime 时，传参主要是为了如下几件事：
 
 1. 把集群中一部分 GPU 分配做训练，一部分分配做推理；
 2. 训练的部分加载 megatron；
@@ -29,11 +29,11 @@
 
 - `--colocate`：开启训推一体。开启后会忽略 `--rollout-num-gpus` 让训练和推理的卡数相等。
 
-此外，slime 支持 Prefill 和 Decode 的分离部署 (PD Disaggregation)，可以通过设置 `--prefill-num-servers` 参数来指定用于 Prefill 的服务器数量。
+此外，vime 支持 Prefill 和 Decode 的分离部署 (PD Disaggregation)，可以通过设置 `--prefill-num-servers` 参数来指定用于 Prefill 的服务器数量。
 
 ### 选择训练后端
 
-slime 支持多种训练后端，可以通过 `--train-backend` 参数进行选择：
+vime 支持多种训练后端，可以通过 `--train-backend` 参数进行选择：
 
 - `megatron`（默认）：使用 Megatron-LM 作为训练后端，支持大规模模型的高效训练。
 
@@ -47,7 +47,7 @@ megatron 与 vLLM 或者 huggingface trainer 之类的工具不同，它不能
 - 配置并行以及一些优化
 - 配置需要加载的 ckpt
 
-对于一些 megatron 的自定义以及 slime 引入 megatron 的原理，请见 megatron 使用方法一节。
+对于一些 megatron 的自定义以及 vime 引入 megatron 的原理，请见 megatron 使用方法一节。
 
 #### 配置模型参数
 
@@ -80,8 +80,8 @@ MODEL_ARGS=(
 
 注意：
 
-- slime 会加载 `PYTHONPATH` 中的 megatron 的所有参数，所以可以在环境中的 megatron 里找参数以及参数的说明；
-- slime 会使用 data packing (或称 varlen 或 thd) 进行训练，无需配置 `--seq-length` 或 `--max-positional-embedding`，这两个参数不会影响训练模型的最大 context length。
+- vime 会加载 `PYTHONPATH` 中的 megatron 的所有参数，所以可以在环境中的 megatron 里找参数以及参数的说明；
+- vime 会使用 data packing (或称 varlen 或 thd) 进行训练，无需配置 `--seq-length` 或 `--max-positional-embedding`，这两个参数不会影响训练模型的最大 context length。
 
 #### 设置各种并行与重计算
 
@@ -127,7 +127,7 @@ torch 格式是 megatron 的老存储格式，里面的结构大约是一些 `mp
 
 其中 `latest_checkpointed_iteration.txt` 中记录了训练最新的训练步。在加载模型时，不能直接传入 `/ckpt/iter_xxxxxxx`，而是要传入 `/ckpt/`，并用 `--ckpt-step` 来选取对应的训练步（如果不使用 `--ckpt-step`，则会通过 `latest_checkpointed_iteration.txt` 读取对应的训练步。）
 
-在使用 slime 的时候，有 3 个参数用来加载和保存 ckpt：
+在使用 vime 的时候，有 3 个参数用来加载和保存 ckpt：
 
 - `--ref-load`：reference model 用的 megatron ckpt；
 - `--load`：actor 用的 megatron ckpt，如果没有设置 `--load`，或者设置的目录不存在，目录中没有 `latest_checkpointed_iteration.txt`，都会直接从 `--ref-load` 的 ckpt 进行初始化；
@@ -145,16 +145,16 @@ vLLM 的加载非常简单，只需要：
 
 注意：
 
-- 在第一个训练步之前，slime 会把 megatron 里的参数同步给 vLLM，所以 `--hf-checkpoint` 中不需要有最新的训练参数，在续训的时候也不需要更换 hf ckpt；
+- 在第一个训练步之前，vime 会把 megatron 里的参数同步给 vLLM，所以 `--hf-checkpoint` 中不需要有最新的训练参数，在续训的时候也不需要更换 hf ckpt；
 - vLLM 默认会从 huggingface ckpt 中 `config.json` 读取模型的最大 context length，可以使用 `--vllm-max-model-len` 参数来对这个值进行覆盖，从而支持进行更长的推理；
 - 在训推一体的训练过程中，虽然 megatron 和 vLLM 会先后 offload，但是还是需要为对方留有一些空间，需要通过减小 `--vllm-gpu-memory-utilization` 来调整 vLLM 的显存占用总量。
-- slime 支持透传 vllm-router 的参数，方式是在原参数名前加上 `router` 前缀。例如，vllm-router 的 `--balance-abs-threshold` 参数需要设置为 `--router-balance-abs-threshold`。由于 vllm-router 默认使用 cache-aware routing，可能会导致请求分配不均衡的问题。可以通过设置 `--router-balance-abs-threshold 0` 来强制均衡分配，但这可能会影响多轮对话场景下 prefix cache 的命中率。
+- vime 支持透传 vllm-router 的参数，方式是在原参数名前加上 `router` 前缀。例如，vllm-router 的 `--balance-abs-threshold` 参数需要设置为 `--router-balance-abs-threshold`。由于 vllm-router 默认使用 cache-aware routing，可能会导致请求分配不均衡的问题。可以通过设置 `--router-balance-abs-threshold 0` 来强制均衡分配，但这可能会影响多轮对话场景下 prefix cache 的命中率。
 
-对于一些 vLLM 的自定义以及 slime 引入 vLLM 的原理，请见 vLLM 使用方法一节。
+对于一些 vLLM 的自定义以及 vime 引入 vLLM 的原理，请见 vLLM 使用方法一节。
 
 ### 数据格式
 
-目前 slime 只支持加载 `.jsonl` 格式文件，即文件的每一行都是一个 json，一行数据的样例（展开后）为：
+目前 vime 只支持加载 `.jsonl` 格式文件，即文件的每一行都是一个 json，一行数据的样例（展开后）为：
 
 ```json
 {
@@ -178,7 +178,7 @@ vLLM 的加载非常简单，只需要：
 ```
 
 请注意，这里的 `step_loss_mask`（默认值为 1）字段为 SFT 阶段提供，若设置为 0，则会将该轮 `loss_mask` 设置为 0；若设置为 1，则使用正常 `loss_mask`。
-另外我们还提供了一个 metadata_key，默认为 `"metadata"`，读取后我们会把数据中的 metadata 加载进 slime，可能会对自定义数据生成或者自定义 reward model 有帮助。
+另外我们还提供了一个 metadata_key，默认为 `"metadata"`，读取后我们会把数据中的 metadata 加载进 vime，可能会对自定义数据生成或者自定义 reward model 有帮助。
 
 ### RL 训练需要的超参
 
@@ -187,9 +187,7 @@ vLLM 的加载非常简单，只需要：
   - `gspo`（https://arxiv.org/abs/2507.18071）；
   - `reinforce_plus_plus` 与 `reinforce_plus_plus_baseline`（https://arxiv.org/abs/2501.03262）；
   - `ppo`（https://arxiv.org/abs/1707.06347）。
-
-  注意：在策略蒸馏 (OPD) 现在与 advantage estimator 正交，使用 `--use-opd` 和 `--opd-kl-coef` 可以在任意 estimator 之上启用 OPD。
-- `--calculate-per-token-loss`：slime 中默认的方案是 per sample loss，即 `mean(sum(sample_i) / len(sample_i))`，如果需要计算 per token loss，即 `sum(sum(sample_i)) / sum(len(sample_i))`，可以开启 `--calculate-per-token-loss`；
+- `--calculate-per-token-loss`：vime 中默认的方案是 per sample loss，即 `mean(sum(sample_i) / len(sample_i))`，如果需要计算 per token loss，即 `sum(sum(sample_i)) / sum(len(sample_i))`，可以开启 `--calculate-per-token-loss`；
 - `--use-tis`：如果需要开启 tis（https://fengyao.notion.site/off-policy-rl），可以开启这一设置；
 
 #### GRPO 算法
@@ -278,9 +276,9 @@ megatron:
 
 ## 自定义 rollout 函数
 
-slime 支持不同程度的自定义数据生成（rollout）。
+vime 支持不同程度的自定义数据生成（rollout）。
 
-- 默认会使用 [slime/rollout/vllm_rollout.py](https://github.com/vllm-project/vime/blob/main/slime/rollout/vllm_rollout.py) 中的 `generate_rollout` 函数进行数据生成。这个文件中实现了基于 vLLM 的异步（asyncio）数据生成流程，并支持了例如 dynamic sampling，partial rollout 等功能；
+- 默认会使用 [vime/rollout/vllm_rollout.py](https://github.com/vllm-project/vime/blob/main/vime/rollout/vllm_rollout.py) 中的 `generate_rollout` 函数进行数据生成。这个文件中实现了基于 vLLM 的异步（asyncio）数据生成流程，并支持了例如 dynamic sampling，partial rollout 等功能；
 
 - 可以通过 `--rollout-function-path` 参数，完全替换默认的 `generate_rollout`，只需要保证 `--rollout-function-path` 传入的函数签名满足：
 
@@ -302,11 +300,11 @@ slime 支持不同程度的自定义数据生成（rollout）。
 
   其中：
 
-  -  `args` 为整个 slime 运行使用的 args；
+  -  `args` 为整个 vime 运行使用的 args；
   - `rollout_id` 对应的是当前是第几次数据生成，用作保证续训时的数据顺序；
-  - `data_source` 是 slime 中全局唯一的数据源，可以用来获取初始 prompt，数据 id，将生成至一半的 sample 存储下来下次留作下次使用等；
+  - `data_source` 是 vime 中全局唯一的数据源，可以用来获取初始 prompt，数据 id，将生成至一半的 sample 存储下来下次留作下次使用等；
   - `evaluation` 是否是当做 evaluation 使用。可以通过 `--eval-function-path` 单独配置 eval 的函数；
-  -  返回的 `Sample` 类型见 [slime/utils/types.py](https://github.com/THUDM/slime/blob/main/slime/utils/types.py)，在实现时，需要保证
+  -  返回的 `Sample` 类型见 [vime/utils/types.py](https://github.com/vllm-project/vime/blob/main/vime/utils/types.py)，在实现时，需要保证
      -   `tokens`：prompt + response 的 token；
      -  `response_length`：response 的总长。对于多轮任务，则是除去第一轮 prompt，剩余的 token 长度；
      -  `reward`：这条数据的 reward；
@@ -353,36 +351,36 @@ slime 支持不同程度的自定义数据生成（rollout）。
       return sample
   ```
 
-   更完备的版本请查看 [slime/rollout/vllm_rollout.py](https://github.com/vllm-project/vime/blob/main/slime/rollout/vllm_rollout.py)。
+   更完备的版本请查看 [vime/rollout/vllm_rollout.py](https://github.com/vllm-project/vime/blob/main/vime/rollout/vllm_rollout.py)。
 
 - 有的时候，我们还需要支持自定义的 reward model，可以通过配置 `--custom-rm-path` 来进行配置。
 
 ## vLLM 使用方法
 
-slime 以 server 模式运行 vLLM，通过 HTTP 与之通信。
+vime 以 server 模式运行 vLLM，通过 HTTP 与之通信。
 
 ### 参数配置
 
-slime 通过转发 vLLM 的 `EngineArgs` CLI 参数，引入了几乎所有的 vLLM 参数。在设置一个 vLLM 参数的时候，需要在参数前加上 `--vllm-` 的前缀，例如：
+vime 通过转发 vLLM 的 `EngineArgs` CLI 参数，引入了几乎所有的 vLLM 参数。在设置一个 vLLM 参数的时候，需要在参数前加上 `--vllm-` 的前缀，例如：
 
 - 在训推一体的训练时，往往需要限制 GPU 显存占用，传入 `--vllm-gpu-memory-utilization`；
-- 在训练中，希望 vLLM 能推理超过 huggingface checkpoint 的 `config.json` 中标识的最长 context length，需要使用 `--max-model-len`，那么在 slime 中需要使用 `--vllm-max-model-len`；
+- 在训练中，希望 vLLM 能推理超过 huggingface checkpoint 的 `config.json` 中标识的最长 context length，需要使用 `--max-model-len`，那么在 vime 中需要使用 `--vllm-max-model-len`；
 - 在进行多机大 ep 推理的时候，需要 `--enable-expert-parallel`、`--data-parallel-size` 等，则可以对应地传入 `--vllm-enable-expert-parallel`、`--vllm-data-parallel-size`。
 
-有部分参数和 slime 的资源调度相关，会由 slime 自行配置，例如：
+有部分参数和 vime 的资源调度相关，会由 vime 自行配置，例如：
 
-- `--tensor-parallel-size` 在 slime 中会使用 `--rollout-num-gpus-per-engine`
-- `--model` 在 slime 中会使用 `--hf-checkpoint`
+- `--tensor-parallel-size` 在 vime 中会使用 `--rollout-num-gpus-per-engine`
+- `--model` 在 vime 中会使用 `--hf-checkpoint`
 
-vLLM 参数引入 slime 的方式可以参考 [slime/backends/vllm_utils/arguments.py](https://github.com/vllm-project/vime/blob/main/slime/backends/vllm_utils/arguments.py)。
+vLLM 参数引入 vime 的方式可以参考 [vime/backends/vllm_utils/arguments.py](https://github.com/vllm-project/vime/blob/main/vime/backends/vllm_utils/arguments.py)。
 
 ### router 使用方法
 
-slime 会用 [vllm-router](https://github.com/vllm-project/router) 来管理训练过程中的 vLLM 引擎。可以通过 `--vllm-router-ip` 与 `--vllm-router-port` 来配置 router 的地址。如果不进行配置，则会在集群中默认启动一个 router。
+vime 会用 [vllm-router](https://github.com/vllm-project/router) 来管理训练过程中的 vLLM 引擎。可以通过 `--vllm-router-ip` 与 `--vllm-router-port` 来配置 router 的地址。如果不进行配置，则会在集群中默认启动一个 router。
 
 所有的 vLLM 引擎在启动后会注册到 router。在实际进行数据生成的时候，只需要向 router 发送 http 请求，router 会进行 load balancing 操作，将请求转发给引擎。
 
-当通过 `--vllm-router-ip` 与 `--vllm-router-port` 来配置传入一个外部的 router，此时 slime 不再会在内部启动一个 router，而是会把所有的引擎都注册在这个外部 router 上。这时可以利用这个外部的 router 地址来实现更复杂的数据生成流程。注意 router 是支持 openai compatible api 的。
+当通过 `--vllm-router-ip` 与 `--vllm-router-port` 来配置传入一个外部的 router，此时 vime 不再会在内部启动一个 router，而是会把所有的引擎都注册在这个外部 router 上。这时可以利用这个外部的 router 地址来实现更复杂的数据生成流程。注意 router 是支持 openai compatible api 的。
 
 ### 高级引擎配置（--vllm-config）
 
@@ -407,7 +405,7 @@ vllm:
         num_gpus_per_engine: 2
 ```
 
-每个模型都有自己独立的 router。每个模型的 router 信息可通过 `args.vllm_model_routers`（一个将模型名映射到 `(ip, port)` 元组的字典）访问。自定义 rollout 函数可以使用 `slime.rollout.vllm_rollout` 中的 `get_model_url(args, "ref")` 来将请求路由到指定模型。
+每个模型都有自己独立的 router。每个模型的 router 信息可通过 `args.vllm_model_routers`（一个将模型名映射到 `(ip, port)` 元组的字典）访问。自定义 rollout 函数可以使用 `vime.rollout.vllm_rollout` 中的 `get_model_url(args, "ref")` 来将请求路由到指定模型。
 
 **服务器组功能：**
 - `worker_type`：`regular`、`prefill`、`decode` 或 `placeholder`（预留 GPU 位置但不创建引擎）
@@ -416,11 +414,11 @@ vllm:
 
 ## megatron 使用方法
 
-slime 通过复用 `megatron.training` 目录下的常规函数，如 `parse_args`， `save_checkpoint`，`load_checkpoint`，从而实现对不同版本以及轻度魔改的 megatron 的支持。所以在使用时，需要保证 `PYTHONPATH` 中能访问到 megatron，例如在运行时加入 `export PYTHONPATH=/root/Megatron-LM`。
+vime 通过复用 `megatron.training` 目录下的常规函数，如 `parse_args`， `save_checkpoint`，`load_checkpoint`，从而实现对不同版本以及轻度魔改的 megatron 的支持。所以在使用时，需要保证 `PYTHONPATH` 中能访问到 megatron，例如在运行时加入 `export PYTHONPATH=/root/Megatron-LM`。
 
 ### 参数配置
 
-slime 通过直接引入 `from megatron.training.arguments import parse_args` 引入了当前环境中 megatron 的所有参数。如果当前使用的 megatron 有在 `parse_args` 之外的参数，可以通过像 [train.py](https://github.com/THUDM/slime/blob/main/train.py) 中传入参数来进行配置，例如：
+vime 通过直接引入 `from megatron.training.arguments import parse_args` 引入了当前环境中 megatron 的所有参数。如果当前使用的 megatron 有在 `parse_args` 之外的参数，可以通过像 [train.py](https://github.com/vllm-project/vime/blob/main/train.py) 中传入参数来进行配置，例如：
 
 ```python
 if __name__ == "__main__":
diff --git a/docs/zh/index.rst b/docs/zh/index.rst
index be92352ad..b4575c02b 100644
--- a/docs/zh/index.rst
+++ b/docs/zh/index.rst
@@ -1,12 +1,12 @@
-slime 文档
+vime 文档
 ====================
 
-slime 是一个面向 RL Scaling 的 LLM 后训练框架，提供两大核心能力：
+vime 是一个面向 RL Scaling 的 LLM 后训练框架，提供两大核心能力：
 
 - 高性能训练：通过连接 Megatron 与 vLLM，支持多种模式下的高效训练；
 - 灵活的数据生成：通过自定义数据生成接口与基于服务器的引擎，实现任意训练数据生成流程。
 
-slime 是 GLM-4.7、GLM-4.6、GLM-4.5 背后的 RL 训练框架。除此之外，slime 还支持:
+vime 是 GLM-4.7、GLM-4.6、GLM-4.5 背后的 RL 训练框架。除此之外，vime 还支持:
 
 - Qwen3 系列 (Qwen3Next, Qwen3MoE, Qwen3), Qwen2.5 系列；
 - DeepSeek V3 系列 (DeepSeek V3, V3.1, DeepSeek R1)；
diff --git a/examples/README.md b/examples/README.md
index 51a72f1f4..e1b822c2b 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -1,6 +1,6 @@
 # Examples
 
-These examples provide concrete examples to leverage slime in your own RL workflow. Some examples are just demonstrative, but most of them are verifiable with a concrete performance score.
+These examples provide concrete examples to leverage vime in your own RL workflow. Some examples are just demonstrative, but most of them are verifiable with a concrete performance score.
 
 ## Directory Structure
 
@@ -8,8 +8,6 @@ These examples provide concrete examples to leverage slime in your own RL workfl
 - **[fully_async](./fully_async)**: Demonstrates fully asynchronous rollout generation for higher efficiency.
 - **[geo3k_vlm](./geo3k_vlm)**: Training VLMs on a single-turn reasoning task using GRPO on the GEO3K dataset.
 - **[geo3k_vlm_multi_turn](./geo3k_vlm_multi_turn)**: VLM multi-turn training on Geo3k dataset.
-- **[low_precision](./low_precision)**: Examples of FP8 training and inference for improved throughput and stability.
-- **[multi_agent](./multi_agent)**: Example of running multi-agent RL with `slime`.
-- **[on_policy_distillation](./on_policy_distillation)**: Example implementation for on-policy distillation, extending the reinforcement learning pipeline to support teacher–student distillation directly within on-policy training.
+- **[multi_agent](./multi_agent)**: Example of running multi-agent RL with `vime`.
 - **[reproducibility](./reproducibility)**: Guides on achieving bitwise experiment reproduction using deterministic modes.
 - **[train_infer_mismatch_helper](./train_infer_mismatch_helper)**: Algorithmic methods for rollout correction (e.g., TIS, MIS).
diff --git a/examples/fully_async/README.md b/examples/fully_async/README.md
index 2545ada98..cd71455a4 100644
--- a/examples/fully_async/README.md
+++ b/examples/fully_async/README.md
@@ -12,7 +12,7 @@ First set up model & environment following the Qwen3-4B example.
 
 ## Quick Start
 ```bash
-cd slime
+cd vime
 bash examples/fully_async/run-qwen3-4b-fully_async.sh
 ```
 You should see log lines like:
diff --git a/examples/fully_async/run-qwen3-4b-fully_async.sh b/examples/fully_async/run-qwen3-4b-fully_async.sh
index 6535e08fa..76f6c5093 100644
--- a/examples/fully_async/run-qwen3-4b-fully_async.sh
+++ b/examples/fully_async/run-qwen3-4b-fully_async.sh
@@ -28,10 +28,9 @@ source "${SCRIPT_DIR}/../../scripts/models/qwen3-4B.sh"
 
 CKPT_ARGS=(
    --hf-checkpoint /root/Qwen3-4B
-   #--hf-checkpoint /root/Qwen3-4B-FP8
    --ref-load /root/Qwen3-4B_torch_dist
-   --load /root/Qwen3-4B_slime/
-   --save /root/Qwen3-4B_slime/
+   --load /root/Qwen3-4B_vime/
+   --save /root/Qwen3-4B_vime/
    --save-interval 20
 )
 
diff --git a/examples/geo3k_vlm/README.md b/examples/geo3k_vlm/README.md
index 77e5528f5..9ec55d7c7 100644
--- a/examples/geo3k_vlm/README.md
+++ b/examples/geo3k_vlm/README.md
@@ -12,7 +12,7 @@ Note: Please make sure the cudnn version in the environment is 9.16.0.29 to prev
 pip install nvidia-cudnn-cu12==9.16.0.29
 ```
 
-**Important:** We use [Megatron Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge) to support multimodal models. However, not all Megatron arguments are passed through to Megatron Bridge — you may need to set some manually [here](https://github.com/THUDM/slime/blob/de84e10d468dcb726e1199fd6bd16aa9538aed09/slime/backends/megatron_utils/model_provider.py#L89) (currently only parallelization-related arguments are passed). For example, for Qwen3-VL-30B-A3B you may need to add:
+**Important:** We use [Megatron Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge) to support multimodal models. However, not all Megatron arguments are passed through to Megatron Bridge — you may need to set some manually [here](https://github.com/vllm-project/vime/blob/main/vime/backends/megatron_utils/model_provider.py#L89) (currently only parallelization-related arguments are passed). For example, for Qwen3-VL-30B-A3B you may need to add:
 ```python
 provider.moe_aux_loss_coeff = args.moe_aux_loss_coeff
 provider.freeze_language_model = False
@@ -64,7 +64,7 @@ export WANDB_API_KEY=your_wandb_api_key
 ./examples/geo3k_vlm/run_geo3k_vlm.sh
 
 # With different model
-SLIME_SCRIPT_MODEL_NAME=Qwen3-VL-4B-Instruct ./examples/geo3k_vlm/run_geo3k_vlm.sh
+VIME_SCRIPT_MODEL_NAME=Qwen3-VL-4B-Instruct ./examples/geo3k_vlm/run_geo3k_vlm.sh
 
 # SFT
 ./examples/geo_3k_vlm/run_geo3k_vlm_sft.sh
@@ -74,10 +74,10 @@ SLIME_SCRIPT_MODEL_NAME=Qwen3-VL-4B-Instruct ./examples/geo3k_vlm/run_geo3k_vlm.
 
 | Environment Variable | Default | Description |
 |---------------------|---------|-------------|
-| `SLIME_SCRIPT_MODEL_NAME` | `Qwen3-VL-8B-Instruct` | Model name |
-| `SLIME_SCRIPT_DATASET_NAME` | `chenhegu/geo3k_imgurl` | HuggingFace dataset name |
-| `SLIME_SCRIPT_NUM_GPUS` | `8` | Number of GPUs |
-| `SLIME_SCRIPT_EXTERNAL_RAY` | `0` | Use external Ray cluster (`1` to enable) |
+| `VIME_SCRIPT_MODEL_NAME` | `Qwen3-VL-8B-Instruct` | Model name |
+| `VIME_SCRIPT_DATASET_NAME` | `chenhegu/geo3k_imgurl` | HuggingFace dataset name |
+| `VIME_SCRIPT_NUM_GPUS` | `8` | Number of GPUs |
+| `VIME_SCRIPT_EXTERNAL_RAY` | `0` | Use external Ray cluster (`1` to enable) |
 
 ### Supported Models
 
@@ -112,7 +112,7 @@ All three performed similarly, so we use the default math RM for simplicity.
 
 Our initial geo3k-specific verifier produced "format scores" (**0 and 0.9**) instead of clean binary rewards. Under **fp32**, fractional values like 0.9 can't be exactly represented, so when all samples in a group have the same reward, `reward - mean` doesn't equal zero—creating spurious gradient signal.
 
-We fixed this by switching to the default math RM with clean **binary 0/1 rewards**. If you encounter similar precision issues with non-binary rewards, you can change the reward tensor dtype from `torch.float` to `torch.float16` in `slime/ray/rollout.py` (`_post_process_rewards` method) to truncate precision artifacts.
+We fixed this by switching to the default math RM with clean **binary 0/1 rewards**. If you encounter similar precision issues with non-binary rewards, you can change the reward tensor dtype from `torch.float` to `torch.float16` in `vime/ray/rollout.py` (`_post_process_rewards` method) to truncate precision artifacts.
 
 ## B200
 On Blackwell (SM100), vllm automatically dispatches the ViT encoder to
diff --git a/examples/geo3k_vlm/run_geo3k_qwen35.sh b/examples/geo3k_vlm/run_geo3k_qwen35.sh
index 3ae747fb8..d908b5f04 100644
--- a/examples/geo3k_vlm/run_geo3k_qwen35.sh
+++ b/examples/geo3k_vlm/run_geo3k_qwen35.sh
@@ -14,14 +14,14 @@ pip install git+https://github.com/coding-famer/Megatron-Bridge-vime.git@qwen35
 # Configuration
 TRAIN_BACKEND="megatron"
 MODEL_NAME="Qwen3_5-35B-A3B"
-DATASET_NAME=${SLIME_SCRIPT_DATASET_NAME:-"chenhegu/geo3k_imgurl"}
-NUM_GPUS=${SLIME_SCRIPT_NUM_GPUS:-8}
+DATASET_NAME=${VIME_SCRIPT_DATASET_NAME:-"chenhegu/geo3k_imgurl"}
+NUM_GPUS=${VIME_SCRIPT_NUM_GPUS:-8}
 DATASET_LOCAL_NAME=$(basename "$DATASET_NAME")
 
 MODEL_NAME_LOWER=$(echo "$MODEL_NAME" | tr '[:upper:]' '[:lower:]')
 
 # External Ray flag
-if [ -z "$SLIME_SCRIPT_EXTERNAL_RAY" ] || [ "$SLIME_SCRIPT_EXTERNAL_RAY" = "0" ]; then
+if [ -z "$VIME_SCRIPT_EXTERNAL_RAY" ] || [ "$VIME_SCRIPT_EXTERNAL_RAY" = "0" ]; then
    USE_EXTERNAL_RAY=0
 else
    USE_EXTERNAL_RAY=1
@@ -169,8 +169,8 @@ BACKEND_ARGS=(
    --micro-batch-size 1
 )
 
-SLIME_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/../.." &>/dev/null && pwd)"
-source "${SLIME_DIR}/scripts/models/qwen3.5-35B-A3B.sh"
+VIME_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/../.." &>/dev/null && pwd)"
+source "${VIME_DIR}/scripts/models/qwen3.5-35B-A3B.sh"
 
 # Start Ray if not using external Ray
 if [ "$USE_EXTERNAL_RAY" = "0" ]; then
diff --git a/examples/geo3k_vlm/run_geo3k_vlm.sh b/examples/geo3k_vlm/run_geo3k_vlm.sh
index 756ef5bfa..83a55270d 100644
--- a/examples/geo3k_vlm/run_geo3k_vlm.sh
+++ b/examples/geo3k_vlm/run_geo3k_vlm.sh
@@ -3,12 +3,12 @@
 # Qwen3 VL RL training on geo3k dataset with non-colocated vLLM rollout.
 # Uses 4 GPUs for Megatron training and 4 GPUs for vLLM rollout.
 # Usage: 
-#   SLIME_SCRIPT_MODEL_NAME=Qwen3-VL-2B-Instruct ./run_geo3k_vlm.sh
+#   VIME_SCRIPT_MODEL_NAME=Qwen3-VL-2B-Instruct ./run_geo3k_vlm.sh
 
 # Configuration
 TRAIN_BACKEND="megatron"
-MODEL_NAME=${SLIME_SCRIPT_MODEL_NAME:-"Qwen3-VL-8B-Instruct"}
-DATASET_NAME=${SLIME_SCRIPT_DATASET_NAME:-"chenhegu/geo3k_imgurl"}
+MODEL_NAME=${VIME_SCRIPT_MODEL_NAME:-"Qwen3-VL-8B-Instruct"}
+DATASET_NAME=${VIME_SCRIPT_DATASET_NAME:-"chenhegu/geo3k_imgurl"}
 TOTAL_GPUS=8
 TRAIN_GPUS=4
 ROLLOUT_GPUS=4
@@ -39,7 +39,7 @@ fi
 MODEL_NAME_LOWER=$(echo "$MODEL_NAME" | tr '[:upper:]' '[:lower:]')
 
 # External Ray flag
-if [ -z "$SLIME_SCRIPT_EXTERNAL_RAY" ] || [ "$SLIME_SCRIPT_EXTERNAL_RAY" = "0" ]; then
+if [ -z "$VIME_SCRIPT_EXTERNAL_RAY" ] || [ "$VIME_SCRIPT_EXTERNAL_RAY" = "0" ]; then
    USE_EXTERNAL_RAY=0
 else
    USE_EXTERNAL_RAY=1
@@ -181,10 +181,10 @@ BACKEND_ARGS=(
 )
 
 # get MODEL_ARGS from scripts/models for megatron backend
-SLIME_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/../.." &>/dev/null && pwd)"
+VIME_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/../.." &>/dev/null && pwd)"
 MODEL_ARGS_FILE=$(echo "$MODEL_NAME" | sed 's/-Instruct//g; s/-Thinking//g; s/Qwen3-VL-/qwen3-/g; s/-2B/-1.7B/g')
 # VL models require rotary-base 5000000
-MODEL_ARGS_ROTARY_BASE=5000000 source "${SLIME_DIR}/scripts/models/${MODEL_ARGS_FILE}.sh"
+MODEL_ARGS_ROTARY_BASE=5000000 source "${VIME_DIR}/scripts/models/${MODEL_ARGS_FILE}.sh"
 
 # Start Ray if not using external Ray
 if [ "$USE_EXTERNAL_RAY" = "0" ]; then
diff --git a/examples/geo3k_vlm/run_geo3k_vlm_sft.sh b/examples/geo3k_vlm/run_geo3k_vlm_sft.sh
index 9c99735f0..5870f6212 100644
--- a/examples/geo3k_vlm/run_geo3k_vlm_sft.sh
+++ b/examples/geo3k_vlm/run_geo3k_vlm_sft.sh
@@ -1,7 +1,7 @@
 TRAIN_BACKEND="megatron"
-MODEL_NAME=${SLIME_SCRIPT_MODEL_NAME:-"Qwen3-VL-8B-Instruct"}
-DATASET_NAME=${SLIME_SCRIPT_DATASET_NAME:-"chenhegu/geo3k_imgurl"}
-NUM_GPUS=${SLIME_SCRIPT_NUM_GPUS:-8}
+MODEL_NAME=${VIME_SCRIPT_MODEL_NAME:-"Qwen3-VL-8B-Instruct"}
+DATASET_NAME=${VIME_SCRIPT_DATASET_NAME:-"chenhegu/geo3k_imgurl"}
+NUM_GPUS=${VIME_SCRIPT_NUM_GPUS:-8}
 DATASET_LOCAL_NAME=$(basename "$DATASET_NAME")
 
 # Validate MODEL_NAME
@@ -29,7 +29,7 @@ fi
 MODEL_NAME_LOWER=$(echo "$MODEL_NAME" | tr '[:upper:]' '[:lower:]')
 
 # External Ray flag
-if [ -z "$SLIME_SCRIPT_EXTERNAL_RAY" ] || [ "$SLIME_SCRIPT_EXTERNAL_RAY" = "0" ]; then
+if [ -z "$VIME_SCRIPT_EXTERNAL_RAY" ] || [ "$VIME_SCRIPT_EXTERNAL_RAY" = "0" ]; then
    USE_EXTERNAL_RAY=0
 else
    USE_EXTERNAL_RAY=1
@@ -144,10 +144,10 @@ BACKEND_ARGS=(
 )
 
 # get MODEL_ARGS from scripts/models for megatron backend
-SLIME_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/../.." &>/dev/null && pwd)"
+VIME_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/../.." &>/dev/null && pwd)"
 MODEL_ARGS_FILE=$(echo "$MODEL_NAME" | sed 's/-Instruct//g; s/-Thinking//g; s/Qwen3-VL-/qwen3-/g; s/-2B/-1.7B/g')
 # VL models require rotary-base 5000000
-MODEL_ARGS_ROTARY_BASE=5000000 source "${SLIME_DIR}/scripts/models/${MODEL_ARGS_FILE}.sh"
+MODEL_ARGS_ROTARY_BASE=5000000 source "${VIME_DIR}/scripts/models/${MODEL_ARGS_FILE}.sh"
 
 # Start Ray if not using external Ray
 if [ "$USE_EXTERNAL_RAY" = "0" ]; then
diff --git a/examples/geo3k_vlm_multi_turn/README.md b/examples/geo3k_vlm_multi_turn/README.md
index 101f86d29..e303fc230 100644
--- a/examples/geo3k_vlm_multi_turn/README.md
+++ b/examples/geo3k_vlm_multi_turn/README.md
@@ -28,14 +28,14 @@ The reward model is the default math RM.
 ```bash
 # 1) Set environment variable
 export WANDB_API_KEY=...
-export SLIME_SCRIPT_MODEL_NAME=Qwen3-VL-2B-Instruct
-export SLIME_SCRIPT_NUM_GPUS=4
+export VIME_SCRIPT_MODEL_NAME=Qwen3-VL-2B-Instruct
+export VIME_SCRIPT_NUM_GPUS=4
 
 # 2) Download the dataset
 hf download --repo-type dataset VeraIsHere/geo3k_imgurl_processed --local-dir /root/datasets/geo3k_imgurl_processed
 
 # 3) Run the script:
-cd /root/slime
+cd /root/vime
 python examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn.py
 ```
 
diff --git a/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn.py b/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn.py
index 5b124d518..399d8cfa2 100644
--- a/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn.py
+++ b/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn.py
@@ -3,7 +3,7 @@
 import vime.utils.misc as U
 from vime.utils.external_utils.command_utils import execute_train
 
-MODEL_NAME = os.environ.get("SLIME_SCRIPT_MODEL_NAME", "Qwen3-VL-2B-Instruct")
+MODEL_NAME = os.environ.get("VIME_SCRIPT_MODEL_NAME", "Qwen3-VL-2B-Instruct")
 assert MODEL_NAME in {
     "Qwen3-VL-2B-Instruct",
     "Qwen3-VL-4B-Instruct",
@@ -13,8 +13,8 @@
     "Qwen3-VL-8B-Thinking",
 }
 
-NUM_GPUS = int(os.environ.get("SLIME_SCRIPT_NUM_GPUS", "4"))
-EXTERNAL_RAY = int(os.environ.get("SLIME_SCRIPT_EXTERNAL_RAY", "0"))
+NUM_GPUS = int(os.environ.get("VIME_SCRIPT_NUM_GPUS", "4"))
+EXTERNAL_RAY = int(os.environ.get("VIME_SCRIPT_EXTERNAL_RAY", "0"))
 
 DATASET_NAME = "VeraIsHere/geo3k_imgurl_processed"
 DATA_ROOT = "/root/datasets/geo3k_imgurl_processed"
diff --git a/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn_grpo_npu.py b/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn_grpo_npu.py
index 7a304c9e7..31cb94efd 100644
--- a/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn_grpo_npu.py
+++ b/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn_grpo_npu.py
@@ -2,7 +2,7 @@
 
 from vime.utils.external_utils.command_utils import execute_train_npu
 
-MODEL_NAME = os.environ.get("SLIME_SCRIPT_MODEL_NAME", "Qwen3-VL-2B-Instruct")
+MODEL_NAME = os.environ.get("VIME_SCRIPT_MODEL_NAME", "Qwen3-VL-2B-Instruct")
 assert MODEL_NAME in {
     "Qwen3-VL-2B-Instruct",
     "Qwen3-VL-4B-Instruct",
@@ -12,8 +12,8 @@
     "Qwen3-VL-8B-Thinking",
 }
 
-EXTERNAL_RAY = int(os.environ.get("SLIME_SCRIPT_EXTERNAL_RAY", "0"))
-TRAIN_BACKEND = os.environ.get("SLIME_SCRIPT_TRAIN_BACKEND", "fsdp").lower()
+EXTERNAL_RAY = int(os.environ.get("VIME_SCRIPT_EXTERNAL_RAY", "0"))
+TRAIN_BACKEND = os.environ.get("VIME_SCRIPT_TRAIN_BACKEND", "fsdp").lower()
 assert TRAIN_BACKEND in {"fsdp", "megatron"}
 
 DATASET_NAME = "VeraIsHere/geo3k_imgurl_processed"
diff --git a/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn_ppo_npu.py b/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn_ppo_npu.py
index fcd76935e..65e9db8bf 100644
--- a/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn_ppo_npu.py
+++ b/examples/geo3k_vlm_multi_turn/run_geo3k_vlm_multi_turn_ppo_npu.py
@@ -3,7 +3,7 @@
 
 from vime.utils.external_utils.command_utils import execute_train_npu
 
-MODEL_NAME = os.environ.get("SLIME_SCRIPT_MODEL_NAME", "Qwen3-VL-2B-Instruct")
+MODEL_NAME = os.environ.get("VIME_SCRIPT_MODEL_NAME", "Qwen3-VL-2B-Instruct")
 assert MODEL_NAME in {
     "Qwen3-VL-2B-Instruct",
     "Qwen3-VL-4B-Instruct",
@@ -13,8 +13,8 @@
     "Qwen3-VL-8B-Thinking",
 }
 
-EXTERNAL_RAY = int(os.environ.get("SLIME_SCRIPT_EXTERNAL_RAY", "0"))
-TRAIN_BACKEND = os.environ.get("SLIME_SCRIPT_TRAIN_BACKEND", "fsdp").lower()
+EXTERNAL_RAY = int(os.environ.get("VIME_SCRIPT_EXTERNAL_RAY", "0"))
+TRAIN_BACKEND = os.environ.get("VIME_SCRIPT_TRAIN_BACKEND", "fsdp").lower()
 assert TRAIN_BACKEND in {"fsdp", "megatron"}
 
 DATASET_NAME = "VeraIsHere/geo3k_imgurl_processed"
diff --git a/examples/geo3k_vlm_multi_turn/run_grpo_npu.sh b/examples/geo3k_vlm_multi_turn/run_grpo_npu.sh
index 8eb886ec6..cb5a84db2 100644
--- a/examples/geo3k_vlm_multi_turn/run_grpo_npu.sh
+++ b/examples/geo3k_vlm_multi_turn/run_grpo_npu.sh
@@ -1,5 +1,5 @@
-export SLIME_SCRIPT_MODEL_NAME=Qwen3-VL-8B-Instruct
-export SLIME_SCRIPT_TRAIN_BACKEND=megatron
+export VIME_SCRIPT_MODEL_NAME=Qwen3-VL-8B-Instruct
+export VIME_SCRIPT_TRAIN_BACKEND=megatron
 export PYTORCH_ALLOC_CONF=expandable_segments:True
 export PYTHONPATH="/root/Megatron-Bridge/src:/root/Megatron-LM/:$PYTHONPATH"
 export ASCEND_RT_VISIBLE_DEVICES=0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
diff --git a/examples/geo3k_vlm_multi_turn/run_ppo_npu.sh b/examples/geo3k_vlm_multi_turn/run_ppo_npu.sh
index 75a88730d..e67de2e78 100644
--- a/examples/geo3k_vlm_multi_turn/run_ppo_npu.sh
+++ b/examples/geo3k_vlm_multi_turn/run_ppo_npu.sh
@@ -1,5 +1,5 @@
-export SLIME_SCRIPT_MODEL_NAME=Qwen3-VL-8B-Instruct
-export SLIME_SCRIPT_TRAIN_BACKEND=megatron
+export VIME_SCRIPT_MODEL_NAME=Qwen3-VL-8B-Instruct
+export VIME_SCRIPT_TRAIN_BACKEND=megatron
 export PYTORCH_ALLOC_CONF=expandable_segments:True
 export PYTHONPATH="/root/Megatron-Bridge/src:/root/Megatron-LM/:$PYTHONPATH"
 export ASCEND_RT_VISIBLE_DEVICES=0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
diff --git a/examples/multi_agent/README.md b/examples/multi_agent/README.md
index c91aa8df1..b3126d4fb 100644
--- a/examples/multi_agent/README.md
+++ b/examples/multi_agent/README.md
@@ -1,10 +1,10 @@
 # Multi-Agent RL
 
-This directory provides an example of running multi-agent reinforcement learning (RL) with slime.
+This directory provides an example of running multi-agent reinforcement learning (RL) with vime.
 
 ## Environment Setup
 
-The environment setup is identical to the standard RL setup used in slime.
+The environment setup is identical to the standard RL setup used in vime.
 
 ## Running the Script
 
@@ -22,7 +22,7 @@ MULTI_AGENT_CONFIGS = {
 To start a run, execute:
 
 ```bash
-cd slime/
+cd vime/
 bash examples/multi_agent/run-qwen3-30B-A3B-multi-agent.sh
 ```
 
diff --git a/examples/multi_agent/run-qwen3-30B-A3B-multi-agent.sh b/examples/multi_agent/run-qwen3-30B-A3B-multi-agent.sh
index de79b41be..c528f9c59 100644
--- a/examples/multi_agent/run-qwen3-30B-A3B-multi-agent.sh
+++ b/examples/multi_agent/run-qwen3-30B-A3B-multi-agent.sh
@@ -28,10 +28,9 @@ source "/root/vime/scripts/models/qwen3-30B-A3B.sh"
 
 CKPT_ARGS=(
    --hf-checkpoint /root/Qwen3-30B-A3B
-   #--hf-checkpoint /root/Qwen3-30B-A3B-FP8
    --ref-load /root/Qwen3-30B-A3B_torch_dist
-   --load /root/Qwen3-4B_slime/
-   --save /root/Qwen3-4B_slime/
+   --load /root/Qwen3-4B_vime/
+   --save /root/Qwen3-4B_vime/
    --save-interval 20
 )
 
diff --git a/examples/train_infer_mismatch_helper/README.md b/examples/train_infer_mismatch_helper/README.md
index 552fa29e6..81e5588bc 100644
--- a/examples/train_infer_mismatch_helper/README.md
+++ b/examples/train_infer_mismatch_helper/README.md
@@ -172,7 +172,7 @@ Reject entire sequence if $\exists t \in T$ such that $\rho_t < C_{\text{veto}}$
 
 ## Mismatch Metrics
 
-When rollout log probabilities are available, SLIME automatically tracks comprehensive metrics to monitor training-inference mismatch and importance sampling weights. These metrics help diagnose policy divergence and guide hyperparameter tuning.
+When rollout log probabilities are available, VIME automatically tracks comprehensive metrics to monitor training-inference mismatch and importance sampling weights. These metrics help diagnose policy divergence and guide hyperparameter tuning.
 
 ### Mismatch Monitoring Metrics
 
diff --git a/examples/train_infer_mismatch_helper/run-qwen3-4b-mis.sh b/examples/train_infer_mismatch_helper/run-qwen3-4b-mis.sh
index 92fbcd804..e40fbba7b 100644
--- a/examples/train_infer_mismatch_helper/run-qwen3-4b-mis.sh
+++ b/examples/train_infer_mismatch_helper/run-qwen3-4b-mis.sh
@@ -28,10 +28,9 @@ source "/root/vime/scripts/models/qwen3-4B.sh"
 
 CKPT_ARGS=(
    --hf-checkpoint /root/Qwen3-4B
-   #--hf-checkpoint /root/Qwen3-4B-FP8
    --ref-load /root/Qwen3-4B_torch_dist
-   # --load /root/Qwen3-4B_slime/
-   --save /root/Qwen3-4B_slime/
+   # --load /root/Qwen3-4B_vime/
+   --save /root/Qwen3-4B_vime/
    --save-interval 200
 )
 
@@ -154,4 +153,4 @@ ray job submit --address="http://127.0.0.1:8265" \
    ${EVAL_ARGS[@]} \
    ${VLLM_ARGS[@]} \
    ${MISC_ARGS[@]} \
-   ${CUSTOM_ARGS[@]}
\ No newline at end of file
+   ${CUSTOM_ARGS[@]}
diff --git a/scripts/run-glm4.7-30B-A3B.sh b/scripts/run-glm4.7-30B-A3B.sh
new file mode 100644
index 000000000..d54875d6c
--- /dev/null
+++ b/scripts/run-glm4.7-30B-A3B.sh
@@ -0,0 +1,169 @@
+#!/bin/bash
+
+# for rerun the task
+pkill -9 -f "vllm serve"
+sleep 3
+ray stop --force
+pkill -9 ray
+pkill -9 python
+sleep 3
+pkill -9 ray
+pkill -9 python
+
+set -ex
+
+# will prevent ray from buffering stdout/stderr
+export PYTHONBUFFERED=16
+
+unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY
+
+NVLINK_COUNT=$(nvidia-smi topo -m 2>/dev/null | grep -o 'NV[0-9][0-9]*' | wc -l)
+if [ "$NVLINK_COUNT" -gt 0 ]; then
+    HAS_NVLINK=1
+else
+    HAS_NVLINK=0
+fi
+echo "HAS_NVLINK: $HAS_NVLINK (detected $NVLINK_COUNT NVLink references)"
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
+source "${SCRIPT_DIR}/../scripts/models/glm4.7-30B-A3B.sh"
+
+CKPT_ARGS=(
+   --hf-checkpoint $BASE_DIR/GLM-4.7-Flash
+   --ref-load $BASE_DIR/GLM-4.7-Flash_torch_dist/
+)
+
+ROLLOUT_ARGS=(
+   --prompt-data $BASE_DIR/dapo-math-17k/dapo-math-17k.jsonl
+   --input-key prompt
+   --label-key label
+   --apply-chat-template
+   --rollout-shuffle
+
+   --rm-type deepscaler
+
+   --num-rollout 3000
+   --rollout-batch-size 128
+   --n-samples-per-prompt 8
+   --rollout-max-response-len 32768
+   --rollout-temperature 1.0
+
+   --global-batch-size 1024
+   #--balance-data
+)
+
+EVAL_ARGS=(
+   --eval-interval 20
+   --eval-prompt-data aime24 $BASE_DIR/rl_data/aime-2024.jsonl
+   --n-samples-per-eval-prompt 2
+   --eval-max-response-len 32768
+   --eval-temperature 1.0
+   --eval-top-p 0.95
+)
+
+PERF_ARGS=(
+   --tensor-model-parallel-size 2
+   --sequence-parallel
+   --pipeline-model-parallel-size 2
+   --context-parallel-size 2
+   --expert-model-parallel-size 8
+   --expert-tensor-parallel-size 1
+   --decoder-last-pipeline-num-layers 23
+
+   --recompute-granularity full
+   --recompute-method uniform
+   --recompute-num-layers 1
+
+   --use-dynamic-batch-size
+   --max-tokens-per-gpu 32768
+)
+
+MTP_ARGS=(
+   --mtp-num-layers 1
+   --enable-mtp-training
+   --mtp-loss-scaling-factor 0.2
+)
+
+GRPO_ARGS=(
+   --advantage-estimator grpo
+   --use-kl-loss
+   --kl-loss-coef 0.00
+   --kl-loss-type low_var_kl
+   --kl-coef 0.00
+   --entropy-coef 0.00
+)
+
+OPTIMIZER_ARGS=(
+   --optimizer adam
+   --lr 1e-6
+   --lr-decay-style constant
+   --weight-decay 0.1
+   --adam-beta1 0.9
+   --adam-beta2 0.98
+
+   --optimizer-cpu-offload
+   --overlap-cpu-optimizer-d2h-h2d
+   --use-precision-aware-optimizer
+)
+
+WANDB_ARGS=(
+   # --use-wandb
+   # --wandb-project vime-dev
+   # --wandb-group glm4.7-flash
+)
+
+VLLM_ARGS=(
+   --rollout-num-gpus-per-engine 8
+   --vllm-gpu-memory-utilization 0.8
+   --vllm-data-parallel-size 8
+
+   # mtp
+   --vllm-speculative-config '{"method":"mtp","num_speculative_tokens":3}'
+   --vllm-max-cudagraph-capture-size 64
+   --vllm-max-num-seqs 512
+)
+
+MISC_ARGS=(
+   # default dropout in megatron is 0.1
+   --attention-dropout 0.0
+   --hidden-dropout 0.0
+   # should be good for model performance
+   --accumulate-allreduce-grads-in-fp32
+   --attention-softmax-in-fp32
+   # need to comment this when using model with MLA
+   --attention-backend flash
+
+   --moe-token-dispatcher-type flex
+   --moe-enable-deepep
+)
+
+# launch the master node of ray in container
+export MASTER_ADDR=${MASTER_ADDR:-"127.0.0.1"}
+ray start --head --node-ip-address ${MASTER_ADDR} --num-gpus 8 --disable-usage-stats --dashboard-host=0.0.0.0 --dashboard-port=8265
+
+# Build the runtime environment JSON with proper variable substitution
+RUNTIME_ENV_JSON="{
+  \"env_vars\": {
+    \"PYTHONPATH\": \"/root/Megatron-LM/\",
+    \"CUDA_DEVICE_MAX_CONNECTIONS\": \"1\",
+    \"NCCL_NVLS_ENABLE\": \"${HAS_NVLINK}\"
+  }
+}"
+
+ray job submit --address="http://127.0.0.1:8265" \
+   --runtime-env-json="${RUNTIME_ENV_JSON}" \
+   -- python3 train.py \
+   --actor-num-nodes 1 \
+   --actor-num-gpus-per-node 8 \
+   --colocate \
+   ${MODEL_ARGS[@]} \
+   ${CKPT_ARGS[@]} \
+   ${ROLLOUT_ARGS[@]} \
+   ${OPTIMIZER_ARGS[@]} \
+   ${GRPO_ARGS[@]} \
+   ${WANDB_ARGS[@]} \
+   ${PERF_ARGS[@]} \
+   ${EVAL_ARGS[@]} \
+   ${VLLM_ARGS[@]} \
+   ${MISC_ARGS[@]} \
+   ${MTP_ARGS[@]}
diff --git a/scripts/run-glm4.7-355B-A32B.sh b/scripts/run-glm4.7-355B-A32B.sh
new file mode 100644
index 000000000..efdb70ded
--- /dev/null
+++ b/scripts/run-glm4.7-355B-A32B.sh
@@ -0,0 +1,194 @@
+#!/bin/bash
+
+# for rerun the task
+pkill -9 -f "vllm serve"
+sleep 3
+ray stop --force
+pkill -9 ray
+pkill -9 python
+sleep 3
+pkill -9 ray
+pkill -9 python
+
+set -ex
+
+# will prevent ray from buffering stdout/stderr
+export PYTHONBUFFERED=16
+
+unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY
+
+NVLINK_COUNT=$(nvidia-smi topo -m 2>/dev/null | grep -o 'NV[0-9][0-9]*' | wc -l)
+if [ "$NVLINK_COUNT" -gt 0 ]; then
+    HAS_NVLINK=1
+else
+    HAS_NVLINK=0
+fi
+echo "HAS_NVLINK: $HAS_NVLINK (detected $NVLINK_COUNT NVLink references)"
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
+source "${SCRIPT_DIR}/models/glm4.5-355B-A32B.sh"
+
+CKPT_ARGS=(
+   --hf-checkpoint $BASE_DIR/GLM-4.7-355B-A32B
+   --ref-load $BASE_DIR/GLM-4.7-355B-A32B_torch_dist/
+)
+
+ROLLOUT_ARGS=(
+   --prompt-data $BASE_DIR/dapo-math-17k/dapo-math-17k.jsonl
+   --input-key prompt
+   --label-key label
+   --apply-chat-template
+   --rollout-shuffle
+   --rm-type deepscaler
+   --num-rollout 3000
+   --rollout-batch-size 128
+   --n-samples-per-prompt 8
+   --rollout-max-response-len 32768
+   --rollout-temperature 1
+
+   --over-sampling-batch-size 256
+   --dynamic-sampling-filter-path vime.rollout.filter_hub.dynamic_sampling_filters.check_reward_nonzero_std
+
+   --num-steps-per-rollout 4
+   --balance-data
+   --rollout-stop-token-ids 151329 151336 151338
+)
+
+EVAL_ARGS=(
+   --eval-interval 20
+   --eval-prompt-data aime $BASE_DIR/rl_data/aime-2024.jsonl
+   --n-samples-per-eval-prompt 8
+   --eval-max-response-len 32768
+   --eval-top-p 1
+)
+
+PERF_ARGS=(
+   --tensor-model-parallel-size 8
+   --sequence-parallel
+   --pipeline-model-parallel-size 4
+   --context-parallel-size 2
+   --expert-model-parallel-size 16
+   --expert-tensor-parallel-size 1
+
+   --recompute-granularity full
+   --recompute-method uniform
+   --recompute-num-layers 1
+
+   --use-dynamic-batch-size
+   --max-tokens-per-gpu 16384
+)
+
+GRPO_ARGS=(
+   --advantage-estimator gspo
+   #--use-kl-loss
+   --kl-loss-coef 0.00
+   --kl-loss-type low_var_kl
+   --kl-coef 0.00
+   --entropy-coef 0.00
+   --eps-clip 1e-4
+   --eps-clip-high 2e-4
+
+   --use-tis
+)
+
+OPTIMIZER_ARGS=(
+   --optimizer adam
+   --lr 1e-6
+   --lr-decay-style constant
+   --weight-decay 0.1
+   --adam-beta1 0.9
+   --adam-beta2 0.98
+
+   --optimizer-cpu-offload
+   --overlap-cpu-optimizer-d2h-h2d
+   --use-precision-aware-optimizer
+)
+
+WANDB_ARGS=(
+   # --use-wandb
+   # --wandb-project vime-dev
+   # --wandb-group glm4.7-355B
+)
+
+VLLM_ARGS=(
+   --rollout-num-gpus-per-engine 32
+   --vllm-gpu-memory-utilization 0.7
+   --vllm-data-parallel-size 4
+
+   # mtp
+   --vllm-enable-expert-parallel
+   --vllm-speculative-config '{"method":"mtp","num_speculative_tokens":3}'
+)
+
+MISC_ARGS=(
+   # default dropout in megatron is 0.1
+   --attention-dropout 0.0
+   --hidden-dropout 0.0
+   # should be good for model performance
+   --accumulate-allreduce-grads-in-fp32
+   --attention-softmax-in-fp32
+   # need to comment this when using model with MLA
+   --attention-backend flash
+
+   --moe-token-dispatcher-type flex
+   --moe-enable-deepep
+)
+
+ACTOR_NUM_NODES=${ACTOR_NUM_NODES:-8}
+ACTOR_NUM_GPUS_PER_NODE=${ACTOR_NUM_GPUS_PER_NODE:-8}
+SOCKET_IFNAME=${SOCKET_IFNAME:-eth0}
+
+MASTER_ADDR=${MASTER_ADDR:-}
+if [ -z "${MASTER_ADDR}" ]; then
+  echo "MASTER_ADDR is not set. Please set it to the master node address."
+  exit 1
+fi
+
+# launch the master node of ray
+export no_proxy="127.0.0.1,${MASTER_ADDR}"
+ray start --head --node-ip-address "${MASTER_ADDR}" --num-gpus "${ACTOR_NUM_GPUS_PER_NODE}" --disable-usage-stats --dashboard-host=0.0.0.0 --dashboard-port=8265
+
+HOSTFILE=${HOSTFILE:-}
+if [ -n "${HOSTFILE}" ]; then
+  for WORKER_IP in $(awk '{print $1}' "${HOSTFILE}"); do
+    if [[ "${WORKER_IP}" == "${MASTER_ADDR}" ]]; then
+      continue
+    fi
+    echo "Starting Ray worker on ${WORKER_IP}"
+    ssh root@"${WORKER_IP}" \
+      "pkill -9 -f 'vllm serve' ; ray stop --force ; pkill -9 python ; ray start --address=${MASTER_ADDR}:6379 --num-gpus ${ACTOR_NUM_GPUS_PER_NODE} --node-ip-address ${WORKER_IP} --disable-usage-stats" &
+  done
+  wait
+fi
+
+RUNTIME_ENV_JSON=$(cat <<EOF_JSON
+{
+  "env_vars": {
+    "no_proxy": "localhost,127.0.0.1,0.0.0.0,${MASTER_ADDR}",
+    "GLOO_SOCKET_IFNAME": "${SOCKET_IFNAME}",
+    "TP_SOCKET_IFNAME": "${SOCKET_IFNAME}",
+    "MASTER_ADDR": "${MASTER_ADDR}",
+    "PYTHONPATH": "/root/Megatron-LM/",
+    "CUDA_DEVICE_MAX_CONNECTIONS": "1",
+    "NCCL_NVLS_ENABLE": "${HAS_NVLINK}"
+  }
+}
+EOF_JSON
+)
+
+ray job submit --address="http://127.0.0.1:8265" \
+   --runtime-env-json="${RUNTIME_ENV_JSON}" \
+   -- python3 train.py \
+   --actor-num-nodes "${ACTOR_NUM_NODES}" \
+   --actor-num-gpus-per-node "${ACTOR_NUM_GPUS_PER_NODE}" \
+   --colocate \
+   ${MODEL_ARGS[@]} \
+   ${CKPT_ARGS[@]} \
+   ${ROLLOUT_ARGS[@]} \
+   ${OPTIMIZER_ARGS[@]} \
+   ${GRPO_ARGS[@]} \
+   ${WANDB_ARGS[@]} \
+   ${PERF_ARGS[@]} \
+   ${EVAL_ARGS[@]} \
+   ${VLLM_ARGS[@]} \
+   ${MISC_ARGS[@]}
diff --git a/scripts/run-qwen3-30B-A3B.sh b/scripts/run-qwen3-30B-A3B.sh
index 7a0f8b069..c3a5f898a 100644
--- a/scripts/run-qwen3-30B-A3B.sh
+++ b/scripts/run-qwen3-30B-A3B.sh
@@ -1,24 +1,15 @@
 #!/bin/bash
 
-ACTOR_NUM_NODES="${ACTOR_NUM_NODES:-1}"
-ACTOR_NUM_GPUS_PER_NODE="${ACTOR_NUM_GPUS_PER_NODE:-8}"
-TOTAL_GPUS=$((ACTOR_NUM_NODES * ACTOR_NUM_GPUS_PER_NODE))
-
-if [[ "${ACTOR_NUM_NODES}" -le 1 ]]; then
-   # for rerun the task (single-node only)
-   pkill -9 -f "vllm serve"
-   sleep 3
-   ray stop --force
-   pkill -9 ray
-   pkill -9 python
-   sleep 3
-   pkill -9 ray
-   pkill -9 python
-   pkill -9 redis
-else
-   export SLIME_SCRIPT_EXTERNAL_RAY=1
-   export MASTER_ADDR="${MASTER_ADDR:?Set MASTER_ADDR to head LAN IP}"
-fi
+# for rerun the task
+pkill -9 -f "vllm serve"
+sleep 3
+ray stop --force
+pkill -9 ray
+pkill -9 python
+sleep 3
+pkill -9 ray
+pkill -9 python
+pkill -9 redis
 
 set -ex
 
@@ -34,244 +25,124 @@ fi
 echo "HAS_NVLINK: $HAS_NVLINK (detected $NVLINK_COUNT NVLink references)"
 
 SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
-VIME_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
 source "${SCRIPT_DIR}/models/qwen3-30B-A3B.sh"
 
-if [[ "${ACTOR_NUM_NODES}" -le 1 ]]; then
-   CKPT_ARGS=(
-      --hf-checkpoint /root/Qwen3-30B-A3B
-      #--hf-checkpoint /root/Qwen3-30B-A3B-FP8
-      --ref-load /root/Qwen3-30B-A3B_torch_dist
-      --load /root/Qwen3-30B-A3B_slime/
-      --save /root/Qwen3-30B-A3B_slime/
-      --save-interval 20
-   )
-
-   ROLLOUT_ARGS=(
-      --prompt-data /root/dapo-math-17k/dapo-math-17k.jsonl
-      --input-key prompt
-      --label-key label
-      --apply-chat-template
-      --rollout-shuffle
-      --rm-type deepscaler
-      --num-rollout 3000
-      --rollout-batch-size 32
-      --n-samples-per-prompt 8
-      --rollout-max-response-len 8192
-      --rollout-temperature 1
-
-      --global-batch-size 256
-      --balance-data
-   )
-
-   EVAL_ARGS=(
-      --eval-interval 20
-      --eval-prompt-data aime /root/aime-2024/aime-2024.jsonl
-      --n-samples-per-eval-prompt 16
-      --eval-max-response-len 16384
-      --eval-top-p 1
-   )
-
-   PERF_ARGS=(
-      --tensor-model-parallel-size 4
-      --sequence-parallel
-      --pipeline-model-parallel-size 1
-      --context-parallel-size 1
-      --expert-model-parallel-size 8
-      --expert-tensor-parallel-size 1
-
-      --recompute-granularity full
-      --recompute-method uniform
-      --recompute-num-layers 1
-
-      # --micro-batch-size 1
-      --use-dynamic-batch-size
-      --max-tokens-per-gpu 20480
-   )
-
-   GRPO_ARGS=(
-      --advantage-estimator grpo
-      --use-kl-loss
-      --kl-loss-coef 0.00
-      --kl-loss-type low_var_kl
-      --entropy-coef 0.00
-      --eps-clip 0.2
-      --eps-clip-high 0.28
-   )
-
-   OPTIMIZER_ARGS=(
-      --optimizer adam
-      --lr 1e-6
-      --lr-decay-style constant
-      --weight-decay 0.1
-      --adam-beta1 0.9
-      --adam-beta2 0.98
-
-      --optimizer-cpu-offload
-      --overlap-cpu-optimizer-d2h-h2d
-      --use-precision-aware-optimizer
-   )
-
-   WANDB_ARGS=(
-      #--use-wandb
-      # --wandb-project vime-dev
-      # --wandb-group qwen3-30B-A3B-test
-      # --wandb-key ${WANDB_KEY}
-   )
-
-   VLLM_ARGS=(
-      --rollout-num-gpus-per-engine 8
-      --vllm-gpu-memory-utilization 0.7
-      --vllm-cudagraph-capture-sizes 1 2 4 8 $(seq 16 8 256)
-   )
-
-   MISC_ARGS=(
-      # default dropout in megatron is 0.1
-      --attention-dropout 0.0
-      --hidden-dropout 0.0
-      # should be good for model performance
-      --accumulate-allreduce-grads-in-fp32
-      --attention-softmax-in-fp32
-      # need to comment this when using model with MLA
-      --attention-backend flash
-   )
-
-else
-   MEGATRON_TP="${MEGATRON_TP:-8}"
-   MEGATRON_PP="${MEGATRON_PP:-1}"
-   MEGATRON_CP="${MEGATRON_CP:-2}"
-   MEGATRON_EP="${MEGATRON_EP:-8}"
-   ROLLOUT_NUM_GPUS_PER_ENGINE="${ROLLOUT_NUM_GPUS_PER_ENGINE:-${TOTAL_GPUS}}"
-   NUM_GPUS_PER_NODE="${NUM_GPUS_PER_NODE:-${ACTOR_NUM_GPUS_PER_NODE}}"
-   NUM_ROLLOUT="${NUM_ROLLOUT:-100}"
-   ROLLOUT_BATCH_SIZE="${ROLLOUT_BATCH_SIZE:-4}"
-   N_SAMPLES_PER_PROMPT="${N_SAMPLES_PER_PROMPT:-2}"
-   ROLLOUT_MAX_RESPONSE_LEN="${ROLLOUT_MAX_RESPONSE_LEN:-2048}"
-   GLOBAL_BATCH_SIZE="${GLOBAL_BATCH_SIZE:-$((ROLLOUT_BATCH_SIZE * N_SAMPLES_PER_PROMPT))}"
-   ENABLE_R3="${ENABLE_R3:-1}"
-   HF_CKPT="${HF_CKPT:-/root/Qwen3-30B-A3B}"
-   TORCH_DIST="${TORCH_DIST:-/root/models/Qwen3-30B-A3B_torch_dist}"
-   PROMPT_DATA="${PROMPT_DATA:-/root/datasets/dapo-math-17k/dapo-math-17k.jsonl}"
-
-   CKPT_ARGS=(
-      --hf-checkpoint "${HF_CKPT}"
-      --ref-load "${TORCH_DIST}"
-   )
-
-   ROLLOUT_ARGS=(
-      --prompt-data "${PROMPT_DATA}"
-      --input-key prompt
-      --label-key label
-      --apply-chat-template
-      --rollout-shuffle
-      --rm-type deepscaler
-      --num-rollout "${NUM_ROLLOUT}"
-      --rollout-batch-size "${ROLLOUT_BATCH_SIZE}"
-      --n-samples-per-prompt "${N_SAMPLES_PER_PROMPT}"
-      --rollout-max-response-len "${ROLLOUT_MAX_RESPONSE_LEN}"
-      --rollout-temperature 1
-      --global-batch-size "${GLOBAL_BATCH_SIZE}"
-      --balance-data
-   )
-
-   EVAL_ARGS=()
-   WANDB_ARGS=()
-
-   PERF_ARGS=(
-      --tensor-model-parallel-size "${MEGATRON_TP}"
-      --sequence-parallel
-      --pipeline-model-parallel-size "${MEGATRON_PP}"
-      --context-parallel-size "${MEGATRON_CP}"
-      --expert-model-parallel-size "${MEGATRON_EP}"
-      --expert-tensor-parallel-size 1
-      --recompute-granularity full
-      --recompute-method uniform
-      --recompute-num-layers 1
-      --use-dynamic-batch-size
-      --max-tokens-per-gpu "${MAX_TOKENS_PER_GPU:-4096}"
-   )
-
-   GRPO_ARGS=(
-      --advantage-estimator gspo
-      --kl-loss-coef 0.00
-      --kl-loss-type low_var_kl
-      --kl-coef 0.00
-      --entropy-coef 0.00
-      --eps-clip 4e-4
-   )
-   if [[ "${ENABLE_R3}" == "1" ]]; then
-      GRPO_ARGS+=(--use-rollout-routing-replay)
-   fi
-
-   OPTIMIZER_ARGS=(
-      --optimizer adam
-      --lr 1e-6
-      --lr-decay-style constant
-      --weight-decay 0.1
-      --adam-beta1 0.9
-      --adam-beta2 0.98
-   )
-
-   VLLM_ARGS=(
-      --rollout-num-gpus-per-engine "${ROLLOUT_NUM_GPUS_PER_ENGINE}"
-      --num-gpus-per-node "${NUM_GPUS_PER_NODE}"
-      --vllm-gpu-memory-utilization "${VLLM_GPU_MEMORY_UTILIZATION:-0.65}"
-      --vllm-moe-backend "${VLLM_MOE_BACKEND:-triton}"
-   )
-   if [[ "${ENABLE_R3}" == "1" ]]; then
-      VLLM_ARGS+=(
-         --vllm-max-model-len "${VLLM_MAX_MODEL_LEN:-6144}"
-         --vllm-server-concurrency "${VLLM_SERVER_CONCURRENCY:-96}"
-         --update-weight-buffer-size "${UPDATE_WEIGHT_BUFFER_SIZE:-$((512 * 1024 * 1024))}"
-      )
-   fi
-
-   MISC_ARGS=(
-      --attention-dropout 0.0
-      --hidden-dropout 0.0
-      --accumulate-allreduce-grads-in-fp32
-      --attention-softmax-in-fp32
-      --attention-backend flash
-      --moe-token-dispatcher-type alltoall
-   )
-fi
-
-RAY_ADDRESS="${RAY_ADDRESS:-http://127.0.0.1:8265}"
-
-if [[ "${ACTOR_NUM_NODES}" -le 1 ]]; then
-   # launch the master node of ray in container
-   export MASTER_ADDR=${MASTER_ADDR:-"127.0.0.1"}
-   ray start --head --node-ip-address ${MASTER_ADDR} --num-gpus "${ACTOR_NUM_GPUS_PER_NODE}" \
-      --disable-usage-stats --dashboard-host=0.0.0.0 --dashboard-port=8265
-
-   RUNTIME_ENV_JSON="{
-     \"env_vars\": {
-       \"PYTHONPATH\": \"/root/Megatron-LM/\",
-       \"CUDA_DEVICE_MAX_CONNECTIONS\": \"1\",
-       \"NCCL_NVLS_ENABLE\": \"${HAS_NVLINK}\"
-     }
-   }"
-else
-   RUNTIME_ENV_JSON="{
-     \"env_vars\": {
-       \"PYTHONPATH\": \"${VIME_ROOT}:/root/Megatron-LM/\",
-       \"CUDA_DEVICE_MAX_CONNECTIONS\": \"1\",
-       \"MASTER_ADDR\": \"${MASTER_ADDR}\",
-       \"NCCL_SOCKET_IFNAME\": \"${NCCL_SOCKET_IFNAME:-ens90f0np0,ens90f1np1,ens92f0np0,ens92f1np1}\",
-       \"GLOO_SOCKET_IFNAME\": \"${GLOO_SOCKET_IFNAME:-enp130s0f0}\",
-       \"NCCL_IB_DISABLE\": \"${NCCL_IB_DISABLE:-1}\",
-       \"SLIME_NCCL_BRIDGE_CPU_FALLBACK\": \"${SLIME_NCCL_BRIDGE_CPU_FALLBACK:-1}\",
-       \"VLLM_SERVER_DEV_MODE\": \"1\"
-     }
-   }"
-   cd "${VIME_ROOT}"
-fi
-
-ray job submit --address="${RAY_ADDRESS}" \
+CKPT_ARGS=(
+   --hf-checkpoint /root/Qwen3-30B-A3B
+   #--hf-checkpoint /root/Qwen3-30B-A3B-FP8
+   --ref-load /root/Qwen3-30B-A3B_torch_dist
+   --load /root/Qwen3-30B-A3B_vime/
+   --save /root/Qwen3-30B-A3B_vime/
+   --save-interval 20
+)
+
+ROLLOUT_ARGS=(
+   --prompt-data /root/dapo-math-17k/dapo-math-17k.jsonl
+   --input-key prompt
+   --label-key label
+   --apply-chat-template
+   --rollout-shuffle
+   --rm-type deepscaler
+   --num-rollout 3000
+   --rollout-batch-size 32
+   --n-samples-per-prompt 8
+   --rollout-max-response-len 8192
+   --rollout-temperature 1
+
+   --global-batch-size 256
+   --balance-data
+)
+
+EVAL_ARGS=(
+   --eval-interval 20
+   --eval-prompt-data aime /root/aime-2024/aime-2024.jsonl
+   --n-samples-per-eval-prompt 16
+   --eval-max-response-len 16384
+   --eval-top-p 1
+)
+
+PERF_ARGS=(
+   --tensor-model-parallel-size 4
+   --sequence-parallel
+   --pipeline-model-parallel-size 1
+   --context-parallel-size 1
+   --expert-model-parallel-size 8
+   --expert-tensor-parallel-size 1
+
+   --recompute-granularity full
+   --recompute-method uniform
+   --recompute-num-layers 1
+
+   # --micro-batch-size 1
+   --use-dynamic-batch-size
+   --max-tokens-per-gpu 20480
+)
+
+GRPO_ARGS=(
+   --advantage-estimator grpo
+   --use-kl-loss
+   --kl-loss-coef 0.00
+   --kl-loss-type low_var_kl
+   --entropy-coef 0.00
+   --eps-clip 0.2
+   --eps-clip-high 0.28
+)
+
+OPTIMIZER_ARGS=(
+   --optimizer adam
+   --lr 1e-6
+   --lr-decay-style constant
+   --weight-decay 0.1
+   --adam-beta1 0.9
+   --adam-beta2 0.98
+
+   --optimizer-cpu-offload
+   --overlap-cpu-optimizer-d2h-h2d
+   --use-precision-aware-optimizer
+)
+
+WANDB_ARGS=(
+   #--use-wandb
+   # --wandb-project vime-dev
+   # --wandb-group qwen3-30B-A3B-test
+   # --wandb-key ${WANDB_KEY}
+)
+
+VLLM_ARGS=(
+   --rollout-num-gpus-per-engine 8
+   --vllm-gpu-memory-utilization 0.7
+   --vllm-cudagraph-capture-sizes 1 2 4 8 $(seq 16 8 256)
+)
+
+MISC_ARGS=(
+   # default dropout in megatron is 0.1
+   --attention-dropout 0.0
+   --hidden-dropout 0.0
+   # should be good for model performance
+   --accumulate-allreduce-grads-in-fp32
+   --attention-softmax-in-fp32
+   # need to comment this when using model with MLA
+   --attention-backend flash
+)
+
+# launch the master node of ray in container
+export MASTER_ADDR=${MASTER_ADDR:-"127.0.0.1"}
+ray start --head --node-ip-address ${MASTER_ADDR} --num-gpus 8 --disable-usage-stats --dashboard-host=0.0.0.0 --dashboard-port=8265
+
+# Build the runtime environment JSON with proper variable substitution
+RUNTIME_ENV_JSON="{
+  \"env_vars\": {
+    \"PYTHONPATH\": \"/root/Megatron-LM/\",
+    \"CUDA_DEVICE_MAX_CONNECTIONS\": \"1\",
+    \"NCCL_NVLS_ENABLE\": \"${HAS_NVLINK}\"
+  }
+}"
+
+ray job submit --address="http://127.0.0.1:8265" \
    --runtime-env-json="${RUNTIME_ENV_JSON}" \
    -- python3 train.py \
-   --actor-num-nodes "${ACTOR_NUM_NODES}" \
-   --actor-num-gpus-per-node "${ACTOR_NUM_GPUS_PER_NODE}" \
+   --actor-num-nodes 1 \
+   --actor-num-gpus-per-node 8 \
    --colocate \
    ${MODEL_ARGS[@]} \
    ${CKPT_ARGS[@]} \
@@ -280,6 +151,6 @@ ray job submit --address="${RAY_ADDRESS}" \
    ${GRPO_ARGS[@]} \
    ${WANDB_ARGS[@]} \
    ${PERF_ARGS[@]} \
-   ${EVAL_ARGS[@]+"${EVAL_ARGS[@]}"} \
+   ${EVAL_ARGS[@]} \
    ${VLLM_ARGS[@]} \
    ${MISC_ARGS[@]}
diff --git a/scripts/run-qwen3-4B.sh b/scripts/run-qwen3-4B.sh
index e54b0b33f..2be2e9d41 100644
--- a/scripts/run-qwen3-4B.sh
+++ b/scripts/run-qwen3-4B.sh
@@ -33,15 +33,15 @@ fi
 echo "NUM_GPUS: $NUM_GPUS"
 
 SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
-SLIME_ROOT="$(cd -- "${SCRIPT_DIR}/.." &>/dev/null && pwd)"
+VIME_ROOT="$(cd -- "${SCRIPT_DIR}/.." &>/dev/null && pwd)"
 source "${SCRIPT_DIR}/models/qwen3-4B.sh"
 
 CKPT_ARGS=(
    --hf-checkpoint /root/Qwen3-4B
    #--hf-checkpoint /root/Qwen3-4B-FP8
    --ref-load /root/Qwen3-4B_torch_dist
-   --load /root/Qwen3-4B_slime/
-   --save /root/Qwen3-4B_slime/
+   --load /root/Qwen3-4B_vime/
+   --save /root/Qwen3-4B_vime/
    --save-interval 20
 )
 
@@ -137,7 +137,7 @@ ray start --head --node-ip-address ${MASTER_ADDR} --num-gpus ${NUM_GPUS} --disab
 # Build the runtime environment JSON with proper variable substitution
 RUNTIME_ENV_JSON="{
   \"env_vars\": {
-    \"PYTHONPATH\": \"${SLIME_ROOT}:/root/Megatron-LM/\",
+    \"PYTHONPATH\": \"${VIME_ROOT}:/root/Megatron-LM/\",
     \"CUDA_DEVICE_MAX_CONNECTIONS\": \"1\",
     \"NCCL_NVLS_ENABLE\": \"${HAS_NVLINK}\"
   }
diff --git a/tests/ci/README.md b/tests/ci/README.md
index 2b58be3d4..6899ce3e1 100644
--- a/tests/ci/README.md
+++ b/tests/ci/README.md
@@ -2,7 +2,7 @@
 
 ## Configure GitHub secrets
 
-https://github.com/THUDM/slime/settings/secrets/actions
+https://github.com/vllm-project/vime/settings/secrets/actions
 
 * `WANDB_API_KEY`: get from https://wandb.ai/authorize
 
@@ -11,7 +11,7 @@ https://github.com/THUDM/slime/settings/secrets/actions
 ### Step 1: Env
 
 Write `.env` mimicking `.env.example`.
-The token can be found at https://github.com/THUDM/slime/settings/actions/runners/new?arch=x64&os=linux.
+The token can be found at https://github.com/vllm-project/vime/settings/actions/runners/new?arch=x64&os=linux.
 
 WARN: The `GITHUB_RUNNER_TOKEN` changes after a while.
 
@@ -28,7 +28,7 @@ ls -alh /home/runner/externals
 ### Step 3: Run
 
 ```shell
-cd /mnt/data/tom/primary_synced/slime/tests/ci/github_runner
+cd /mnt/data/tom/primary_synced/vime/tests/ci/github_runner
 docker compose up -d
 ```
 
diff --git a/tests/ci/github_runner/.env.example b/tests/ci/github_runner/.env.example
index 1692a83a3..d1261558f 100644
--- a/tests/ci/github_runner/.env.example
+++ b/tests/ci/github_runner/.env.example
@@ -1,2 +1,2 @@
-GITHUB_RUNNER_URL=https://github.com/THUDM/slime
+GITHUB_RUNNER_URL=https://github.com/vllm-project/vime
 GITHUB_RUNNER_TOKEN=paste-your-token-here
\ No newline at end of file
diff --git a/tests/ci/github_runner/docker-compose.yml b/tests/ci/github_runner/docker-compose.yml
index c6d0fb63c..7c58c980a 100644
--- a/tests/ci/github_runner/docker-compose.yml
+++ b/tests/ci/github_runner/docker-compose.yml
@@ -7,7 +7,7 @@ services:
     image: ghcr.io/actions/actions-runner:2.329.0
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock
-      - /data/slime_ci:/data/slime_ci
+      - /data/vime_ci:/data/vime_ci
       # it requires this folder
       - /home/runner/externals:/home/runner/externals
     deploy:
@@ -23,7 +23,7 @@ services:
     # TODO seems we should not run config.sh repeatedly
     entrypoint: >
       sh -c "
-      cd /data/slime_ci &&
-      /home/runner/config.sh --url ${GITHUB_RUNNER_URL} --token ${GITHUB_RUNNER_TOKEN} --unattended --work /data/slime_ci/runner_$(hostname) --disableupdate &&
+      cd /data/vime_ci &&
+      /home/runner/config.sh --url ${GITHUB_RUNNER_URL} --token ${GITHUB_RUNNER_TOKEN} --unattended --work /data/vime_ci/runner_$(hostname) --disableupdate &&
       /home/runner/run.sh
       "
diff --git a/tests/plugin_contracts/_shared.py b/tests/plugin_contracts/_shared.py
index 2ffb77971..249a51f57 100644
--- a/tests/plugin_contracts/_shared.py
+++ b/tests/plugin_contracts/_shared.py
@@ -9,7 +9,7 @@
 
 import pytest
 
-ENV_PREFIX = "SLIME_CONTRACT_"
+ENV_PREFIX = "VIME_CONTRACT_"
 
 
 def install_paths() -> None:
@@ -56,7 +56,7 @@ def run_contract_test_for_file(
     extra_args: Sequence[tuple[str, dict]] = (),
     extra_setup=None,
 ) -> None:
-    """Parse ``--xxx-path`` CLI arguments, store as ``SLIME_CONTRACT_XXX_PATH``
+    """Parse ``--xxx-path`` CLI arguments, store as ``VIME_CONTRACT_XXX_PATH``
     env vars, then call pytest on *file*.
 
     Args:
diff --git a/tests/test_moonlight_16B_A3B.py b/tests/test_moonlight_16B_A3B.py
index 8a1cf9a68..233e0ccb6 100644
--- a/tests/test_moonlight_16B_A3B.py
+++ b/tests/test_moonlight_16B_A3B.py
@@ -1,8 +1,8 @@
 import os
 import vime.utils.external_utils.command_utils as U
 
-ENABLE_EVAL = bool(int(os.environ.get("SLIME_TEST_ENABLE_EVAL", "1")))
-TIGHT_HOST_MEMORY = bool(int(os.environ.get("SLIME_TEST_TIGHT_HOST_MEMORY", "1")))
+ENABLE_EVAL = bool(int(os.environ.get("VIME_TEST_ENABLE_EVAL", "1")))
+TIGHT_HOST_MEMORY = bool(int(os.environ.get("VIME_TEST_TIGHT_HOST_MEMORY", "1")))
 
 MODEL_NAME = "Moonlight-16B-A3B-Instruct"
 MODEL_TYPE = "moonlight"
diff --git a/tests/test_moonlight_16B_A3B_r3.py b/tests/test_moonlight_16B_A3B_r3.py
index 53b076c5e..c0eb3bf43 100644
--- a/tests/test_moonlight_16B_A3B_r3.py
+++ b/tests/test_moonlight_16B_A3B_r3.py
@@ -1,8 +1,8 @@
 import os
 import vime.utils.external_utils.command_utils as U
 
-ENABLE_EVAL = bool(int(os.environ.get("SLIME_TEST_ENABLE_EVAL", "1")))
-TIGHT_HOST_MEMORY = bool(int(os.environ.get("SLIME_TEST_TIGHT_HOST_MEMORY", "1")))
+ENABLE_EVAL = bool(int(os.environ.get("VIME_TEST_ENABLE_EVAL", "1")))
+TIGHT_HOST_MEMORY = bool(int(os.environ.get("VIME_TEST_TIGHT_HOST_MEMORY", "1")))
 
 MODEL_NAME = "Moonlight-16B-A3B-Instruct"
 MODEL_TYPE = "moonlight"
diff --git a/tests/test_quick_start_glm4_9B.py b/tests/test_quick_start_glm4_9B.py
index 3a006ee91..d5785deb2 100644
--- a/tests/test_quick_start_glm4_9B.py
+++ b/tests/test_quick_start_glm4_9B.py
@@ -1,8 +1,8 @@
 import os
 import vime.utils.external_utils.command_utils as U
 
-ENABLE_EVAL = U.get_bool_env_var("SLIME_TEST_ENABLE_EVAL", "1")
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+ENABLE_EVAL = U.get_bool_env_var("VIME_TEST_ENABLE_EVAL", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "GLM-Z1-9B-0414"
 MODEL_TYPE = "glm4-9B"
diff --git a/tests/test_qwen2.5_0.5B_async_short.py b/tests/test_qwen2.5_0.5B_async_short.py
index 67ee03bac..d5e394c49 100644
--- a/tests/test_qwen2.5_0.5B_async_short.py
+++ b/tests/test_qwen2.5_0.5B_async_short.py
@@ -1,7 +1,7 @@
 import os
 import vime.utils.external_utils.command_utils as U
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/tests/test_qwen2.5_0.5B_debug_rollout_then_train.py b/tests/test_qwen2.5_0.5B_debug_rollout_then_train.py
index e3a72a120..c67e91e98 100644
--- a/tests/test_qwen2.5_0.5B_debug_rollout_then_train.py
+++ b/tests/test_qwen2.5_0.5B_debug_rollout_then_train.py
@@ -13,7 +13,7 @@
 
 import vime.utils.external_utils.command_utils as U
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
@@ -132,7 +132,7 @@ def execute_train_only(debug_data_dir: str):
 
 
 def execute():
-    debug_data_dir = tempfile.mkdtemp(prefix="slime_debug_rollout_")
+    debug_data_dir = tempfile.mkdtemp(prefix="vime_debug_rollout_")
     print(f"Using temp dir for rollout data: {debug_data_dir}")
 
     execute_rollout_only(debug_data_dir)
diff --git a/tests/test_qwen2.5_0.5B_fully_async_short.py b/tests/test_qwen2.5_0.5B_fully_async_short.py
index b055949f6..7c158955a 100644
--- a/tests/test_qwen2.5_0.5B_fully_async_short.py
+++ b/tests/test_qwen2.5_0.5B_fully_async_short.py
@@ -12,7 +12,7 @@
 import os
 import vime.utils.external_utils.command_utils as U
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/tests/test_qwen2.5_0.5B_opd_vllm.py b/tests/test_qwen2.5_0.5B_opd_vllm.py
index b43b268fe..4a9ddb3cb 100644
--- a/tests/test_qwen2.5_0.5B_opd_vllm.py
+++ b/tests/test_qwen2.5_0.5B_opd_vllm.py
@@ -5,7 +5,7 @@
 
 import vime.utils.external_utils.command_utils as U
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/tests/test_qwen2.5_0.5B_ppo_critic_only_short.py b/tests/test_qwen2.5_0.5B_ppo_critic_only_short.py
index 37e4786b5..7fe843049 100644
--- a/tests/test_qwen2.5_0.5B_ppo_critic_only_short.py
+++ b/tests/test_qwen2.5_0.5B_ppo_critic_only_short.py
@@ -3,7 +3,7 @@
 
 import vime.utils.external_utils.command_utils as U
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/tests/test_qwen2.5_0.5B_short.py b/tests/test_qwen2.5_0.5B_short.py
index a43d0b278..a1fcca757 100644
--- a/tests/test_qwen2.5_0.5B_short.py
+++ b/tests/test_qwen2.5_0.5B_short.py
@@ -1,7 +1,7 @@
 import os
 import vime.utils.external_utils.command_utils as U
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/tests/test_qwen2.5_0.5B_vllm_config.py b/tests/test_qwen2.5_0.5B_vllm_config.py
index 72819917b..5ef1787d9 100644
--- a/tests/test_qwen2.5_0.5B_vllm_config.py
+++ b/tests/test_qwen2.5_0.5B_vllm_config.py
@@ -3,7 +3,7 @@
 
 import vime.utils.external_utils.command_utils as U
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/tests/test_qwen2.5_0.5B_vllm_config_distributed.py b/tests/test_qwen2.5_0.5B_vllm_config_distributed.py
index d0fc6a839..f6a507e6a 100644
--- a/tests/test_qwen2.5_0.5B_vllm_config_distributed.py
+++ b/tests/test_qwen2.5_0.5B_vllm_config_distributed.py
@@ -3,7 +3,7 @@
 
 import vime.utils.external_utils.command_utils as U
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/tests/test_qwen3.5_0.8B_gsm8k_async_short.py b/tests/test_qwen3.5_0.8B_gsm8k_async_short.py
index 7b8fb2f9b..10ed6fef8 100644
--- a/tests/test_qwen3.5_0.8B_gsm8k_async_short.py
+++ b/tests/test_qwen3.5_0.8B_gsm8k_async_short.py
@@ -3,7 +3,7 @@
 import vime.utils.external_utils.command_utils as U
 
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen3.5-0.8B"
 MODEL_TYPE = "qwen3.5-0.8B"
diff --git a/tests/test_qwen3.5_0.8B_gsm8k_short.py b/tests/test_qwen3.5_0.8B_gsm8k_short.py
index 9c99dff77..a1182f168 100644
--- a/tests/test_qwen3.5_0.8B_gsm8k_short.py
+++ b/tests/test_qwen3.5_0.8B_gsm8k_short.py
@@ -3,7 +3,7 @@
 import vime.utils.external_utils.command_utils as U
 
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen3.5-0.8B"
 MODEL_TYPE = "qwen3.5-0.8B"
diff --git a/tests/test_qwen3_0.6B_parallel_check.py b/tests/test_qwen3_0.6B_parallel_check.py
index d3e487d1e..3b8b5d6f7 100644
--- a/tests/test_qwen3_0.6B_parallel_check.py
+++ b/tests/test_qwen3_0.6B_parallel_check.py
@@ -3,8 +3,8 @@
 import vime.utils.external_utils.command_utils as U
 
 
-ENABLE_EVAL = bool(int(os.environ.get("SLIME_TEST_ENABLE_EVAL", "1")))
-TIGHT_HOST_MEMORY = bool(int(os.environ.get("SLIME_TEST_TIGHT_HOST_MEMORY", "1")))
+ENABLE_EVAL = bool(int(os.environ.get("VIME_TEST_ENABLE_EVAL", "1")))
+TIGHT_HOST_MEMORY = bool(int(os.environ.get("VIME_TEST_TIGHT_HOST_MEMORY", "1")))
 
 MODEL_NAME = "Qwen3-0.6B"
 MODEL_TYPE = "qwen3-0.6B"
diff --git a/tests/test_qwen3_30B_A3B.py b/tests/test_qwen3_30B_A3B.py
index 5ab3ac807..9bd7af964 100644
--- a/tests/test_qwen3_30B_A3B.py
+++ b/tests/test_qwen3_30B_A3B.py
@@ -3,10 +3,10 @@
 import vime.utils.external_utils.command_utils as U
 
 
-ENABLE_EVAL = bool(int(os.environ.get("SLIME_TEST_ENABLE_EVAL", "1")))
-TIGHT_HOST_MEMORY = bool(int(os.environ.get("SLIME_TEST_TIGHT_HOST_MEMORY", "1")))
-USE_DEEPEP = bool(int(os.environ.get("SLIME_TEST_USE_DEEPEP", "1")))
-USE_FP8_ROLLOUT = bool(int(os.environ.get("SLIME_TEST_USE_FP8_ROLLOUT", "1")))
+ENABLE_EVAL = bool(int(os.environ.get("VIME_TEST_ENABLE_EVAL", "1")))
+TIGHT_HOST_MEMORY = bool(int(os.environ.get("VIME_TEST_TIGHT_HOST_MEMORY", "1")))
+USE_DEEPEP = bool(int(os.environ.get("VIME_TEST_USE_DEEPEP", "1")))
+USE_FP8_ROLLOUT = bool(int(os.environ.get("VIME_TEST_USE_FP8_ROLLOUT", "1")))
 
 MODEL_NAME = "Qwen3-30B-A3B"
 MODEL_TYPE = "qwen3-30B-A3B"
diff --git a/tests/test_qwen3_30B_A3B_r3.py b/tests/test_qwen3_30B_A3B_r3.py
index c90d896a3..f4cad4b10 100644
--- a/tests/test_qwen3_30B_A3B_r3.py
+++ b/tests/test_qwen3_30B_A3B_r3.py
@@ -3,10 +3,10 @@
 import vime.utils.external_utils.command_utils as U
 
 
-ENABLE_EVAL = bool(int(os.environ.get("SLIME_TEST_ENABLE_EVAL", "1")))
-TIGHT_HOST_MEMORY = bool(int(os.environ.get("SLIME_TEST_TIGHT_HOST_MEMORY", "1")))
-USE_DEEPEP = bool(int(os.environ.get("SLIME_TEST_USE_DEEPEP", "1")))
-USE_FP8_ROLLOUT = bool(int(os.environ.get("SLIME_TEST_USE_FP8_ROLLOUT", "1")))
+ENABLE_EVAL = bool(int(os.environ.get("VIME_TEST_ENABLE_EVAL", "1")))
+TIGHT_HOST_MEMORY = bool(int(os.environ.get("VIME_TEST_TIGHT_HOST_MEMORY", "1")))
+USE_DEEPEP = bool(int(os.environ.get("VIME_TEST_USE_DEEPEP", "1")))
+USE_FP8_ROLLOUT = bool(int(os.environ.get("VIME_TEST_USE_FP8_ROLLOUT", "1")))
 
 MODEL_NAME = "Qwen3-30B-A3B"
 MODEL_TYPE = "qwen3-30B-A3B"
diff --git a/tests/test_qwen3_4B_ckpt.py b/tests/test_qwen3_4B_ckpt.py
index 63b955703..bebbce845 100644
--- a/tests/test_qwen3_4B_ckpt.py
+++ b/tests/test_qwen3_4B_ckpt.py
@@ -4,8 +4,8 @@
 import vime.utils.external_utils.command_utils as U
 
 
-ENABLE_EVAL = bool(int(os.environ.get("SLIME_TEST_ENABLE_EVAL", "1")))
-TIGHT_HOST_MEMORY = bool(int(os.environ.get("SLIME_TEST_TIGHT_HOST_MEMORY", "1")))
+ENABLE_EVAL = bool(int(os.environ.get("VIME_TEST_ENABLE_EVAL", "1")))
+TIGHT_HOST_MEMORY = bool(int(os.environ.get("VIME_TEST_TIGHT_HOST_MEMORY", "1")))
 
 MODEL_NAME = "Qwen3-4B"
 MODEL_TYPE = "qwen3-4B"
@@ -19,7 +19,7 @@
 def prepare():
     U.exec_command("mkdir -p /root/models /root/datasets")
     U.exec_command(f"hf download Qwen/{MODEL_NAME} --local-dir /root/models/{MODEL_NAME}")
-    U.exec_command(f"rm -rf /root/models/{MODEL_NAME}_slime")
+    U.exec_command(f"rm -rf /root/models/{MODEL_NAME}_vime")
     U.hf_download_dataset("zhuzilin/dapo-math-17k")
     U.hf_download_dataset("zhuzilin/aime-2024")
 
@@ -31,15 +31,15 @@ def prepare():
 def execute(mode: str = ""):
     ckpt_args = f"--hf-checkpoint /root/models/{MODEL_NAME}/ " f"--ref-load /root/models/{MODEL_NAME}_torch_dist "
     if mode == "save":
-        ckpt_args += f"--save /root/models/{MODEL_NAME}_slime "
+        ckpt_args += f"--save /root/models/{MODEL_NAME}_vime "
         ckpt_args += "--save-interval 2 "
     elif mode == "async_save":
-        ckpt_args += f"--save /root/models/{MODEL_NAME}_slime "
+        ckpt_args += f"--save /root/models/{MODEL_NAME}_vime "
         ckpt_args += "--save-interval 2 "
         # Real async save (Megatron disables async without persistent ckpt worker).
         ckpt_args += "--async-save --use-persistent-ckpt-worker "
     elif mode == "load":
-        ckpt_args += f"--load /root/models/{MODEL_NAME}_slime "
+        ckpt_args += f"--load /root/models/{MODEL_NAME}_vime "
         ckpt_args += "--ckpt-step 1 "
 
     rollout_args = (
diff --git a/tests/test_qwen3_4B_ppo.py b/tests/test_qwen3_4B_ppo.py
index 197fa5741..8ff3920dc 100644
--- a/tests/test_qwen3_4B_ppo.py
+++ b/tests/test_qwen3_4B_ppo.py
@@ -4,8 +4,8 @@
 import vime.utils.external_utils.command_utils as U
 
 
-ENABLE_EVAL = bool(int(os.environ.get("SLIME_TEST_ENABLE_EVAL", "1")))
-TIGHT_HOST_MEMORY = bool(int(os.environ.get("SLIME_TEST_TIGHT_HOST_MEMORY", "1")))
+ENABLE_EVAL = bool(int(os.environ.get("VIME_TEST_ENABLE_EVAL", "1")))
+TIGHT_HOST_MEMORY = bool(int(os.environ.get("VIME_TEST_TIGHT_HOST_MEMORY", "1")))
 
 MODEL_NAME = "Qwen3-4B"
 MODEL_TYPE = "qwen3-4B"
diff --git a/tests/test_qwen3_4B_ppo_disaggregate.py b/tests/test_qwen3_4B_ppo_disaggregate.py
index bdaef069b..f680d1db8 100644
--- a/tests/test_qwen3_4B_ppo_disaggregate.py
+++ b/tests/test_qwen3_4B_ppo_disaggregate.py
@@ -4,8 +4,8 @@
 import vime.utils.external_utils.command_utils as U
 
 
-ENABLE_EVAL = bool(int(os.environ.get("SLIME_TEST_ENABLE_EVAL", "1")))
-TIGHT_HOST_MEMORY = bool(int(os.environ.get("SLIME_TEST_TIGHT_HOST_MEMORY", "1")))
+ENABLE_EVAL = bool(int(os.environ.get("VIME_TEST_ENABLE_EVAL", "1")))
+TIGHT_HOST_MEMORY = bool(int(os.environ.get("VIME_TEST_TIGHT_HOST_MEMORY", "1")))
 
 MODEL_NAME = "Qwen3-4B"
 MODEL_TYPE = "qwen3-4B"
diff --git a/tests/test_qwen3_4B_ppo_train_critic_only.py b/tests/test_qwen3_4B_ppo_train_critic_only.py
index f43ecde14..13245d690 100644
--- a/tests/test_qwen3_4B_ppo_train_critic_only.py
+++ b/tests/test_qwen3_4B_ppo_train_critic_only.py
@@ -4,8 +4,8 @@
 import vime.utils.external_utils.command_utils as U
 
 
-ENABLE_EVAL = bool(int(os.environ.get("SLIME_TEST_ENABLE_EVAL", "1")))
-TIGHT_HOST_MEMORY = bool(int(os.environ.get("SLIME_TEST_TIGHT_HOST_MEMORY", "1")))
+ENABLE_EVAL = bool(int(os.environ.get("VIME_TEST_ENABLE_EVAL", "1")))
+TIGHT_HOST_MEMORY = bool(int(os.environ.get("VIME_TEST_TIGHT_HOST_MEMORY", "1")))
 
 MODEL_NAME = "Qwen3-4B"
 MODEL_TYPE = "qwen3-4B"
diff --git a/tests/test_vllm_config_mixed_offload.py b/tests/test_vllm_config_mixed_offload.py
index 9f6ad7f40..1da543164 100644
--- a/tests/test_vllm_config_mixed_offload.py
+++ b/tests/test_vllm_config_mixed_offload.py
@@ -18,7 +18,7 @@
 
 import vime.utils.external_utils.command_utils as U
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/tests/test_vllm_config_mixed_offload_ft.py b/tests/test_vllm_config_mixed_offload_ft.py
index 61708107d..4d0f2911b 100644
--- a/tests/test_vllm_config_mixed_offload_ft.py
+++ b/tests/test_vllm_config_mixed_offload_ft.py
@@ -15,7 +15,7 @@
 
 import vime.utils.external_utils.command_utils as U
 
-TIGHT_DEVICE_MEMORY = U.get_bool_env_var("SLIME_TEST_TIGHT_DEVICE_MEMORY", "1")
+TIGHT_DEVICE_MEMORY = U.get_bool_env_var("VIME_TEST_TIGHT_DEVICE_MEMORY", "1")
 
 MODEL_NAME = "Qwen2.5-0.5B-Instruct"
 MODEL_TYPE = "qwen2.5-0.5B"
diff --git a/tests/unit/backends/megatron_utils/update_weight/test_update_weight_from_tensor.py b/tests/unit/backends/megatron_utils/update_weight/test_update_weight_from_tensor.py
index 087b329bb..512d278ee 100644
--- a/tests/unit/backends/megatron_utils/update_weight/test_update_weight_from_tensor.py
+++ b/tests/unit/backends/megatron_utils/update_weight/test_update_weight_from_tensor.py
@@ -51,9 +51,9 @@ def _install_stubs():
     _dist.barrier = dist_stub.barrier
     _dist.all_gather_object = dist_stub.all_gather_object
 
-    slime_utils = types.ModuleType("vime.utils.distributed_utils")
-    slime_utils.get_gloo_group = MagicMock(return_value="gloo")
-    sys.modules.setdefault("vime.utils.distributed_utils", slime_utils)
+    vime_utils = types.ModuleType("vime.utils.distributed_utils")
+    vime_utils.get_gloo_group = MagicMock(return_value="gloo")
+    sys.modules.setdefault("vime.utils.distributed_utils", vime_utils)
 
     hf_iter_stub = MagicMock()
     hf_iter_stub.get_hf_weight_chunks.return_value = iter([])
diff --git a/vime/backends/megatron_utils/arguments.py b/vime/backends/megatron_utils/arguments.py
index ca0f82a4b..0a85faa69 100644
--- a/vime/backends/megatron_utils/arguments.py
+++ b/vime/backends/megatron_utils/arguments.py
@@ -70,7 +70,7 @@ def _is_moe_config(hf_config):
 
 
 def validate_args(args):
-    """Run megatron's own validate_args plus slime-specific megatron validations."""
+    """Run megatron's own validate_args plus vime-specific megatron validations."""
 
     _megatron_validate_args(args)
 
diff --git a/vime/backends/megatron_utils/megatron_patch/megatron_chunked_grad_coalesce_patch.py b/vime/backends/megatron_utils/megatron_patch/megatron_chunked_grad_coalesce_patch.py
index f7ecceb2d..800da9b0c 100644
--- a/vime/backends/megatron_utils/megatron_patch/megatron_chunked_grad_coalesce_patch.py
+++ b/vime/backends/megatron_utils/megatron_patch/megatron_chunked_grad_coalesce_patch.py
@@ -5,9 +5,9 @@
 # allocation during TP-side grad sync, avoiding OOM under allocator
 # fragmentation when the combined grad buffer would otherwise be very large.
 # SUM/AVG are element-wise, so chunking is mathematically equivalent.
-# Chunk size: SLIME_GRAD_COALESCE_CHUNK_BYTES, default 1 GiB.
+# Chunk size: VIME_GRAD_COALESCE_CHUNK_BYTES, default 1 GiB.
 #
-# Cross-compatible across the Megatron-LM versions slime is run against:
+# Cross-compatible across the Megatron-LM versions vime is run against:
 # the core_v0.13.0 line (DDP config exposes `use_custom_fsdp`, `_get_main_grad_attr`
 # takes `(param, use_custom_fsdp)`, target function takes `(model, config)`) and
 # the post-core_v0.15.0rc7 dev line (`use_megatron_fsdp`, single-arg
@@ -46,7 +46,7 @@ def _grad_attr(param, fsdp_on):
     def _fsdp_flag(ddp_config):
         return bool(getattr(ddp_config, "use_megatron_fsdp", False) or getattr(ddp_config, "use_custom_fsdp", False))
 
-    _chunk_bytes = int(os.environ.get("SLIME_GRAD_COALESCE_CHUNK_BYTES") or (1 << 30))
+    _chunk_bytes = int(os.environ.get("VIME_GRAD_COALESCE_CHUNK_BYTES") or (1 << 30))
 
     def _split_into_chunks(params, grads, target_bytes):
         """Greedy split keeping params/grads aligned. A single grad larger
@@ -131,7 +131,7 @@ def _allreduce_non_tensor_model_parallel_grads(model, config, tp_group=None):
     _fmg._allreduce_layernorm_grads = _allreduce_non_tensor_model_parallel_grads
 
     logger.info(
-        "slime grad coalesce patch applied to "
+        "vime grad coalesce patch applied to "
         "megatron.core.distributed.finalize_model_grads."
         "_allreduce_non_tensor_model_parallel_grads (chunk=%d MiB)",
         _chunk_bytes // (1 << 20),
@@ -139,7 +139,7 @@ def _allreduce_non_tensor_model_parallel_grads(model, config, tp_group=None):
 
 except ImportError as exc:
     warnings.warn(
-        f"slime grad coalesce patch not applied — Megatron import failed ({exc!r}). "
+        f"vime grad coalesce patch not applied — Megatron import failed ({exc!r}). "
         "If this is a Megatron upgrade, the symbol layout may have changed; "
         "without this patch, large-model TP grad sync may OOM.",
         stacklevel=2,
diff --git a/vime/backends/megatron_utils/megatron_to_hf/processors/quantizer_fp8.py b/vime/backends/megatron_utils/megatron_to_hf/processors/quantizer_fp8.py
index cb299160e..6d49f754d 100644
--- a/vime/backends/megatron_utils/megatron_to_hf/processors/quantizer_fp8.py
+++ b/vime/backends/megatron_utils/megatron_to_hf/processors/quantizer_fp8.py
@@ -100,15 +100,6 @@ def _quantize_param(name, weight, weight_block_size):
             weight_block_size=weight_block_size
         ):
             qweight, scale = quant_weight_ue8m0(weight, weight_block_size=weight_block_size)
-            # vLLM's MoE FP8 loader expects the RAW block scale
-            # [ceil(n/128), ceil(k/128)] -- the on-disk weight_scale_inv format. It
-            # narrows the scale per-TP (shard_dim) and TMA-packs it itself inside
-            # process_weights_after_loading. transform_scale_ue8m0 produces SGLang's
-            # mn-major TMA-packed layout (slime targets the SGLang engine); under a
-            # vLLM rollout engine that pre-packed scale's numel mismatches vLLM's
-            # per-rank w2/w13 scale buffer (w2 expects [n/128,k/128] -> narrow on the
-            # k-block dim), so the online update_weights asserts in fused_moe _load_w2.
-            # Send the raw block scale and let vLLM do its own narrow + packing.
         else:
             qweight, scale = blockwise_cast_to_fp8_triton(weight, weight_block_size)
         scale_name = name.replace(".weight", ".weight_scale_inv")
diff --git a/vime/backends/megatron_utils/update_weight/update_weight_from_tensor.py b/vime/backends/megatron_utils/update_weight/update_weight_from_tensor.py
index 96731b238..494cebb42 100644
--- a/vime/backends/megatron_utils/update_weight/update_weight_from_tensor.py
+++ b/vime/backends/megatron_utils/update_weight/update_weight_from_tensor.py
@@ -351,7 +351,7 @@ def update_weights(self) -> None:
         # ── 5. Signal colocated engines to exit weight-update mode ───────────
         # State-machine bookend only; ``_weight_version`` is recorded inside
         # ``update_weights_from_tensor`` (step 4) when the data RPC succeeds —
-        # matches slime's single-RPC version-with-data semantics.
+        # matches vime's single-RPC version-with-data semantics.
         if self._ipc_engine_coordinator:
             ray.get(self._ipc_engine.finish_weight_update.remote())
         dist.barrier(group=get_gloo_group())
@@ -443,16 +443,16 @@ class _VLLMHijack:
     def hijack() -> None:
         from vllm.distributed.weight_transfer.ipc_engine import IPCWeightTransferEngine
 
-        if getattr(IPCWeightTransferEngine, "_slime_receive_patched", False):
+        if getattr(IPCWeightTransferEngine, "_vime_receive_patched", False):
             return
 
         _orig = IPCWeightTransferEngine.receive_weights
 
-        def _slime_receive_weights(self, update_info, load_weights, _orig=_orig):
+        def _vime_receive_weights(self, update_info, load_weights, _orig=_orig):
             _orig(self, update_info, load_weights)
 
-        IPCWeightTransferEngine.receive_weights = _slime_receive_weights
-        IPCWeightTransferEngine._slime_receive_patched = True  # type: ignore[attr-defined]
+        IPCWeightTransferEngine.receive_weights = _vime_receive_weights
+        IPCWeightTransferEngine._vime_receive_patched = True  # type: ignore[attr-defined]
 
 
 class vLLMColocateWorkerExtension:
diff --git a/vime/backends/vllm_utils/arguments.py b/vime/backends/vllm_utils/arguments.py
index b13a6611e..098180ff9 100644
--- a/vime/backends/vllm_utils/arguments.py
+++ b/vime/backends/vllm_utils/arguments.py
@@ -316,12 +316,6 @@ def validate_args(args):
     args.vllm_dp_size = args.vllm_data_parallel_size
     args.vllm_pp_size = args.vllm_pipeline_parallel_size
 
-    # NOTE: TP is intentionally NOT precomputed here. A global ``vllm_tp_size`` derived from the
-    # *global* rollout_num_gpus_per_engine would shadow the per-engine value and break
-    # heterogeneous per-group engines (different num_gpus_per_engine). TP is resolved per engine
-    # in ``vllm_engine._resolve_vllm_parallel_sizes`` (tp = gpus_per_engine // pp), mirroring
-    # upstream slime's sglang_engine. (pp divisibility is validated there, per engine.)
-
     if getattr(args, "vllm_router_ip", None):
         args.vllm_router_ip = _wrap_ipv6(args.vllm_router_ip)
 
diff --git a/vime/backends/vllm_utils/vllm_engine.py b/vime/backends/vllm_utils/vllm_engine.py
index 6458716f4..b9b6cb3b8 100644
--- a/vime/backends/vllm_utils/vllm_engine.py
+++ b/vime/backends/vllm_utils/vllm_engine.py
@@ -121,12 +121,6 @@ def _get_vllm_dp_size(args) -> int:
 
 
 def _resolve_vllm_parallel_sizes(args, *, gpus_per_engine: int) -> tuple[int, int]:
-    # Derive TP per-engine from THIS engine's GPU count (matches upstream slime's
-    # sglang_engine: tp = _gpus_per_engine // pp). Deliberately does NOT consult a global
-    # ``args.vllm_tp_size``: validate_args used to set that from the *global*
-    # rollout_num_gpus_per_engine, which shadowed this per-engine value and made a
-    # heterogeneous per-group engine (e.g. a tp=2 group) launch with the global TP —
-    # desyncing the weight-transfer rendezvous (the 300s "3/4 clients joined" hang).
     pp = _get_vllm_pp_size(args)
     dp = _get_vllm_dp_size(args)
     if dp != 1:
@@ -500,16 +494,7 @@ def _wait_worker_process_alive(process: multiprocessing.Process, timeout_s: floa
 
 
 def _wait_server_healthy(base_url: str, process: multiprocessing.Process | None) -> None:
-    """Wait until the vLLM server responds on ``GET /health`` (no time limit, SGLang-style).
-
-    Loops until /health returns 200, or — for a managed subprocess — until it dies (fail fast via
-    ``process.is_alive()``). There is no overall deadline, so a slow-but-healthy startup (a large
-    MoE / DP engine loading + compiling + capturing CUDA graphs across replicas) is never
-    spuriously timed out. The per-probe ``timeout=3`` bounds each individual request so a single
-    stuck socket cannot wedge the loop. In external mode (``process is None``) there is no liveness
-    signal, so a permanently unreachable URL loops indefinitely by design (the external engine is
-    caller-managed). Mirrors slime's SGLang backend _wait_server_healthy.
-    """
+    """Wait until the vLLM server responds on ``GET /health``."""
     while True:
         try:
             response = requests.get(f"{base_url}/health", timeout=3)
@@ -706,12 +691,7 @@ def _init_normal(self) -> None:
             _wait_worker_process_alive(self.process)
 
     def _make_request(self, endpoint: str, payload: dict | None = None, *, timeout: float) -> dict | None:
-        """Control-plane POST returning parsed JSON (mirrors SGLang's ``_make_request``).
-
-        The single choke point for control-plane POSTs: headless workers (node_rank>0) own no
-        HTTP server, so they no-op to None; otherwise POST and parse via the shared
-        ``_response_json`` (also reused by the query-param endpoints /sleep, /wake_up, ...).
-        """
+        """Control-plane POST returning parsed JSON."""
         if self.node_rank != 0:
             return None
         url = f"{self._http_base()}/{endpoint.lstrip('/')}"
@@ -906,7 +886,7 @@ def finish_weight_update(self) -> dict:
         """``POST /finish_weight_update`` — signals vLLM to exit IPC weight-update mode.
 
         Purely a state-machine bookend now; ``_weight_version`` is recorded by
-        ``update_weights_from_tensor`` (the IPC data-carrying RPC), matching slime's
+        ``update_weights_from_tensor`` (the IPC data-carrying RPC), matching vime's
         single-RPC version-with-data semantics.
         """
         return self._make_request("finish_weight_update", {}, timeout=self._weight_transfer_http_timeout())
diff --git a/vime/ray/rollout.py b/vime/ray/rollout.py
index ef5fb31b8..d3a2ecdc3 100644
--- a/vime/ray/rollout.py
+++ b/vime/ray/rollout.py
@@ -116,7 +116,7 @@ def start_engines(self, port_cursors: dict[int, int] | None = None) -> tuple[lis
             env_vars = {name: "1" for name in NOSET_VISIBLE_DEVICES_ENV_VARS_LIST} | {
                 key: os.environ.get(key, default_val)
                 for key, default_val in {
-                    "SLIME_ENABLE_PROFILING": "true",
+                    "VIME_ENABLE_PROFILING": "true",
                 }.items()
             }
             rollout_engine = RolloutRayActor.options(
diff --git a/vime/utils/__init__.py b/vime/utils/__init__.py
index 074557662..2a18698ac 100644
--- a/vime/utils/__init__.py
+++ b/vime/utils/__init__.py
@@ -1 +1 @@
-"""Utility package root for Slime."""
+"""Utility package root for Vime."""
diff --git a/vime/utils/arguments.py b/vime/utils/arguments.py
index 0dacf1248..0bf14b138 100644
--- a/vime/utils/arguments.py
+++ b/vime/utils/arguments.py
@@ -32,8 +32,8 @@ def reset_arg(parser, name, **kwargs):
         parser.add_argument(name, **kwargs)
 
 
-def get_slime_extra_args_provider(add_custom_arguments=None):
-    def add_slime_arguments(parser):
+def get_vime_extra_args_provider(add_custom_arguments=None):
+    def add_vime_arguments(parser):
         # Ray
         def add_cluster_arguments(parser):
             parser.add_argument("--actor-num-nodes", type=int, default=1, help="Number of nodes for training actor")
@@ -618,7 +618,7 @@ def add_data_arguments(parser):
                     "Because the sample length varies, to maximize the GPU utilization, "
                     "we will use the dynamic batch size to adjust the micro batch size according to the maximum number of tokens each gpu can run. "
                     "For example, if we have 3 samples, with the length of 100, 200, and 300, and the max_tokens_per_gpu is 300, when enabling "
-                    "dynamic batch size, slime will make 2 micro batches, i.e. [100, 200], [300]."
+                    "dynamic batch size, vime will make 2 micro batches, i.e. [100, 200], [300]."
                 ),
             )
             parser.add_argument(
@@ -1376,7 +1376,7 @@ def add_ci_arguments(parser):
             )
             return parser
 
-        # Add custom arguments in front to prevent overwritten some slime arguments.
+        # Add custom arguments in front to prevent overwritten some vime arguments.
         if add_custom_arguments is not None:
             parser = add_custom_arguments(parser)
 
@@ -1409,13 +1409,13 @@ def add_ci_arguments(parser):
 
         return parser
 
-    return add_slime_arguments
+    return add_vime_arguments
 
 
 def _pre_parse_mode():
     """Pre-parse CLI to extract arguments that control parsing flow.
 
-    These arguments are removed from add_slime_arguments to avoid
+    These arguments are removed from add_vime_arguments to avoid
     registering them twice.  The returned namespace is merged into
     the final ``args`` after Phase 2 parsing.
     """
@@ -1432,7 +1432,7 @@ def parse_args(add_custom_arguments=None):
     # Users may call `parse_args` very early, thus we ensure logger is configured here
     configure_logger()
 
-    add_slime_arguments = get_slime_extra_args_provider(add_custom_arguments)
+    add_vime_arguments = get_vime_extra_args_provider(add_custom_arguments)
 
     pre = _pre_parse_mode()
     skip_vllm = pre.debug_train_only or pre.load_debug_rollout_data is not None
@@ -1442,14 +1442,14 @@ def parse_args(add_custom_arguments=None):
     if not skip_vllm:
         vllm_ns = vllm_parse_args()
 
-    # Phase 2: Parse megatron + slime args.
+    # Phase 2: Parse megatron + vime args.
     # Uses ignore_unknown_args=True so that --vllm-* and pre-parsed CLI flags are
     # silently ignored by the megatron parser.
     from vime.backends.megatron_utils.arguments import megatron_parse_args
     from vime.backends.megatron_utils.arguments import validate_args as megatron_validate_args
 
     args = megatron_parse_args(
-        extra_args_provider=add_slime_arguments,
+        extra_args_provider=add_vime_arguments,
         skip_hf_validate=pre.debug_rollout_only,
     )
 
@@ -1462,7 +1462,7 @@ def parse_args(add_custom_arguments=None):
         for key, value in vars(vllm_ns).items():
             setattr(args, key, value)
 
-    slime_validate_args(args)
+    vime_validate_args(args)
 
     if pre.train_backend == "megatron" and not args.debug_rollout_only:
         megatron_validate_args(args)
@@ -1597,7 +1597,7 @@ def _resolve_eval_datasets(args) -> list[EvalDatasetConfig]:
     return eval_datasets
 
 
-def slime_validate_args(args):
+def vime_validate_args(args):
     args.eval_datasets = _resolve_eval_datasets(args)
 
     if args.kl_coef != 0 or args.use_kl_loss:
diff --git a/vime/utils/external_utils/command_utils.py b/vime/utils/external_utils/command_utils.py
index 3d6aa9456..2ea6024e3 100644
--- a/vime/utils/external_utils/command_utils.py
+++ b/vime/utils/external_utils/command_utils.py
@@ -1,5 +1,5 @@
 """
-This file is not for slime framework itself, but as an optional utility to easily launch slime jobs and tests.
+This file is not for vime framework itself, but as an optional utility to easily launch vime jobs and tests.
 """
 
 import datetime
@@ -104,7 +104,7 @@ def execute_train(
         extra_env_vars = {}
     if config is None:
         config = ExecuteTrainConfig()
-    external_ray = get_bool_env_var("SLIME_SCRIPT_EXTERNAL_RAY")
+    external_ray = get_bool_env_var("VIME_SCRIPT_EXTERNAL_RAY")
     master_addr = os.environ.get("MASTER_ADDR", "127.0.0.1")
 
     exec_command(
@@ -120,10 +120,10 @@ def execute_train(
         "sleep 3; "
         f"{'' if external_ray else 'ray stop --force; '}"
         f"{'' if external_ray else 'pkill -9 ray; '}"
-        "pkill -9 slime; "
+        "pkill -9 vime; "
         "sleep 3; "
         f"{'' if external_ray else 'pkill -9 ray; '}"
-        "pkill -9 slime; "
+        "pkill -9 vime; "
         "pkill -9 redis; "
         "true; "
     )
@@ -163,7 +163,7 @@ def execute_train(
         }
     )
 
-    if get_bool_env_var("SLIME_SCRIPT_ENABLE_RAY_SUBMIT", "1"):
+    if get_bool_env_var("VIME_SCRIPT_ENABLE_RAY_SUBMIT", "1"):
         cmd_megatron_model_source = (
             f'source "{repo_base_dir}/scripts/models/{megatron_model_type}.sh" && '
             if megatron_model_type is not None
@@ -212,7 +212,7 @@ def get_default_wandb_args(test_file: str, run_name_prefix: str | None = None, r
     wandb_key = os.environ.get("WANDB_API_KEY")
     return (
         "--use-wandb "
-        f"--wandb-project slime-{test_name} "
+        f"--wandb-project vime-{test_name} "
         f"--wandb-group {wandb_run_name} "
         f"--wandb-key '{wandb_key}' "
         "--disable-wandb-random-suffix "
@@ -243,11 +243,11 @@ def get_bool_env_var(name: str, default: str = "false") -> bool:
 
 
 def get_env_enable_infinite_run():
-    return get_bool_env_var("SLIME_TEST_ENABLE_INFINITE_RUN", "false")
+    return get_bool_env_var("VIME_TEST_ENABLE_INFINITE_RUN", "false")
 
 
 def save_to_temp_file(text: str, ext: str):
-    path = Path(f"/tmp/slime_temp_file_{time.time()}_{random.randrange(0, 10000000)}.{ext}")
+    path = Path(f"/tmp/vime_temp_file_{time.time()}_{random.randrange(0, 10000000)}.{ext}")
     path.write_text(text)
     print(f"Write the following content to {path=}: {text=}")
     return str(path)
diff --git a/vime/utils/external_utils/typer_utils.py b/vime/utils/external_utils/typer_utils.py
index ece4f5fd9..b3e2eccba 100644
--- a/vime/utils/external_utils/typer_utils.py
+++ b/vime/utils/external_utils/typer_utils.py
@@ -5,7 +5,7 @@
 import typer
 
 
-def dataclass_cli(func, env_var_prefix: str = "SLIME_SCRIPT_"):
+def dataclass_cli(func, env_var_prefix: str = "VIME_SCRIPT_"):
     """Modified from https://github.com/fastapi/typer/issues/154#issuecomment-1544876144"""
 
     # The dataclass type is the first argument of the function.
@@ -58,12 +58,12 @@ def main(args: DemoArgs):
 
     runner = CliRunner()
 
-    res1 = runner.invoke(app, [], env={"SLIME_SCRIPT_NAME": "EnvName", "SLIME_SCRIPT_COUNT": "10"})
+    res1 = runner.invoke(app, [], env={"VIME_SCRIPT_NAME": "EnvName", "VIME_SCRIPT_COUNT": "10"})
     print(f"{res1.stdout=}")
     assert res1.exit_code == 0
     assert "EnvName|10" in res1.stdout.strip()
 
-    res2 = runner.invoke(app, ["--count", "999"], env={"SLIME_SCRIPT_NAME": "EnvName"})
+    res2 = runner.invoke(app, ["--count", "999"], env={"VIME_SCRIPT_NAME": "EnvName"})
     print(f"{res2.stdout=}")
     assert res2.exit_code == 0
     assert "EnvName|999" in res2.stdout.strip()
diff --git a/vime/utils/http_utils.py b/vime/utils/http_utils.py
index e7fe05348..6a4ab78ce 100644
--- a/vime/utils/http_utils.py
+++ b/vime/utils/http_utils.py
@@ -11,7 +11,7 @@
 
 logger = logging.getLogger(__name__)
 
-SLIME_HOST_IP_ENV = "SLIME_HOST_IP"
+VIME_HOST_IP_ENV = "VIME_HOST_IP"
 
 
 def find_available_port(base_port: int):
@@ -42,7 +42,7 @@ def is_port_available(port):
 def get_host_info():
     hostname = socket.gethostname()
 
-    if env_overwrite_local_ip := os.getenv(SLIME_HOST_IP_ENV, None):
+    if env_overwrite_local_ip := os.getenv(VIME_HOST_IP_ENV, None):
         return hostname, env_overwrite_local_ip
 
     def _is_loopback(ip):
@@ -83,7 +83,7 @@ def _resolve_ip(family, test_target_ip):
 
         return None
 
-    prefer_ipv6 = os.getenv("SLIME_PREFER_IPV6", "0").lower() in ("1", "true", "yes", "on")
+    prefer_ipv6 = os.getenv("VIME_PREFER_IPV6", "0").lower() in ("1", "true", "yes", "on")
     local_ip = None
     final_fallback = "127.0.0.1"
 
diff --git a/vime/utils/trace_utils.py b/vime/utils/trace_utils.py
index a1ec76898..2bf6e55e4 100644
--- a/vime/utils/trace_utils.py
+++ b/vime/utils/trace_utils.py
@@ -17,11 +17,11 @@
 
 logger = logging.getLogger(__name__)
 _TRACE_STACK: contextvars.ContextVar[tuple[tuple[str, str], ...]] = contextvars.ContextVar(
-    "slime_trace_stack",
+    "vime_trace_stack",
     default=(),
 )
 _TRACE_HANDLE_STACK: contextvars.ContextVar[tuple[tuple[TraceHandle, ...], ...]] = contextvars.ContextVar(
-    "slime_trace_handle_stack",
+    "vime_trace_handle_stack",
     default=(),
 )
 _TRACE_AUTO_INFER_WARNED: set[str] = set()
@@ -107,11 +107,6 @@ def _new_span_id() -> str:
 
 def build_vllm_meta_trace_attrs(output: dict[str, Any]) -> dict[str, Any]:
     """Trace-span attributes from a vLLM ``/inference/v1/generate`` response.
-
-    vLLM exposes far less per-request meta than SGLang's ``meta_info`` (no
-    PD-disaggregation timing): only the finish reason and token usage are
-    available on the response. Richer request timing lives in vLLM's own OTLP
-    traces (``gen_ai.latency.*``, enabled via ``--otlp-traces-endpoint``).
     """
     attrs: dict[str, Any] = {}
     choices = output.get("choices") or []
diff --git a/vime_plugins/rollout_buffer/README.md b/vime_plugins/rollout_buffer/README.md
index e85e68d89..1636a73ae 100644
--- a/vime_plugins/rollout_buffer/README.md
+++ b/vime_plugins/rollout_buffer/README.md
@@ -2,12 +2,12 @@
 
 ## Overview
 
-Rollout Buffer is an independent component for asynchronous agent trajectory generation, with the main function of using the LLM OpenAI Server launched by slime training to generate agent trajectories.
+Rollout Buffer is an independent component for asynchronous agent trajectory generation, with the main function of using the LLM OpenAI Server launched by vime training to generate agent trajectories.
 
 ### Workflow
 
 ```
-slime Training Process ←─── HTTP API ───→ Rollout Buffer
+vime Training Process ←─── HTTP API ───→ Rollout Buffer
         ↓                                      ↓
    LLM Server ←─────── HTTP Requests ─────── Agent Framework
         ↓                                      ↓
@@ -36,13 +36,13 @@ generator/
 
 Each Generator file must define `TASK_TYPE` and `run_rollout()`.
 
-In addition, Rollout Buffer also provides some customizable functions to meet special needs of different tasks. If no custom implementation is provided, the system will use default implementations (located in `slime_plugins/rollout_buffer/default_func.py`).
+In addition, Rollout Buffer also provides some customizable functions to meet special needs of different tasks. If no custom implementation is provided, the system will use default implementations (located in `vime_plugins/rollout_buffer/default_func.py`).
 
 ### Example Script
 
 First, you need to follow [Example: Qwen3-4B Model](../../docs/en/models/qwen3-4B.md) to configure the environment, download data and convert model checkpoints. And then run the following scripts:
 ```bash
-cd slime_plugins/rollout_buffer
+cd vime_plugins/rollout_buffer
 bash rollout_buffer_example.sh
 
 # In a different terminal
diff --git a/vime_plugins/rollout_buffer/README_zh.md b/vime_plugins/rollout_buffer/README_zh.md
index cfa689fe7..f17808a97 100644
--- a/vime_plugins/rollout_buffer/README_zh.md
+++ b/vime_plugins/rollout_buffer/README_zh.md
@@ -2,12 +2,12 @@
 
 ## 概述
 
-Rollout Buffer 是用于辅助纯异步 agent 训练的独立组件，其主要功能是使用 slime 训练启动的 LLM OpenAI Server 进行智能体轨迹的生成。
+Rollout Buffer 是用于辅助纯异步 agent 训练的独立组件，其主要功能是使用 vime 训练启动的 LLM OpenAI Server 进行智能体轨迹的生成。
 
 ### 工作流程
 
 ```
-slime Training Process ←─── HTTP API ───→ Rollout Buffer
+vime Training Process ←─── HTTP API ───→ Rollout Buffer
         ↓                                      ↓
    LLM Server ←─────── HTTP Requests ─────── Agent Framework
         ↓                                      ↓
@@ -36,14 +36,14 @@ generator/
 
 每个 Generator 文件必须定义 `TASK_TYPE` 与 `run_rollout()`。
 
-此外，Rollout Buffer 还提供了一些可自定义的函数来满足不同任务的特殊需求。如果不提供自定义实现，系统将使用默认实现（位于 `slime_plugins/rollout_buffer/default_func.py`）。
+此外，Rollout Buffer 还提供了一些可自定义的函数来满足不同任务的特殊需求。如果不提供自定义实现，系统将使用默认实现（位于 `vime_plugins/rollout_buffer/default_func.py`）。
 
 ### 示例脚本
 
-请仿照 [示例：Qwen3-4B 模型](../../docs/zh/models/qwen3-4B.md) 文档中配置好 slime 的运行环境，下载数据，并转换模型 ckpt。之后分别运行
+请仿照 [示例：Qwen3-4B 模型](../../docs/zh/models/qwen3-4B.md) 文档中配置好 vime 的运行环境，下载数据，并转换模型 ckpt。之后分别运行
 
 ```bash
-cd slime_plugins/rollout_buffer
+cd vime_plugins/rollout_buffer
 bash rollout_buffer_example.sh
 
 # In a different terminal
diff --git a/vime_plugins/rollout_buffer/rollout_buffer_example.sh b/vime_plugins/rollout_buffer/rollout_buffer_example.sh
index 2b3bacce9..040859526 100644
--- a/vime_plugins/rollout_buffer/rollout_buffer_example.sh
+++ b/vime_plugins/rollout_buffer/rollout_buffer_example.sh
@@ -45,7 +45,7 @@ CKPT_ARGS=(
    --hf-checkpoint /root/DeepSeek-R1-Distill-Qwen-7B
    --ref-load /root/DeepSeek-R1-Distill-Qwen-7B_torch_dist
    --save-interval 100
-   --save /root/DeepSeek-R1-Distill-Qwen-7B_slime
+   --save /root/DeepSeek-R1-Distill-Qwen-7B_vime
 )
 
 ROLLOUT_ARGS=(