TurboVLA: Real-Time VLA at 32 Hz, 0.9 GB VRAM, No LLM

Most people assume that a good VLA (Vision-Language-Action) model has to be large: OpenVLA at 7.5B, Pi0.5 at 3.4B, SmolVLA at 2.3B. Then, in late July 2026, the H-EmbodVis team released TurboVLA and overturned every one of those assumptions.

TurboVLA uses only 0.2B parameters, runs at 32 Hz, consumes 0.9 GB VRAM on an RTX 4090 — and achieves 97.7% success on the LIBERO benchmark, outperforming both Pi0.5 (96.9%) and OpenVLA (76.5%).

No GPT. No LLaMA. No Qwen. Just DINOv3 + BERT + a cleverly designed bidirectional interaction mechanism. The paper is available at arXiv:2607.27205 (July 29, 2026). This is your complete guide to understanding, installing, and running TurboVLA.

The Problem: Conventional VLAs Are Too Heavy for Real Deployment

The traditional VLA pipeline is: Image → LLM processes → Action. Every time a robot needs to make a decision, the full visual input must pass through a massive language model.

The practical consequences:

• OpenVLA (7.5B, LLaMA backbone): 202.9 ms/inference → ~5 Hz, requires 14.9 GB VRAM
• SmolVLA (2.3B): 203.1 ms/inference → ~5 Hz, requires 7.1 GB VRAM
• Pi0.5 (3.4B): 93.6 ms/inference → ~10 Hz, requires 12.8 GB VRAM

On a real robot, 5–10 Hz is dangerously slow. A robot arm needs at least 20–30 Hz for smooth, non-jerky control. And for VRAM — OpenVLA requires 14.9 GB just for inference. Training? You need a GPU cluster.

The question TurboVLA asks is: does manipulation actually require an LLM?

The answer: no, if you design a smarter fusion mechanism.

The Core Idea: V+L→A Instead of V→L→A

The old pipeline forces images to "pass through" language before generating actions. The language model acts as a mandatory bottleneck.

TurboVLA proposes a new paradigm: vision and language are processed in parallel, exchanging information through a lightweight mechanism, then jointly producing the action sequence.

Imagine a skilled chef receiving two inputs simultaneously: a photo of the kitchen counter (visual) and the instruction "place the apple on the blue plate" (language). A good chef doesn't read the instruction, describe the entire scene, and then start cooking — they look and read at the same time, then act directly. That is exactly how TurboVLA works.

TurboVLA Architecture in Detail

TurboVLA has four main components, each designed with a clear purpose.

1. Visual Encoder: DINOv3

DINOv3 (ViT-B for LIBERO, ViT-L for RoboTwin) extracts spatial features from images. DINOv3 excels at understanding the geometric structure of objects — critical for manipulation tasks.

Each image frame is encoded into a set of patch tokens with positional embeddings and camera-view embeddings (to distinguish inputs from different cameras in multi-camera setups). All features are projected into a shared 256-dimensional space.

2. Language Encoder: BERT Base Uncased

Instead of a 7B LLM, TurboVLA uses only BERT base — a 110M-parameter model pre-trained to understand sentence semantics. A task instruction like "grab the roller" is tokenized and encoded into feature vectors.

Why is BERT sufficient? In manipulation, instructions are typically short and structurally predictable. You don't need a model that understands poetry — just one that knows "pick up X and place it at Y." The ablation study confirms: BERT achieves 97.7%, T5-Small achieves 97.1%, SigLIP achieves 95.5% — the margins are small, meaning you can swap the text encoder if needed.

3. Bidirectional Vision-Language Interaction Module

This is the most innovative part. TurboVLA uses 6 stacked fusion layers with bidirectional cross-attention:

• Visual queries → Language context: The image asks "what is the instruction referring to?"
• Language queries → Visual context: The language asks "what does the thing I'm describing look like in the image?"

Each layer contains layer normalization + bidirectional cross-attention + modality-specific FFN + residual connections. The output is a concatenated vector [V_final; L_final] — visual and language information that have fully "understood" each other.

Why 6 layers? The ablation shows N=2 achieves only 93.5% (insufficient depth), N=6 achieves 97.7% (optimal), and N=8 drops to 96.6% (slight overfitting, unnecessary extra compute).

Bidirectionality matters: V→L only achieves 96.1%, L→V only achieves 96.5%, but both directions together achieve 97.7%.

4. Action Decoder: ACT-style Parallel

The decoder uses an ACT (Action Chunking Transformer) architecture with parallel decoding: all H=12 action steps are predicted simultaneously in a single forward pass — no autoregressive generation.

