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.
πNote: This review is the deep-dive companion to LLaMA-Factory's entry in the Local LLM Software Directory β see that page for how it compares at a glance to dozens of other local AI tools.
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.
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 | Unsloth |
|---|---|---|
| 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.
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.
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.