---

What is FastVLA?

FastVLA trains Vision-Language-Action models up to 2.6× faster with 65 % less VRAM than the published L4 bf16 recipe — and trains models on hardware where the paper recipe simply cannot run.

Vision-Language-Action models (OpenVLA, SmolVLA, π₀…) map camera observations and language instructions to robot actions. The published fine-tuning recipes assume A100 / H100 boxes; the consumer-tier path has been missing.

FastVLA closes that gap. 4-bit QLoRA, paged 8-bit AdamW, activation checkpointing, fused Triton kernels, and a trainer that actually turns those features on — the same recipe Unsloth applied to LLMs, transposed to the vision + LLM + action-head stack. BC pretraining and PPO / GRPO refinement run end-to-end on a single L4.

---

Key features

• Fine-tune 7B VLAs on a single L4 or T4. Vanilla bf16 OpenVLA-7B OOMs at 22 GB on L4 — FastVLA trains at 14.3 it/s with 5.2 GB peak reserved on the same hardware. (Sprint 1 measurements)
• 2.6× faster inference, 65 % less VRAM vs the OpenVLA paper's L4 bf16 baseline (53 ms vs 138 ms; 4.87 GB vs 14.1 GB).
• One command per workflow. modal run examples/modal_production_benchmark.py reproduces every number in this README on serverless L4 + T4.
• Auto-torch.compile on Ada (sm_89) and Hopper (sm_90+). Off on Turing / Ampere where bnb 4-bit kernels regress under compile.
• Multi-lingual data pipeline. First VLA library shipping with Arabic translation + localisation tooling in scripts/dataset/.
• RL integrated. PPO and GRPO on top of BC, not a separate library.
• Reproducibility first. Every number in this README cites either an artefact in benchmark_results.json / production_benchmark_results.json / baseline_benchmark_results.json, a publicly-linked W&B run, or a published paper. The 3-4× speedup vs vanilla 4-bit QLoRA cited in issue #1 remains the one outstanding claim — locally remeasuring it is blocked by upstream OpenVLA + bnb failing to load, tracked as the next sprint item.

---

Cost and hardware floor

Same problem Unsloth solved for LLMs, transposed to VLAs. Inference Hz is not the pitch — OpenVLA-OFT already reaches 109 Hz with action chunking on A100/H100. FastVLA's pitch is the cost and hardware floor of training.

L4 on Modal is $0.80 / GPU-hr (source). Wall times come from the measured it/s in the table below; the OOM row is from baseline_benchmark_results.json (examples/modal_baseline_benchmark.py).

---

Repository layout

• fastvla/ — core library: model, adapters, kernels, RL trainers, registry.
• examples/ — runnable benchmarks (modal_smoke_benchmark.py, modal_production_benchmark.py, modal_baseline_benchmark.py) and training / inference examples.
• scripts/training/ — BC and RL training scripts.
• scripts/modal/ — Modal.com deployment and simulation scripts.
• scripts/dataset/ — Arabic localization and dataset translation tools.
• scripts/evaluation/ — benchmarking and success-rate evaluation.
• docs/ — BENCHMARKS, ACCESSIBILITY_ROADMAP, Arabic Datasets, RL Report.
• tests/ — kernel, data, model, loader, and config tests.

---

Measured throughput

Single-GPU training step time on Modal L4 + T4, real HF weights, synthetic batch (B = 1, T = 32). Reproducer: modal run --detach examples/modal_production_benchmark.py. Raw: production_benchmark_results.json, W&B project fastvla-production-benchmark.

The Unsloth-for-LLMs pattern (2-5× over HF + PEFT, 70 % less VRAM — Red Hat post), now applied to the vision + LLM + action-head stack.

Honest scorecard vs SOTA

Project north star is "Unsloth for VLAs". Scores below reflect post-Sprint 1 state (commits cbb8af9, 303ccad, f6fbaee, ec67ddc, 8a497b1).

xychart-beta horizontal
    title "FastVLA progress vs published SOTA training stacks (%)"
    x-axis ["VRAM accessibility", "Training cost / task", "Speedup vs vanilla QLoRA", "Reproducibility", "Multi-language data", "Inference Hz", "Feature coverage", "Library maturity", "Real-robot deployment"]
    y-axis "Achieved (%)" 0 --> 100
    bar [95, 95, 75, 90, 90, 25, 60, 30, 10]

Weighted toward the training axes that define the pitch (rows 1–5): ≈ 89 % of the Unsloth-for-VLA goal. Unweighted average across all nine axes: ≈ 63 %.

Where the remaining ~37 % lives, in order of impact: a real-robot evaluation loop, parallel-decoded inference (OFT recipe), measuring the vanilla 4-bit QLoRA baseline once the upstream OpenVLA + bnb load path is patched, and library polish (docs site, PyPI, HF model card).

Where the gains come from