This is why TurboVLA is fast. There's no token-by-token decoding like an LLM — it produces all 12 consecutive action steps at once. Training uses behavior cloning with L1 loss on the continuous action space.

Installation

System Requirements

• Python 3.10
• PyTorch 2.3.1 + CUDA 12.1
• GPU with 8 GB+ VRAM for inference (RTX 4090 optimal, RTX 3080 sufficient)
• 4× GPUs for full training

Clone and Install

git clone https://github.com/H-EmbodVis/TurboVLA.git
cd TurboVLA

Environment for LIBERO:

conda create -n turbovla-libero python=3.10 -y
conda activate turbovla-libero
pip install torch==2.3.1 torchvision==0.18.1 --index-url https://download.pytorch.org/whl/cu121
pip install -e ".[libero]"

Environment for RoboTwin:

conda create -n turbovla-robotwin python=3.10 -y
conda activate turbovla-robotwin
pip install -e ".[robotwin]"
pip install flash-attn==2.7.4.post1 --no-build-isolation

Flash-Attention for RoboTwin further reduces memory usage and speeds up inference, especially with the larger ViT-L backbone.

Dataset Preparation

LIBERO

LIBERO has four task suites: libero_spatial, libero_object, libero_goal, and libero_10 (long-horizon). TurboVLA uses the no-noops version — frames with no action have been filtered out, improving training efficiency — in TFDS/RLDS format.

# Verify data directory structure
ls data/libero/
# libero_10_no_noops/1.0.0/
# libero_goal_no_noops/1.0.0/
# libero_object_no_noops/1.0.0/
# libero_spatial_no_noops/1.0.0/

See the repo for conversion scripts to transform raw LIBERO data into TFDS/RLDS format.

RoboTwin 2.0

RoboTwin is a bimanual manipulation benchmark with 50 diverse tasks, including complex two-arm operations.

# Set ROBOTWIN_DATA_ROOT before training or evaluation
export ROBOTWIN_DATA_ROOT="$PWD/playground/Datasets/RoboTwin"

Follow the download instructions in the RoboTwin section of the repo README.

Training

Training on LIBERO (4 GPUs)

torchrun --nproc_per_node=4 experiments/libero/train.py \
  --dataset_dir data/libero/libero_10_no_noops/1.0.0 \
  --dataset_dirs "data/libero/libero_10_no_noops/1.0.0,\
data/libero/libero_goal_no_noops/1.0.0,\
data/libero/libero_object_no_noops/1.0.0,\
data/libero/libero_spatial_no_noops/1.0.0" \
  --stats_path experiments/libero/configs/libero_all4_stats.json \
  --dinov3_path facebook/dinov3-vitb16-pretrain-lvd1689m \
  --bert_path google-bert/bert-base-uncased

Key notes:

• --dinov3_path and --bert_path can be HuggingFace repo IDs (auto-downloaded on first run) or local paths if you have pre-downloaded them
• --stats_path contains normalization statistics for joint training across all 4 suites
• Training on 4× RTX 4090 takes a few hours; checkpoints are saved automatically

Training on RoboTwin (4 GPUs, 55k steps)

export ROBOTWIN_DATA_ROOT="$PWD/playground/Datasets/RoboTwin"
MAX_TRAIN_STEPS=55000 bash scripts/robotwin/train.sh

