Axolotl

Axolotl is a free, open-source LLM fine-tuning framework built by Wing Lian and maintained under the Axolotl AI and OpenAccess AI Collective organizations on GitHub. It wraps Hugging Face Transformers, PEFT, and related libraries behind a YAML-driven configuration system, so training runs become reproducible artifacts you can commit to git, share with teammates, or hand off to CI/CD pipelines. Released under Apache 2.0, the framework carries zero licensing restrictions for commercial use and has attracted contributions from 170+ developers since its launch in 2023.

Axolotl supports over 100 model architectures, including Llama 4, Mistral Small 4, Qwen 3, Gemma 4, Granite 4, and a growing set of vision-language models such as Qwen-VL, Pixtral, and InternVL 3.5. Training methods span full fine-tuning, LoRA, QLoRA, preference tuning (DPO, IPO, KTO, ORPO), reinforcement learning (GRPO, GDPO), reward modeling, and quantization-aware training. Multi-GPU distributed training via FSDP1, FSDP2, and DeepSpeed is a first-class feature, along with multinode support through Torchrun and Ray. Datasets can be pulled from local disk, Hugging Face Hub, or cloud storage on S3, Azure, GCP, and OCI.

What Axolotl actually does in April 2026

The v0.16.0 release on April 2, 2026, was the framework's most significant update to date. Wing Lian announced two headline capabilities: ScatterMoE with fused LoRA Triton kernels delivering up to 15x faster MoE forward passes and 40x less memory than previous implementations, and async GRPO training with vLLM integration that achieves 58% faster step times by overlapping token generation with the training pass.

"Axolotl v0.16.0 is here. Two big pillars in this release: 1. MoE and LoRA, making MoE fine-tuning fast (15x faster, 40x less memory) and LoRA training seamless, across architectures, out of the box. 2. GRPO, async training (58% faster), custom Triton kernels, environment." -- Wing Lian (@winglian), X, April 2, 2026

The same release added Flash Attention 4 with automatic fallback, NeMo Gym integration for RL training environments, Energy-Based Fine-Tuning (EBFT) as a novel RL approach, CPU layer offloading for LoRA, MX Quantization-Aware Training, and new model support for Mistral Small 4, Qwen 3.5, and NeMo Super. Wing Lian also announced a complete documentation overhaul: "We also overhauled the docs, new guides for GRPO training, vLLM serving, training stability, debugging, and agent-specific workflows."

The v0.13.0 release in December 2024 introduced streaming SFT for unlimited dataset sizes, text diffusion training as a plugin, and NVFP4 quantization-aware training. The v0.15.0 release in March 2026 added Torch 2.10.0, SonicMoE kernels for Hopper and Blackwell GPUs, MoE expert quantization that reduced peak reserved memory from 127 GiB to 23 GiB for large mixture-of-experts models, and SageAttention integration.

The framework now covers the full post-training lifecycle through a single YAML file: dataset preprocessing, training, evaluation, quantization, and inference preparation. Key performance defaults include Flash Attention variants, multipacking (packing sequences together to eliminate padding waste), and sequence parallelism for long-context models. Wing Lian explained the rationale for the config-driven approach at the Latent Space podcast: "I really wanted it to be in a YAML file because it was more portable and reproducible."

Where Axolotl sits versus Unsloth and LLaMA-Factory

Unsloth is the fastest single-GPU fine-tuning tool available as of 2026, with 53.9k GitHub stars against Axolotl's 11.8k. Unsloth uses custom Triton kernels that replace standard FlashAttention 2 at a kernel level, achieving 2-5x faster training and 70-80% less VRAM than baseline methods. On a direct benchmark, Llama-3.1 8B QLoRA trained on an A100 40GB for two epochs over 512 tokens took 3.2 hours with Unsloth vs. 5.8 hours with Axolotl. Unsloth also delivers 12x faster MoE training and can fit GRPO reasoning model training into 5GB VRAM. The structural limitation: the open-source version of Unsloth is single-GPU only. Multi-GPU training requires an Unsloth Pro subscription. Teams scaling to 4, 8, or more GPUs who need open licensing choose Axolotl.

LLaMA-Factory sits at 68.4k GitHub stars and is the entry point for teams that need a web UI instead of a terminal. Its LlamaBoard interface handles dataset configuration, training method selection, and evaluation without any command-line interaction, and it internally uses the Unsloth acceleration backend so first-time users get competitive speed automatically. LLaMA-Factory's weakness is that low-level customization is restricted by the GUI, and production debugging through a web interface is harder than reading a YAML file that caused a training failure. Axolotl YAML configs are version-controllable, diff-able, and pipeline-compatible in ways that GUI-configured runs are not.

TRL (Transformer Reinforcement Learning, 17.6k stars) is the Hugging Face reference implementation for RLHF and GRPO, the technique DeepSeek used to train reasoning models. TRL is where alignment research papers get implemented first, but it is not optimized for throughput on supervised fine-tuning. Axolotl's v0.16.0 GRPO implementation with async vLLM overlap now makes it directly competitive with TRL for production alignment training at multi-GPU scale.

What the daily workflow actually looks like