• Skip LM head in forward (_encode_sequence). Kills the [B, T, ~128k] logits tensor every step. PR #4.
• Gradient / activation checkpointing actually wired into the trainer. Was declared but never enabled.
• PagedAdamW8bit instead of plain AdamW8bit. Optimizer state pages to CPU under pressure.
• DataLoader workers + pinned memory + persistent workers. Default num_workers=0 was starving the GPU.
• Turing-aware attention. sdpa on T4 (sm_75), flash_attention_2 on Ada (sm_89) / Ampere (sm_80).
• Fused Triton action head with cached forward for the autograd backward.
• Auto-torch.compile on Ada / Hopper. _auto_torch_compile() flips the default on when cuda.get_device_capability() >= (8, 9). (Sprint 1, 303ccad.)
• OpenVLA loader cascade. Four strategies tried in order: AutoModelForImageTextToText → AutoModelForVision2Seq → dynamic class load via auto_map → plain AutoModel. Falls back to SigLIP only as last resort, always with attn_implementation="eager". (Sprint 1, f6fbaee.)

Full per-lever breakdown (memory + speed + evaluation honesty + library polish) lives in docs/ACCESSIBILITY_ROADMAP.md. Speed-deep-dive with reference points + ratios in docs/BENCHMARKS.md.

---

Inference

Single-image inference, B = 1, T = 32, same protocol as the training table. Reported for completeness — the project is not optimised for raw inference Hz. For control-rate-critical deployments, see OpenVLA-OFT.

Caveat: in the production-benchmark image, FastVLA's OpenVLA-7B loader still falls back to a SigLIP-only vision tower. The cascade in fastvla/adapters/vision.py (Sprint 1) is correct, but the two upstream stacks — OpenVLA's pinned transformers==4.40.1 / timm<1.0 and FastVLA's modern Unsloth-compatible pins — have no version overlap. The standalone baseline image (examples/modal_baseline_benchmark.py) pins OpenVLA's exact recipe and successfully loads the full fused DINOv2 + SigLIP backbone (138 ms / 7.25 Hz / 14.1 GB L4 bf16, validates Kim 2024 Fig. 5). Numbers in the FastVLA rows above therefore characterise a "SigLIP + Llama-2-7B + FastVLA action head" deployment; closing the version gap is tracked alongside issue #2.

Reproduce every number

# Smoke test (dummy backbone, no HF download)
modal run --detach examples/modal_smoke_benchmark.py

# Real weights: OpenVLA-7B + SmolVLA on L4 + T4
modal run --detach examples/modal_production_benchmark.py

# Vanilla bf16 baseline: validates OpenVLA paper Figure 5
modal run --detach examples/modal_baseline_benchmark.py

Each script writes a JSON artefact (benchmark_results.json / production_benchmark_results.json / baseline_benchmark_results.json) and logs to W&B.

Sources

• OpenVLA paper: arXiv 2406.09246
• OpenVLA-OFT: openvla-oft.github.io / arXiv 2502.19645
• SmolVLA (LeRobot): HF blog / HF docs
• Unsloth: Red Hat
• Modal L4 pricing: modal.com
• FastVLA transparency: issue #1, issue #2, PR #4

---

Install

git clone https://github.com/BouajilaHamza/fastvla.git
cd fastvla
uv sync

Quickstart

Fine-tune any registered VLA on PushT (Arabic) on a single L4:

# 1. BC pretraining
modal run scripts/training/train_scratch_relative.py --bc-epochs 10

# 2. RL refinement with GRPO
modal run scripts/modal/modal_rl_grpo.py --epochs 100

Supported model presets out of the box: openvla-7b, smolvla, pi0-base, olmovla. Add your own via fastvla.registry.register_model(...). The Arabic data pipeline lives in scripts/dataset/; see ARABIC_DATASETS.md.

---

Deeper reading

• Training-speed deep-dive — per-GPU it/s, ratios vs vanilla QLoRA / OFT / Unsloth-on-LLM, and a citation for every number: docs/BENCHMARKS.md.
• Accessibility roadmap — every memory + speed lever between today and "Unsloth-for-VLA done", grouped by status: docs/ACCESSIBILITY_ROADMAP.md.
• RL technical report — PPO / GRPO results, policy consolidation, PushT stability: docs/reports/RL_TECHNICAL_REPORT.md.
• Arabic datasets — the translation pipeline and dataset release: docs/datasets/ARABIC_DATASETS.md.

---

License and citation

Apache-2.0. If FastVLA helps your work, please cite:

@software{fastvla2026,
  author  = {Bouajila, Hamza},
  title   = {FastVLA: Efficient Fine-Tuning for Vision-Language-Action Models},
  url     = {https://github.com/BouajilaHamza/fastvla},
  year    = {2026}
}

Acknowledgements

FastVLA stands on Unsloth for the 4-bit + LoRA kernels, PEFT and bitsandbytes for the quantisation stack, HuggingFace Transformers and LeRobot for the model + dataset primitives, Modal for the serverless GPU infrastructure, and the OpenVLA team for the model weights and the published baseline numbers we measure against.