AI Development

Unsloth: Run and Fine-Tune LLMs on Your Own GPU

September 12, 2026
9 min read
Home GPU workstation running and training a local LLM with Unsloth
Share:

Renting GPU hours every time you want to experiment with an LLM gets expensive fast. Unsloth flips that: it is an open-source app that lets you run and train models like Qwen, Kimi K3, DeepSeek and Gemma directly on your own machine, with fine-tuning that is 2x faster and uses up to 80% less VRAM.

In this guide I show you what Unsloth is, how its 4-step workflow works, the verified install commands, how much VRAM you really need, and when you should NOT use it.

1. What Is Unsloth: Stars, License and Scope

Unsloth (github.com/unslothai/unsloth) is, in their own words, the first desktop app to run and train models locally. It covers text, vision, audio, embedding and diffusion models: Qwen3.8, Kimi K3, MiniMax-H3, Gemma 4, DeepSeek-V4 and FLUX, in GGUF and MLX formats. It also serves everything through an OpenAI-compatible API, so your coding agents can use local models.

Repo facts (verified Aug–Sep 2026)

Stars:~76k stars on GitHub
License:Apache-2.0 (main repo)
Speed:2x faster fine-tuning
Memory:Up to 80% less VRAM
Notebooks:250+ fine-tuning and RL notebooks
Platforms:Windows, Linux, macOS, WSL, Docker

The headline claim is memory efficiency: 4-bit QLoRA fine-tuning of Llama 3.1 8B fits very different context lengths per card, and reasoning-model training (GRPO) is advertised from just 5GB of VRAM. Concrete numbers from their own benchmarks are in section 3.

How much VRAM do you need? (their numbers)

Llama 3.1 8B QLoRA, 8GB card~3k context
Llama 3.1 8B QLoRA, 12GB card~21k context
Llama 3.1 8B QLoRA, 24GB card~78k context
Qwen3-30B-A3Bfits in 17.5GB VRAM
gpt-oss 20B / 120B14GB / 65GB VRAM
GRPO reasoning trainingfrom 5GB VRAM

2. How It Works: The 4-Step Architecture

Unsloth is three things in one: Unsloth Desktop (native app, recommended), Unsloth Studio (web UI), and Unsloth Core (code-first pip package). Every workflow follows the same four steps:

1

Pick a pre-quantized model

Grab one of Unsloth’s Dynamic 2.0 quants from Hugging Face (4-bit, GGUF or bnb-4bit). The quantization work is already done and benchmarked, so you skip the hardest part of local inference.

No quant knowledge needed
2

Run it behind a local API

Studio serves the model through an OpenAI- and Anthropic-compatible endpoint. Point Claude Code, Codex, OpenCode, OpenClaw or any MCP tool at localhost and your agents run on local weights.

Agents included
3

Fine-tune with QLoRA

Add your dataset in one of the 250+ notebooks (SFT, DPO, GRPO, vision, TTS, STT, embeddings), press Run All, and train with 4-bit QLoRA kernels that are 2x faster and use a fraction of the VRAM.

2x faster, 80% less VRAM
4

Export anywhere

Save the result as GGUF, 16-bit safetensors, or push it to Ollama, vLLM, llama.cpp or Hugging Face. Your fine-tune leaves your machine in a deployable format.

GGUF · vLLM · Ollama · HF

3. Quickstart: Verified Install Commands

All commands below come from the official README and install wiki. Pick ONE path: the desktop app (easiest), Studio (web UI), or Core (pip, for notebooks).

Option A — Studio web UI (Linux, macOS, WSL)

One-line installer, then launch the local UI:

curl -fsSL https://unsloth.ai/install.sh | sh
unsloth studio

Secure/remote variant: unsloth studio --secure (HTTPS via Cloudflare).

Option A — Studio web UI (Windows)

Same flow in PowerShell:

irm https://unsloth.ai/install.ps1 | iex
unsloth studio

Or download the native Desktop app for Windows from unsloth.ai.

Option B — Core pip install (for fine-tuning notebooks)

CUDA 12.1 + Torch 2.5 build. If unsure, run their auto-install script instead:

pip install "unsloth[cu121-torch250] @ git+https://github.com/unslothai/unsloth.git"
# --- or auto-detect the right build: ---
wget -qO- https://raw.githubusercontent.com/unslothai/unsloth/main/unsloth/_auto_install.py | python

Needs matching Python + CUDA + torch + triton + xformers versions.

Serve a model (vLLM, OpenAI-compatible)