RoboTwin requires more steps due to the greater task diversity (50 tasks vs. LIBERO's suites). The training script is pre-configured with appropriate hyperparameters.

Inference and Evaluation

Download Pretrained Checkpoints

# Download from HuggingFace Hub
huggingface-cli download H-EmbodVis/TurboVLA --local-dir pretrained/TurboVLA

After downloading, the directory structure will be:

pretrained/TurboVLA/
  checkpoints/
    libero/
      libero_object.pth
      libero_goal.pth
      libero_spatial.pth
      libero_10.pth
    robotwin/
      steps_55000_ema_model.safetensors

Evaluate on LIBERO

# Evaluate libero_object suite (50 trials per task)
python experiments/libero/evaluate.py \
  --ckpt_path pretrained/TurboVLA/checkpoints/libero/libero_object.pth \
  --task_suite_name libero_object \
  --num_trials_per_task 50 \
  --precision bf16

Valid values for --task_suite_name: libero_object, libero_goal, libero_spatial, libero_10.

The bf16 precision reduces VRAM usage and increases throughput on RTX 4090 with negligible accuracy impact — recommended as default.

For a quick smoke test before running the full evaluation:

python experiments/libero/evaluate.py \
  --ckpt_path pretrained/TurboVLA/checkpoints/libero/libero_object.pth \
  --task_suite_name libero_object \
  --num_trials_per_task 10 \
  --precision bf16

Evaluate on RoboTwin

ROBOTWIN_TEST_NUM=100 bash scripts/robotwin/evaluate.sh \
  pretrained/TurboVLA/checkpoints/robotwin/steps_55000_ema_model.safetensors

ROBOTWIN_TEST_NUM=100 runs 100 trials per task. Set ROBOTWIN_TEST_NUM=20 for a faster debug run.

Benchmark Results

LIBERO — Per-Suite Breakdown

LIBERO-Object near 100% — remarkable for a 0.2B-parameter model. LIBERO-Long is lower due to longer horizons, but 94.2% is still strong.

Full Comparison with Competing Models

TurboVLA is 17× smaller than Pi0.5, 3× faster, uses 14× less VRAM — and still outperforms Pi0.5 on accuracy (97.7% vs 96.9%).

RoboTwin 2.0 — Bimanual Manipulation

On 50 bimanual tasks, TurboVLA achieves 60.2% at 43.4 ms latency:

TurboVLA generalizes well beyond single-arm tasks — an important property for practical deployment.

Real-World Results — AgileX Piper Arm

The research team evaluated TurboVLA on a physical AgileX Piper robot arm across four tasks:

TurboVLA outperforms Pi0.5 on all four real-world tasks — despite having 17× fewer parameters. This confirms that the efficiency gains come without sacrificing physical-world generalization.

Ablation Insights: Why These Design Choices Work

The paper provides thorough ablation studies explaining the key decisions:

Number of interaction layers N:

N=6 is the sweet spot — enough depth to learn complex visual-language alignment without overfitting.

The role of language conditioning:

Removing text instructions entirely drops accuracy from 97.7% to 70.8% — proving that language conditioning is genuinely important, even though a full LLM is not needed. BERT is sufficient to encode the necessary semantics.

Bidirectional vs. unidirectional attention:

Both modalities benefit from querying each other — image and language need to mutually understand context, not just one informing the other.

Action horizon H:

H=12 is optimal — long enough to capture temporal dependencies, short enough to avoid predicting too far into an uncertain future.

Text encoder flexibility:

This modularity is a practical advantage: if you need multilingual instructions, swap BERT for a multilingual variant without architectural changes.

Practical Deployment: Who Should Use TurboVLA?

1. Rapid prototyping on a single machine: At 0.9 GB VRAM, you can run TurboVLA alongside a simulator, visualizer, and other processes on the same GPU. No resource partitioning headaches.

2. Near-term edge deployment: RTX 4090 is consumer hardware. With additional optimization (quantization, TensorRT), running on a Jetson AGX Orin or similar edge accelerator becomes realistic in the near future.

3. Research baseline: A clean 0.2B model with modular architecture is ideal for ablation studies. Want to try a different visual backbone? Swap ViT-B for ViT-L. Want a multilingual text encoder? Swap BERT for mBERT. The architecture accommodates such changes cleanly.

4. Multi-task learning: Joint training across all four LIBERO suites adds minimal overhead while producing more generalizable representations than training on individual suites.

If you're exploring other VLA approaches, check out ResVLA — Residual Diffusion Bridge for manipulation and compare with InstructVLA — instruction tuning for VLA.

Conclusion

TurboVLA makes a compelling case for three principles:

1. LLMs are not required for VLA — if you design a proper bidirectional fusion mechanism instead of routing everything through a language model.
2. Model size does not determine performance — architecture and data quality are the real drivers. 0.2B can outperform 3.4B with the right design.
3. 32 Hz on a consumer GPU is achievable today — no cluster required, no A100 needed, just an RTX 4090 with 0.9 GB of VRAM.

The V+L→A paradigm of TurboVLA opens a new research direction: instead of scaling the LLM backbone, design more efficient bidirectional interaction mechanisms. This is especially valuable for edge robotics — where compute and memory are hard constraints, not preferences.

The paper (arXiv:2607.27205) and code (GitHub H-EmbodVis/TurboVLA) are publicly available. The next open question: can the V+L→A paradigm scale up to whole-body humanoid manipulation?

Related Posts

• VLA Models for Robot Arm Manipulation — from ACT to Diffusion Policy
• ResVLA: Residual Diffusion Bridge to Anchor VLA Policy and Reduce Noise
• InstructVLA (ICLR 2026): VLA Instruction Tuning, Outperforms OpenVLA by 96% on SimplerEnv-Instruct