Fine-tuning your own large language model used to mean renting a cloud GPU or owning a workstation with 24GB or more of VRAM. A new open-source tool called Soup claims to fine-tune an 8-billion-parameter model on a 4GB laptop GPU, which puts it in direct competition with the three tools most creators already reach for: Unsloth, Axolotl, and LLaMA-Factory. This is a head-to-head look at how the four stack up on the things that actually decide which one you should install: minimum VRAM, supported training methods, configuration effort, and Apple Silicon support.
Background
Local fine-tuning has quietly become one of the most useful skills in the creator toolkit. A fine-tuned model can copy your writing voice, classify assets in your own taxonomy, or hold a character persona without leaking your data to a hosted API. The barrier has never been talent. It has been VRAM. Full fine-tuning of an 8B model in half precision needs roughly 60GB, and even memory-efficient LoRA runs have historically wanted 8GB to 16GB to be comfortable.
Unsloth, Axolotl, and LLaMA-Factory each attacked that barrier from a different angle. Unsloth rewrote the attention and backpropagation kernels to cut memory and roughly double speed. Axolotl wrapped the Hugging Face training stack in a single YAML config so teams could reproduce runs. LLaMA-Factory built a broad menu of models and methods with an optional web UI. Soup is the newest entrant, and its pitch is the most aggressive on memory: stream the frozen base weights from system RAM to the GPU one decoder layer at a time so peak VRAM never has to hold the whole model.
Deep Analysis
The four tools overlap enough that headline features do not separate them. The differences that matter show up when you line up the constraints side by side.
| Tool | Min VRAM (8B) | Training methods | Config style | Apple Silicon |
|---|---|---|---|---|
| Soup | ~4GB (layer streaming) | 23 methods, 142 recipes | Single YAML, auto-detect | Native MLX (M1 to M4) |
| Unsloth | ~5GB to 8GB (LoRA) | SFT, DPO, ORPO, GRPO | Python notebook or script | Limited |
| Axolotl | ~10GB to 16GB (LoRA) | SFT, DPO, ORPO, KTO | Single YAML | No |
| LLaMA-Factory | ~8GB to 16GB (LoRA) | SFT, DPO, PPO, KTO, ORPO | YAML or web UI | No |
Minimum VRAM is where Soup pulls ahead
On the memory axis, Soup is doing something the others are not. By keeping frozen weights in RAM and feeding the GPU one layer at a time, it reports training Llama-3.1-8B on an RTX 3050 laptop GPU at 119.6 tokens per second using 3.32GB of peak memory, and a Qwen2.5-3B run at 264.2 tokens per second using 1.76GB. Unsloth is the closest competitor because its custom kernels genuinely lower LoRA memory, but it still wants the active model resident on the GPU. Axolotl and LLaMA-Factory lean on standard Hugging Face and PEFT paths, so their comfortable floor for an 8B LoRA sits higher. If your hardware is a 4GB or 6GB laptop GPU, Soup is the only tool on this list that treats that as a supported target rather than a stretch.
Training methods: breadth versus battle-testing
Soup advertises the widest menu on paper, with 23 methods and 142 pre-built recipes spanning supervised fine-tuning and preference methods such as DPO, ORPO, SimPO, and KTO, plus safeguards against reward hacking. LLaMA-Factory is the closest on breadth and adds classic reinforcement learning with PPO. Unsloth covers the methods most people actually use and pairs them with the fastest kernels. Axolotl is the most conservative list but the most battle-tested in production pipelines. The honest read is that recipe count is a weak signal. What matters is whether the two or three methods you need are implemented cleanly, and all four cover the SFT-plus-DPO path that most creators will ever touch.
Configuration effort and migration
Axolotl popularized the single-YAML approach, and both Soup and LLaMA-Factory follow it, while Unsloth stays closest to hand-written Python. Soup adds two conveniences that reduce setup friction: it auto-detects the GPU and picks a batch size and quantization without manual tuning, and it advertises second-long migration from existing Unsloth, Axolotl, and LLaMA-Factory configs. It also borrows a Git mental model for adapters, exposing diff, merge, and bisect operations so you can reason about what a training run changed. For a creator who has bounced off hyperparameter tuning before, the auto-detection is the feature most likely to get a first run to finish.
Ecosystem and hardware reach
All four pull models from the Hugging Face Hub, and Soup supports more than 200 of them, including Llama, Qwen, Mistral, Gemma, Phi, DeepSeek, and GLM, plus vision, audio, and TTS variants. The real hardware split is Apple Silicon. Soup ships native M1 to M4 support through MLX, which none of the other three match natively, and it scales to multiple GPUs through DeepSpeed when you graduate to a workstation. That makes Soup unusually portable across the exact machines creators own, from a MacBook to a single consumer NVIDIA card.
Impact on Creators
The practical takeaway is that the right tool now depends almost entirely on your hardware, not your ambition. If you are on a 4GB or 6GB laptop GPU or an Apple Silicon Mac, Soup is the one to try first, because it is the only option that treats low memory as the design center. If you have a single 8GB to 12GB NVIDIA card and want maximum speed on the common methods, Unsloth remains the strongest pick. If you run a reproducible team pipeline where other people need to rerun your config, Axolotl is still the safe institutional choice. If you want the widest method menu with an optional graphical interface, LLaMA-Factory covers that ground.
A concrete first project looks the same across all four: install the tool, point it at a base model and a few hundred examples of your own writing or labeled data, run supervised fine-tuning, and export to GGUF so the result loads in a local runner. Start small to confirm the memory path works on your hardware before committing to a longer preference-training job. With Soup, the install is pip install "soup-cli[train]" from the Soup repository, and the run is described in one YAML file.
Key Takeaways
Soup's differentiator is memory, not features. Layer streaming is what lets an 8B fine-tune land on a 4GB GPU, and that single design decision is why it is worth installing even if you already use another tool. The other three are not obsolete: Unsloth wins on speed per watt, Axolotl on reproducibility, and LLaMA-Factory on breadth plus its web UI. Recipe counts and method menus are marketing more than a decision axis, because the SFT-plus-DPO workflow that covers most creator use cases is implemented in all four. Pick on VRAM and platform first, then on config style.
What to Watch
The open question for Soup is whether layer streaming holds up on longer, larger runs. Streaming weights from RAM or NVMe trades I/O bandwidth for VRAM headroom, and on bigger models or longer context windows that trade can slow throughput or stall. The reported RTX 3050 numbers are promising on 8B and 3B models, but independent benchmarks on 13B and larger, and on multi-hour preference-training jobs, will decide whether Soup is a genuine everyday tool or a clever demo for the smallest models. Watch the Soup documentation and community reports for reproductions on hardware beyond a single laptop GPU, and watch whether Unsloth responds by pushing its own memory floor lower. The direction is clear either way: custom post-training is moving off the cloud and onto the machines creators already own.