Example with a real Unsloth quant, straight from its model card:

pip install vllm
vllm serve "unsloth/Qwen3-4B-Instruct-2507-unsloth-bnb-4bit"
curl -X POST "http://localhost:8000/v1/chat/completions" -H "Content-Type: application/json" --data '{"model": "unsloth/Qwen3-4B-Instruct-2507-unsloth-bnb-4bit", "messages": [{"role": "user", "content": "What is the capital of France?"}]}'

Any OpenAI client works against port 8000 from here.

Plug in your coding agent

Unsloth wires local models into agent CLIs with one command:

unsloth start opencode
# also: unsloth start claude | unsloth start codex | unsloth start openclaw

GGUF shortcut for other runtimes: ollama run hf.co/unsloth/Qwen3-14B-GGUF:UD-Q4_K_XL

Tip: start from a notebook, not from scratch

The unslothai/notebooks repo has 250+ beginner-friendly notebooks (text, vision, audio, TTS, embeddings). Add your dataset, click Run All, export to GGUF/Ollama/vLLM/Hugging Face. That path is tested by thousands of users; hand-rolled training loops are where VRAM surprises live.

4. Real-World Use Cases

Where Unsloth earns its stars: anything where data, cost or iteration speed pushes you off the cloud.

💻

Private coding assistant

Serve Qwen or DeepSeek locally, point your agent CLI at localhost, and code with zero tokens billed and zero code leaving the machine.

🏥

Domain fine-tunes (medical, legal, support)

QLoRA a 7–8B model on your own tickets, docs or guidelines. The MedCoT-7B style projects show the pattern: distill reasoning into a small local model.

🌍

Offline / air-gapped deployments

Once downloaded, GGUF models run with llama.cpp, Ollama or Docker with no network. Ideal for regulated environments.

🧪

Cheap RL experiments

GRPO reasoning training from ~5GB VRAM means a single RTX 3060/4060 can run alignment experiments that used to need a cluster.

🎨

Local image generation

FLUX and diffusion models run through the same Studio UI, so one app covers both your LLM and image needs.

📦

Quant publishing

Fine-tune once, export Dynamic 2.0 quants to Hugging Face, and serve the same weights via vLLM, SGLang or Docker Model Runner.

5. When NOT to Use It

Unsloth is excellent, but it is not a cloud replacement. Be honest about these limits before committing:

✅ Use Unsloth when…

  • You have a CUDA NVIDIA GPU (8GB+ ideally) or Apple Silicon with MLX
  • Privacy matters: code, medical, legal or internal data
  • You fine-tune 7–30B models with QLoRA/SFT/DPO/GRPO
  • You want agents on local models via an OpenAI-compatible API
  • Cloud GPU bills exceed the price of your own card

❌ Do NOT use it when…

  • You only have CPU or an old 4GB GPU — inference will crawl
  • You need 70B+ dense models at full precision (needs 40–80GB VRAM)
  • You want zero setup: managed APIs still win on convenience
  • You need multi-GPU training today (listed as coming soon)
  • Your stack is AMD/ROCm or exotic drivers — expect friction

Golden rule

If your model fits in your VRAM in 4-bit and your data cannot leave the building, Unsloth is the best tool in 2026. If neither is true, pay for the API and spend the saved hours on your product.

Conclusion

Unsloth earned its ~76k stars by removing the two excuses for not training locally: it is 2x faster and needs up to 80% less VRAM, and the Studio UI plus one-line installers removed the setup pain. Qwen, Kimi, DeepSeek, Gemma and FLUX all run on hardware you can actually own.

My recommendation: install Studio this week, serve one 4–8B quant, wire it to your coding agent, and run one notebook fine-tune on your own data. That single loop teaches you more than ten cloud demos.

Unsloth in 30 seconds

Repo

  • ~76k stars · Apache-2.0
  • Qwen3.8 · Kimi K3 · DeepSeek-V4
  • Gemma 4 · FLUX · GGUF · MLX

Install

  • Desktop app (easiest)
  • curl …/install.sh | sh
  • pip unsloth[…] @ git+…

VRAM guide

  • 8B QLoRA from 8GB
  • 30B MoE ≈ 17.5GB
  • GRPO from 5GB
Diego Rodriguez

Diego Rodriguez

Senior Full-Stack & AI Engineer

Diego has 10+ years of experience building production-grade AI-powered applications, from LLM orchestration and RAG pipelines to ML-driven risk detection and algorithmic trading systems.

Learn more about Diego