**TurboVLA** is a vision-language-action model that argues the dominant VLA architecture is doing unnecessary work. Instead of routing visual observations through a large language model before decoding robot actions, it encodes vision and language separately, lets them exchange information through a lightweight bidirectional module, and predicts action chunks with a compact decoder. The repository is the official implementation of the paper of the same name from **Huazhong University of Science and Technology** and **Huawei**, published on **30 July 2026** with model checkpoints following on **31 July**. It is Apache-2.0 licensed and has reached roughly **393 stars** with **42 forks**. ## The Argument Against V → L → A Most VLA policies inherit their shape from vision-language models: an image encoder projects observations into the token space of an LLM, the instruction joins them as text, and an action head decodes from the LLM's hidden states. It works, and it inherits the LLM's semantic grounding — but the LLM runs on **every policy invocation**, at whatever control frequency the robot needs. TurboVLA reformulates this as a direct **V + L → A** mapping. Visual observations and language instructions are encoded independently, a bidirectional vision-language interaction module exchanges information between the two streams, and a compact decoder emits continuous action chunks. The task-conditioned representation is constructed directly from visual and linguistic features rather than mediated by a language model's residual stream. The efficiency claim that follows is the headline: | Metric | TurboVLA on LIBERO | |---|---| | Average success rate | 97.7% | | Parameters | 0.2B | | Inference latency | 31.2 ms (~32 Hz) | | Inference VRAM | 0.9 GB | | Hardware | Consumer RTX 4090 | A policy that fits in under a gigabyte and closes the loop at 32 Hz on a consumer GPU is a different deployment story from one that needs a datacenter card resident for every action. ## What It Is Actually Built From The 0.2B figure counts the policy, not the frozen perception stack it sits on. TurboVLA composes four external assets: | Asset | Role | |---|---| | DINOv3 ViT-B / ViT-L | Visual backbone (ViT-B for LIBERO, ViT-L for RoboTwin) | | BERT base uncased | Language encoder, run online during training and evaluation | | GroundingDINO Swin-T OGC | Pretrained initialization checkpoint | | LIBERO / RoboTwin 2.0 | Simulation benchmarks and datasets | Notably, BERT is treated as part of the model and runs live rather than as a cached text-feature lookup, so instructions are not restricted to a fixed precomputed set. The published training recipes are specific enough to reproduce. LIBERO uses DINOv3 ViT-B, two camera views, 7-D actions, a 12-step action chunk, 80k optimizer steps with 10k warmup, and a global batch of 256 across four GPUs. RoboTwin uses DINOv3 ViT-L, three camera views, 14-D absolute joint-position actions, a 50-step ACT head, batch size 192 and 55k steps. Checkpoints ship for all four LIBERO suites — spatial, object, goal and long — plus a RoboTwin EMA checkpoint. ## Caveats **The headline numbers are simulation numbers.** LIBERO and RoboTwin 2.0 are the benchmarks reported. The repository shows a real-world manipulation GIF with synchronous policy inference, but there is no quantitative real-robot evaluation, and no open-world generalization benchmark, in the published material. **0.2B buys latency by giving something up.** The LLM-centric design that TurboVLA removes is also what carries broad semantic priors. On a fixed benchmark suite with a fixed instruction distribution, that cost may not show up; whether the V + L → A paradigm holds for unseen objects, novel phrasing or long-horizon compositional instructions is exactly the question the current evaluation does not answer. **The weights inherit third-party license terms.** The checkpoint release bundles a DINOv3 license file alongside its Apache-2.0 LICENSE. Anyone planning commercial deployment needs to read both, plus the GroundingDINO and BERT terms. **It is very new and very small as a project.** Roughly ten days old at the time of writing, three contributors, and 292 downloads with 4 likes on the Hugging Face checkpoints. There is no track record of outside users reproducing the numbers. **Setup is heavy.** Two separate conda environments are recommended because LIBERO and RoboTwin use incompatible simulator stacks, flash-attn must be built for the RoboTwin path, and the RoboTwin registry expects all 50 task datasets present locally. Huawei Ascend NPU support is on the TODO list, not in the repository. ## Verdict TurboVLA's contribution is less a model than a question about where VLA compute is going. If a 0.2B policy with independently encoded vision and language can match much larger LLM-centric policies on a standard manipulation suite, then the language model in the middle of most VLA stacks is doing less load-bearing work at inference time than its cost suggests. That question is worth taking seriously, and the release is complete enough to test it — paper, training code, evaluation code and checkpoints for both benchmarks. Robotics teams running LIBERO or RoboTwin who care about control frequency and on-robot memory should reproduce it directly. Everyone else should wait for real-robot and generalization results before concluding the LLM-centric pathway is optional.