An Axolotl training run starts with a YAML file. A minimal config specifies the base model (a Hugging Face Hub path or local directory), the dataset (Hub ID, local JSONL, or cloud storage URI), the training method (LoRA, QLoRA, full fine-tune), and any optimization flags. The YAML then drives dataset tokenization and preprocessing (run once, cached), training with the configured method, and optional evaluation. The CLI commands are short: axolotl preprocess config.yml followed by axolotl train config.yml.

For multi-GPU runs, the same YAML adds a DeepSpeed or FSDP2 stanza. A real production example from Spheron's 2026 benchmark: Llama-3.1 70B training on 8x H100 GPUs across 50,000 examples took 18 hours with Axolotl FSDP2 and produced an 8-12% improvement over QLoRA variants on downstream tasks. The config file was committed alongside the experiment results, making the run reproducible by any team member.

Red Hat's developer blog documented a three-step sparse fine-tuning pipeline built on Axolotl in June 2025. The workflow combined LLM Compressor for sparsification, Axolotl for sparse-aware fine-tuning using a ConstantPruningModifier recipe, and post-training quantization before vLLM deployment. The result: models 3x smaller and 2x faster with sparse FP8, or 5x smaller and 3x faster with sparse INT4, while retaining 99%+ accuracy on the task.

Axolotl is the framework behind several prominent open-source model families. Nous Research used it to train Puffin, Capybara, and NousHermes. Teknium's OpenHermes and Trismigestus models were built on Axolotl configs. The framework's YAML-based reproducibility means community configs for specific model/dataset combinations circulate on GitHub and Hugging Face alongside the fine-tuned weights, letting teams fork and adapt successful experiments rather than starting from scratch. For teams integrating with Predibase or OpenPipe for hosted fine-tuning, Axolotl's checkpoint format (standard Hugging Face Transformers) is compatible: adapters trained in Axolotl load directly into any Transformers-based inference stack.

Who Axolotl is built for

Axolotl targets ML engineers and research teams who need production-grade fine-tuning with full control over the training process. The profile: a team fine-tuning 7B-70B parameter models on domain-specific data, running on 2+ GPUs or a cloud GPU node, and needing the training run committed to version control so it can be audited, repeated, or handed to another engineer six months later.

The framework is particularly strong for: teams doing multimodal fine-tuning (vision-language or audio models) where Unsloth's coverage is incomplete; teams using DeepSeek-style GRPO to train reasoning or domain-specific RL models; teams integrating fine-tuning into MLOps pipelines where reproducibility matters more than minimizing wall-clock time on a single run; and teams doing sparse or quantization-aware training where Axolotl's QAT support and integration with compression tools like LLM Compressor provides a complete pipeline.

"For most users, especially if you are a beginner, we recommend using Axolotl due to its balance of accessibility and power." -- Modal.com fine-tuning guide, 2025

Axolotl also integrates naturally with the broader ecosystem. Datasets load from Hugging Face Hub with a single Hub dataset ID in the YAML. Training metrics stream to Weights and Biases or other supported loggers. Checkpoints save in standard Transformers format for direct inference deployment. Checkpoint compatibility is a meaningful practical advantage: because all four major open-source fine-tuning frameworks (Axolotl, Unsloth, LLaMA-Factory, and TRL) share the Hugging Face Transformers checkpoint format underneath, LoRA adapters trained in Axolotl load directly into Unsloth for inference, or into any Transformers-based serving stack including vLLM and llama.cpp. Teams are not locked in. Switching from Axolotl's YAML-driven training to a different inference runtime costs nothing except rewriting the config.

The YAML-as-config philosophy also shapes how Axolotl users share work. When researchers publish fine-tuned models on Hugging Face Hub, the YAML config file travels alongside the weights, making the training setup transparent and reproducible. This is a different culture than notebook-driven workflows: instead of a Colab notebook with embedded parameters, you get a declarative specification that any engineer on the team can run, audit, and modify without touching Python. For organizations where model training runs need to pass internal review or be reproduced months later for compliance or debugging, that audit trail is a material benefit over GUI-based tools.

What Axolotl is not

Axolotl is not the right first step for someone with no machine learning background. The installation requires Python 3.11+, PyTorch 2.9.1+, and a CUDA-compatible NVIDIA Ampere GPU or newer. First-time users regularly hit dependency version mismatches or out-of-memory errors on initial runs, and the error messages do not always point clearly to the YAML parameter responsible. One recurring complaint across reviews: "Axolotl is a great tool, but its documentation is not easy to follow." If you need a web interface, five-minute setup, and no command-line work, LLaMA-Factory is the correct choice.

Axolotl is also not the fastest single-GPU framework. If your constraint is maximizing training speed on one consumer GPU (RTX 4090, 3090, or free Colab instance), Unsloth will beat Axolotl's throughput by roughly 2x at comparable VRAM usage. The abstraction layers around Hugging Face Transformers add overhead that shows up clearly in single-GPU benchmarks. Axolotl's multi-GPU advantage only materializes when you have 2+ GPUs and need FSDP or DeepSpeed coordination.

Finally, Axolotl is not a managed service or API. There is no Axolotl endpoint you can call to fine-tune a model. You run it yourself on your own hardware or a cloud GPU provider. Teams that want fine-tuning as a managed API should look at Predibase or OpenPipe instead.