Key Takeaways
- Free and open-source; the GitHub repository reports an Apache-2.0 license, and this review found no separate pricing page for the framework itself
- Two ways to use it: LLaMA Board (a Gradio-based web UI for training, evaluation, and inference with no code) and
llamafactory-cli(a command-line tool for scripted train/chat/export workflows) - Fine-tunes LLMs and vision-language models across 100+ model families — LLaMA, Qwen3, Mistral, Mixtral-MoE, DeepSeek, Gemma, GLM, Phi, LLaVA, Qwen3-VL, and more, ranging from 270M to 671B parameters per the README
- Supports full fine-tuning, LoRA, QLoRA, Freeze, GaLore, BAdam, DoRA, PiSSA, and OFT/OFTv2, across pre-training, supervised fine-tuning, reward modeling, PPO, and DPO
- Multi-backend hardware support: NVIDIA CUDA, AMD ROCm, and Ascend NPU, each with a dedicated Docker image, plus native install on Linux, Windows, and macOS
- Deploys trained models through an OpenAI-style local API server or a vLLM worker, and can optionally accelerate training using Unsloth's kernels as one of several backend options
- Maintained by hiyouga (an individual GitHub maintainer, per the GitHub API); repository created May 28, 2023, with commits pushed within days of this review's research date, 9,153 forks, and 1,152 open issues
📍 In One Sentence
LLaMA-Factory is a free, open-source (Apache-2.0) framework that fine-tunes 100+ open LLMs and vision-language models via a no-code web UI (LLaMA Board) or a Python command line, on NVIDIA, AMD, or Ascend NPU hardware.
💬 In Plain Terms
If you want to teach an existing open-weight AI model your own data — without writing a training script from scratch — LLaMA-Factory gives you a web page with dropdowns and sliders for picking the model, the dataset, and the training method, then runs the job on your own GPU. A command-line version exists too for automating the same steps.
What Is LLaMA-Factory?
LLaMA-Factory is a framework for fine-tuning open-weight LLMs and vision-language models on hardware you control, through a web interface instead of a hand-written training script. Its own GitHub description reads "Unified Efficient Fine-Tuning of 100+ LLMs & VLMs (ACL 2024)," referencing an academic paper accepted at the Association for Computational Linguistics 2024 conference. The project's landing page at llamafactory.readthedocs.io describes it as "an easy-to-use and efficient platform for training and fine-tuning large language models," built so users can "fine-tune hundreds of pre-trained models locally without writing any code."
- Core function: pick a base model, a dataset, and a fine-tuning method (LoRA, QLoRA, or full) through LLaMA Board's web interface or a YAML config file, then run and export the result
- Not text-only: alongside text LLMs, the README lists vision-language model (VLM) fine-tuning support, including models like LLaVA and Qwen3-VL
- Two products, one engine: LLaMA Board (the Gradio web UI, launched with
llamafactory-cli webui) andllamafactory-cli(the command-line tool both the UI and scripted workflows are built on) - Repository naming: the GitHub repository was renamed from
LLaMA-FactorytoLlamaFactory— a casing-only change; the old URL (github.com/hiyouga/LLaMA-Factory) 301-redirects to the same repository, stars, and commit history, so both names refer to the same project - Maintainer: hiyouga, listed as an individual user (not an organization) on the GitHub API, though the README states the project is "used by Amazon, NVIDIA, Aliyun" among others — a claim from the project's own README, not independently verified by this review
LLaMA-Factory's Release History
LLaMA-Factory's verifiable timeline comes from two official sources: GitHub's own repository metadata, and the project's tagged releases on GitHub.
- The GitHub repository was created on May 28, 2023, per GitHub's repository metadata — originally under the name
LLaMA-Factory - The project's associated academic paper, "LlamaFactory: Unified Efficient Fine-Tuning of 100+ Language Models," was accepted at ACL 2024, per the repository's own description line
- The repository was later renamed to
LlamaFactory(casing only); GitHub automatically redirects the oldLLaMA-FactoryURL to the current one, preserving stars, forks, and commit history - The most recent tagged release, v0.9.5 ("Qwen3.5/3.6, Gemma 4, Transformers v5"), was published on May 30, 2026, per GitHub's releases API
- Commits to the
mainbranch continued after that tag — GitHub's metadata shows a push within days of this review's research date, indicating active day-to-day development beyond the last formal release
What Can You Do With LLaMA-Factory?
LLaMA-Factory's feature set spans training method coverage, model breadth, hardware backends, and deployment. Here is what each part actually does, per the project's own GitHub README and documentation.
- Training methods — full fine-tuning, LoRA, QLoRA, Freeze, GaLore, BAdam, DoRA, PiSSA, and OFT/OFTv2, across pre-training, supervised fine-tuning (SFT), reward modeling, PPO, and DPO training paradigms
- Model breadth — 100+ model families including LLaMA, Qwen3, Mistral, Mixtral-MoE, DeepSeek, Gemma, GLM, and Phi, ranging from 270M to 671B parameters, plus vision-language models like LLaVA and Qwen3-VL, per the README
- No-code web UI — LLaMA Board, a Gradio interface, covers training, evaluation, and inference without writing a training script
- Command-line tool —
llamafactory-cliexposestrain,chat,export,webui, andversionsubcommands for scripting the same workflows LLaMA Board covers interactively - Quantization support — AQLM, AWQ, GPTQ, LLM.int8, HQQ, and EETQ formats are supported, alongside acceleration via FlashAttention-2 and an optional Unsloth-kernel integration
- Deployment — trained models can be served through an OpenAI-style local API or a vLLM worker for higher-throughput inference
- Distributed training — the documentation's Advanced section covers multi-GPU and multi-node training, alongside DeepSpeed integration for memory-efficient distributed jobs
- Experiment tracking — integrates with Wandb and TensorBoard for monitoring training runs, per the documentation
Usage Examples: Two Ways to Fine-Tune With LLaMA-Factory
These are concrete workflows built from LLaMA-Factory's documented commands above — not hypothetical use cases.
Fine-tune a model with the LLaMA Board web UI
After installing LLaMA-Factory, run llamafactory-cli webui to launch LLaMA Board in your browser. Select a base model from the dropdown, point it at a dataset, choose LoRA or QLoRA as the method, and start the job — no YAML file or training script required.
Fine-tune from the command line with a YAML config
Run llamafactory-cli train examples/train_lora/qwen3_lora_sft.yaml (or a modified copy of one of the example configs) to launch a scripted training run — the approach that fits CI pipelines or repeated experiments better than the interactive web UI.
Export and serve the fine-tuned model
After training, run llamafactory-cli export to merge LoRA weights into a standalone model, then serve it through the OpenAI-style local API for use with any OpenAI-compatible client, or hand it to a separate local inference tool like Ollama for day-to-day use.
Install LLaMA-Factory: Pip, Git, and Docker
LLaMA-Factory is not a downloadable end-user app — it installs as a Python package, per its own GitHub README and installation docs. Links below are the project's own documented commands; always verify against the docs directly, since extras and Docker paths can change between versions.
Install method | Command or link |
|---|---|
| From source (recommended by the docs) | git clone --depth 1 https://github.com/hiyouga/LlamaFactory.git && cd LlamaFactory && pip install -e . |
| Optional metrics extras | pip install -r requirements/metrics.txt |
| From PyPI | pip install llamafactory — see llamafactory on PyPI |
| Docker — NVIDIA CUDA | cd docker/docker-cuda/ && docker compose up -d |
| Docker — AMD ROCm | cd docker/docker-rocm/ && docker compose up -d (per the docs' Multi-device Backends section) |
| Docker — Ascend NPU | cd docker/docker-npu/ && docker compose up -d — see the NPU guide |
| Launch the web UI (LLaMA Board) | llamafactory-cli webui |
| Verify the install | llamafactory-cli version |
Optional extras install via `pip install -e ".[extra_name]", with extra_name options including torch, metrics, deepspeed, bitsandbytes, hqq, eetq, gptq, awq, aqlm, vllm, galore, badam, qwen, modelscope, and swanlab`, per the installation docs. The Ascend NPU Docker image ships in several Ubuntu and openEuler variants — see the NPU guide for the current list. Windows QLoRA and FlashAttention-2 support need extra platform-specific wheels — see the installation guide directly rather than guessing at wheel URLs, since they are version-pinned.
LLaMA-Factory Pricing: Is It Really Free?
Yes — LLaMA-Factory the framework carries no paid tier. The GitHub repository reports an Apache-2.0 license via GitHub's own API, which applies to the LLaMA-Factory codebase itself, and neither the README nor the documentation site links to a pricing page or describes a paid feature.
- No subscription, license fee, or paid tier documented for the framework in the GitHub repository, its README, or its documentation site
- No account or sign-up required to install
llamafactory-cli, run LLaMA Board locally, or use any of the Docker images - Apache-2.0 covers LLaMA-Factory's own code; it does not extend to the base models you fine-tune with it — models like Meta's Llama family or Qwen ship their own separate licenses that still apply to the weights you train and redistribute
- Cloud GPU costs (if you rent hardware instead of using your own) are a separate, real cost this review does not estimate — they depend entirely on the provider and instance type you choose
LLaMA-Factory vs. Unsloth
LLaMA-Factory and Unsloth are both free, Apache-2.0 tools for local fine-tuning, but they cover different ground. LLaMA-Factory focuses on breadth of models and training methods for text and vision-language models, with a documented path to multi-GPU and multi-node training; Unsloth covers a broader range of modalities (LLMs, diffusion, TTS, and embedding models) plus a native desktop app, at the cost of not documenting multi-node training in its own README.
Aspect | LLaMA-Factory | |
|---|---|---|
| License | Apache-2.0 | Apache-2.0 |
| Interface | Web UI (LLaMA Board) + CLI, no desktop app | Desktop app, web UI, or Python library |
| Model types | LLM + vision-language (VLM) | LLM, diffusion, TTS, embedding |
| Hardware | NVIDIA CUDA, AMD ROCm, Ascend NPU | NVIDIA, AMD, Intel, CPU via Vulkan |
| Multi-node training | Documented in the Advanced docs (multi-GPU/multi-node + DeepSpeed) | Not documented in its README |
| Best for | Widest model/method surface for text + VLM, including scaling past one machine | Broadest modality coverage (including non-text) in one desktop app |
The two tools are not purely rivals — LLaMA-Factory's own documentation lists an optional Unsloth-kernel acceleration backend, meaning a LLaMA-Factory training job can use Unsloth's optimized kernels under the hood while still running through LLaMA-Factory's web UI and config format. If your job needs to scale past one machine, LLaMA-Factory's documented multi-node path is the more direct fit; if you need diffusion, TTS, or embedding model fine-tuning rather than just LLMs and VLMs, see the Unsloth review instead.
Who Should Use LLaMA-Factory?
Whether LLaMA-Factory fits depends on whether you want the widest documented model and method coverage for text and vision-language fine-tuning, including a path to multi-GPU or multi-node scaling.
Use LLaMA-Factory if
- You want to fine-tune one of 100+ open LLM or vision-language model families without writing a training script, using a web UI
- You need a documented path to multi-GPU or multi-node training as your dataset or model size grows
- You want quantization-aware fine-tuning (AQLM, AWQ, GPTQ, HQQ, EETQ) and export options built into one tool
- You run AMD ROCm or Ascend NPU hardware specifically, not just NVIDIA CUDA
- You want the underlying tool to be open-source (Apache-2.0) with an academic paper (ACL 2024) behind its core method
Wait, or look elsewhere, if
- You want a native, point-and-click desktop app rather than a browser-based web UI — see the Unsloth review for its Desktop app option
- You need to fine-tune diffusion (image/video), text-to-speech, or embedding models rather than LLMs/VLMs — LLaMA-Factory's README does not list these model types
- You are Apple-Silicon-only and want the leanest possible native tool rather than a CUDA/ROCm/NPU-centric framework — MLX-LM is worth comparing directly
- You do not own a GPU and want the lowest-friction way to try fine-tuning at all — a free Colab-notebook-based option (see the Unsloth review) needs less local setup
LLaMA-Factory vs. Other Fine-Tuning Tools
LLaMA-Factory is one of several tools for fine-tuning models on your own hardware. Here is how it sits next to other options in that space — see the Local LLM Software Directory for the full catalog, and the dedicated LLaMA-Factory vs. Unsloth comparison above for the closest head-to-head.
- Unsloth — a free, Apache-2.0 tool covering LLM, diffusion, TTS, and embedding fine-tuning through a desktop app, web UI, or Python library; see the dedicated comparison section above for how the two differ.
- Second Me — an Apache-2.0, self-directed personal-model training tool with a narrower focus (training a personalized model on your own data) than LLaMA-Factory's general-purpose 100+ model fine-tuning scope.
- Axolotl — a YAML-config-driven, Apache-2.0 fine-tuning framework with documented multi-node training and a wide alignment-method surface (DPO, ORPO, KTO, and more); no dedicated PromptQuorum review exists yet, but it is a direct alternative for readers comparing config-driven, no-UI fine-tuning frameworks.
- Ollama and LM Studio — local inference tools for *running* models rather than training them; a common pattern is fine-tuning with LLaMA-Factory, exporting the result, then running it in Ollama or LM Studio for daily use. See the Ollama review and LM Studio review.
Common Mistakes When Evaluating LLaMA-Factory
Most confusion about LLaMA-Factory comes from its old repository name, its lack of a downloadable installer, or assuming its hardware table is a guaranteed result rather than a documented starting point.
Mistake 1: Assuming "LLaMA-Factory" only fine-tunes Meta's Llama models
The name is a holdover from the project's original scope. The current README lists 100+ supported model families — including Qwen3, Mistral, Mixtral-MoE, DeepSeek, Gemma, GLM, and Phi, plus vision-language models — not just Llama.
Mistake 2: Looking for a downloadable installer or app icon
LLaMA-Factory has no packaged desktop installer. It installs as a Python package via pip/git and a pip install -e . step, or as a Docker image; the web UI (LLaMA Board) then runs in your browser once the package is installed and llamafactory-cli webui is run.
Mistake 3: Treating the VRAM hardware table as a guarantee for every dataset
The documented VRAM figures (for example, ~16 GB for LoRA fine-tuning a 7B model) come from the project's own documentation, not independent PromptQuorum benchmarks. Actual usage depends on sequence length, batch size, and the specific quantization method chosen.
Mistake 4: Confusing the two repository name spellings as two different projects
The GitHub organization renamed the repository from LLaMA-Factory to LlamaFactory — a casing-only change. The old URL still works via a GitHub redirect, and both names point to the identical codebase, stars, and commit history.
Frequently Asked Questions
What is LLaMA-Factory?
LLaMA-Factory (github.com/hiyouga/LlamaFactory, docs at llamafactory.readthedocs.io) is a free, open-source (Apache-2.0) framework for fine-tuning 100+ open LLMs and vision-language models, using a Gradio web UI (LLaMA Board) or a command-line tool (llamafactory-cli).
Is LLaMA-Factory free?
Yes, per GitHub's repository metadata and the project's own documentation — the framework carries an Apache-2.0 license and no documented paid tier. The Apache-2.0 license covers LLaMA-Factory's code, not the license of whichever base model you fine-tune with it.
Why does the URL say "LLaMA-Factory" but the repository is called "LlamaFactory"?
The GitHub organization renamed the repository from LLaMA-Factory to LlamaFactory — a casing-only change. The old URL (github.com/hiyouga/LLaMA-Factory) 301-redirects to the current one, preserving the same stars, forks, and commit history.
Does LLaMA-Factory need a GPU?
A GPU is strongly recommended, not strictly mandatory. Per the project's documentation, CPU-only training is technically supported but impractical for real fine-tuning jobs; LoRA fine-tuning a 7B model is documented at roughly 16 GB of VRAM, as low as ~4 GB with 2-bit QLoRA.
How much VRAM does full fine-tuning need?
Per LLaMA-Factory's own documentation, full (bf16/fp16) fine-tuning of a 7B model needs roughly 60 GB of VRAM, and full fp32 fine-tuning of the same model needs roughly 120 GB — these are the project's documented figures, not numbers this review independently benchmarked.
What models does LLaMA-Factory support?
Per its GitHub README, 100+ open model families ranging from 270M to 671B parameters, including LLaMA, Qwen3, Mistral, Mixtral-MoE, DeepSeek, Gemma, GLM, Phi, and vision-language models like LLaVA and Qwen3-VL.
Does LLaMA-Factory have a desktop app?
No. It has a web UI (LLaMA Board) that runs in your browser after installing the Python package and running llamafactory-cli webui, but no packaged, installable desktop application. See the Unsloth review for a fine-tuning tool that does ship a native desktop app.
How does LLaMA-Factory compare to Unsloth?
LLaMA-Factory covers more model breadth for text and vision-language models plus documented multi-node training; Unsloth covers more modalities (including diffusion, TTS, and embedding models) plus a native desktop app. LLaMA-Factory can optionally use Unsloth's kernels as an acceleration backend. See the dedicated comparison section above.
Can LLaMA-Factory run on AMD or Ascend NPU hardware?
Yes — separate Docker images exist for AMD ROCm and Ascend NPU, alongside the default NVIDIA CUDA image, per the project's Multi-device Backends documentation.
Who maintains LLaMA-Factory?
hiyouga, listed as an individual GitHub user (not an organization) via the GitHub API. The project's README states it is used by organizations including Amazon, NVIDIA, and Aliyun — a claim from the project's own README that this review did not independently verify.