Unsloth Desktop: Fine-Tune on 8GB VRAM, No Code

Short answer: yes, an 8GB card can fine-tune a model, and as of 11 August 2026 you can do it by clicking buttons. Unsloth's own published VRAM table puts QLoRA training of an 11B model at 7.5GB and a 7B at 5GB. Unsloth Desktop wraps that in a native app for Windows, macOS and Linux, defaults every hyperparameter for you, shows live loss curves and a GPU monitor, and exports straight to GGUF for Ollama and LM Studio. It is free, Apache-2.0, and about 42MB to download.

The interesting part is not that no-code fine-tuning exists. It is that the project doing it is the one that spent three years making fine-tuning fit on small cards in the first place — so the memory numbers behind the GUI are the credible ones.

---

What Shipped, and When {#what-shipped}

Unsloth Desktop was announced on 11 August 2026, in a release titled "Introducing Unsloth Desktop". It shipped twice that same day — v0.1.70-beta, then v0.1.701-beta a few hours later carrying the first round of fixes — and twice more inside four days: v0.1.702-beta on 13 August, and v0.1.800-beta on 14 August adding Qwen3.8-27B support. The GitHub repository description was rewritten at the same time to "Local UI to run and train LLMs and diffusion models" — the project reframed itself from a library into an app.

Some grounding numbers, read live on 18 August 2026 — the star and fork counts move daily, so they are rounded:

Worth reading that fourth row carefully: this is a repo from 2023 with a large existing star count, so the headline number is not a measure of how the app landed. What is a signal is the cadence — four releases in four days, and Qwen3.8-27B support landing on 14 August, a day after the community GGUF conversions of that model appeared.

The release notes call it "the first desktop app to run and train AI models locally". That is a marketing claim, not something we can verify, and plenty of apps run models locally. The genuinely unusual half is train: LM Studio, Jan, Ollama and the rest are inference clients. This one has a training tab.

What is actually in the box

Per the release notes and documentation, Unsloth Desktop is four products stacked in one window:

• Chat — run GGUF, safetensors and MLX models locally, with document, image and audio upload, side-by-side model comparison, sandboxed Python and Bash execution, web search, deep research, RAG and MCP tool connections.
• Training — no-code QLoRA, LoRA or full fine-tuning for text, vision, audio and embedding models.
• Data Recipes — dataset building and editing, including from PDFs and DOCX files.
• Export — merged 16-bit, LoRA-only or GGUF, saved locally or pushed to Hugging Face.

Plus an OpenAI-compatible API server, so anything that speaks the OpenAI protocol — including Ollama-style tooling and coding agents — can point at it.

---

The 8GB Question {#vram-table}

Unsloth publishes its own minimum-VRAM table, and it is the most useful thing on their entire documentation site. These are the numbers behind the headline, sorted by model size and training method. QLoRA is 4-bit, LoRA is 16-bit.

Read across the tiers and the practical map falls out:

• 8GB card (RTX 4060, 5060, 3060 Ti): QLoRA up to 11B. 14B is 8.5GB — over the line, though a 14B may still work with batch size 1 and short sequences.
• 12GB card (RTX 3060 12GB, 5070, Arc B580): comfortably 14B, with room to breathe.
• 16GB card: still 14B-class for QLoRA, but you can start using longer context lengths without OOM-ing.
• 24GB card (3090, 4090): 27B QLoRA at 22GB — tight but the table says it fits.
• 32GB card (5090): 27B comfortably, 32B QLoRA at 26GB.

Unsloth describes these as "the absolute minimum" and warns that some models need more. Their stated first fix for an out-of-memory error is not a smaller model — it is batch size, set to 1, 2 or 3. The app's default is 4 with gradient accumulation of 8, which is a sensible default on a big card and the first thing to change on a small one.

The release notes also claim training is "up to 2× faster and uses up to 70% less VRAM" on supported LLM workloads. That is a vendor claim and no baseline is specified, so treat it as marketing. The table above is the part you can plan against.

If you are unsure what your card can hold at inference time either, our 8GB VRAM model picks cover the other half of the problem.

---

System Requirements {#requirements}

The requirement that catches most people is Python: 3.11 up to but not including 3.14. Everything else is ordinary.

Windows — and note this runs natively, no WSL needed:

• Windows 10 or 11, 64-bit
• NVIDIA GPU with drivers installed (for training)
• App Installer, which provides winget
• Git — winget install --id Git.Git -e --source winget
• Python 3.11 to 3.13
• Work inside uv, venv, or conda/mamba

macOS — training, MLX and GGUF inference are all supported:

• macOS 12 Monterey or newer, Intel or Apple Silicon
• Homebrew, then brew install git cmake openssl
• Python 3.11 to 3.13

Linux and WSL:

• Ubuntu 20.04+ or similar, 64-bit
• NVIDIA GPU with drivers
• CUDA toolkit 12.4+, or 12.8+ for Blackwell cards
• Python 3.11 to 3.13

CPU only: you get Chat and Data Recipes. Not training. The documentation is unambiguous about this, and Export on CPU-only setups is listed as coming soon rather than shipped.

---

Install It {#install}

Two ways: download the app, or run a one-liner. The app is the easier path and both end up at the same place — a local web UI on port 8888.

Option 1: the installer

Grab it from unsloth.ai/download — 42.7MB for Apple Silicon macOS, 44.3MB for Ubuntu/Debian, 41.5MB for Windows 10/11. Install, launch, done.

Option 2: the terminal

macOS, Linux and WSL:

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

Windows PowerShell:

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

The installer sets up the environment, pulls dependencies, and offers to start Unsloth immediately. Say yes and it binds to port 8888.

Starting and reaching it

# start it manually
unsloth studio -p 8888

# make it reachable from other machines on your network
unsloth studio -H 0.0.0.0 -p 8888

# publish it over HTTPS through a free Cloudflare tunnel
unsloth studio --secure

Open http://127.0.0.1:8888. On first launch you set a password — do that even on a machine you trust, because the -H 0.0.0.0 flag above turns this into a network service with a training queue and a filesystem behind it.

Downloaded models land in your Hugging Face cache — ~/.cache/huggingface/hub on macOS, Linux and WSL — and existing models pulled by Hugging Face, LM Studio and friends are detected automatically, so you are not re-downloading weights you already have.

---

Your First Fine-Tune {#first-finetune}

Four panels: Model, Dataset, Parameters, Training. The Start Training button stays greyed out until the first two are filled in.

1. Pick a model and a method

Choose the modality first — Text, Vision (image plus text), Audio, or Embeddings — then the training method:

On an 8GB or 12GB card, QLoRA is the only realistic option, and it is the one the VRAM table above is built around. Type any Hugging Face model name or search the Hub from the combobox; local models appear in the same list. Paste a Hugging Face token if the model is gated.

The gotcha that will get you: GGUF models are excluded from training. They are inference-only. If you have been running everything as GGUFs through Ollama, you need the original safetensors repo for the base model, not the quantised file you already have on disk.

2. Point it at data

Two tabs. Hugging Face Hub does live search against the Hub and shows a last-updated date for each result. Local takes a drag-and-drop upload — PDF, DOCX, JSONL, JSON, CSV or Parquet, so unstructured documents are a first-class input, not something you have to convert first.

Then tell it how to read your data:

If it cannot map your columns automatically, a Dataset Preview dialog opens with sample rows and lets you assign each column to a role by hand. You can also set an eval split — do it, because that is what turns on the Eval Loss chart, and a loss curve without an eval line tells you nothing about overfitting.

For getting your own material into one of those shapes, our train on your own data guide covers dataset construction properly.

3. Click Start Training

A full-page overlay shows an animated terminal with colour-coded phases — downloading, loading, configuring, training — and you can cancel out of it at any point.

Once the first step lands, the overlay drops and the live view appears: current epoch as a fraction, a step-based progress bar, loss to four decimal places, learning rate in scientific notation, gradient norm, elapsed time, ETA, steps per second and total tokens processed. Beside it, a GPU monitor polling every few seconds for utilisation, temperature, VRAM used against total, and power draw against limit.

That VRAM readout is the thing to watch on a small card. If it is pinned at 99% you are one long sample away from an OOM crash — stop, halve the batch size, restart.

Four live charts: training loss with an EMA-smoothed line and running average, learning rate schedule, gradient norm, and eval loss if you configured a split. Stopping gives you two choices — Stop & Save, which writes a checkpoint first, or Cancel, which does not.

---

The Settings That Matter {#settings}

Unsloth pre-fills every hyperparameter when you pick a model, and the defaults are reasonable. Three of them are worth changing.

The shipped defaults:

The three to touch:

1. Batch size, if you are under 12GB. Drop it to 1 or 2. Gradient accumulation of 8 keeps the effective batch size where it should be, so you lose almost nothing but wall-clock time.
2. Context length, if your samples are short. The 2048 default reserves memory you may not need; dropping to 512 or 1024 on a short-form instruction dataset frees real VRAM.
3. Epochs, if your dataset is small. Three passes over 200 examples is a fast route to a model that has memorised your data and forgotten how to write English.

Leave gradient checkpointing on unsloth — that is their own implementation and it is the reason the VRAM numbers look the way they do. Every configuration can be saved and reloaded as YAML, auto-named {model}_{method}_{dataset}_{timestamp}.yaml, which is how you make a run reproducible without writing any code.

For what the LoRA numbers actually mean, our LoRA fine-tuning guide and QLoRA guide go deeper than a settings table can.

---

Export to GGUF and Into Ollama {#export}

Three export types, and only one of them ends up in Ollama.

Pick a training run, then a checkpoint within it — later checkpoints are usually the finished model but any of them can be exported. Then choose:

Save locally, or push to the Hugging Face Hub with a write token (leave the token blank if you are already authenticated through the Hugging Face CLI).

For Ollama, take the GGUF export and write a Modelfile next to it:

FROM ./my-finetune.gguf

Then:

ollama create my-finetune -f Modelfile
ollama run my-finetune

That is the full loop: base model in, your data on top, quantised file out, running under Ollama beside everything else you already pull. If you are wiring the result into an actual workflow rather than just testing it, fine-tuning for business use covers what happens after the export.

---

Gotchas and Honest Limits {#gotchas}

It is labelled Beta, and it behaves like it. Every version number carries a -beta suffix. The first patch landed the same day as the launch — it fixed slow Windows downloads (throttling, described in the release notes as a 200× difference), a macOS bug that kept prompting for command line tools, and AMD Strix Halo GPUs not being detected — and the 13 August release went further on AMD RDNA3/4, Strix Halo and Mac support. That is a healthy response time, and also a sign of how new the surface is.

The rest, in order of how likely you are to hit it:

• GGUFs cannot be trained. Inference only. You need the original safetensors repo.
• CPU-only means no training. Chat and Data Recipes work; the training tab does not. Export on CPU is listed as coming soon.
• The VRAM table is a floor, not a guarantee. It excludes your context length, your batch size, and whatever your desktop compositor is already holding.
• Non-NVIDIA training is newer. AMD, Intel and Mac MLX training are all documented as working, but the Windows and Linux requirement lists both name an NVIDIA GPU specifically. If you are on AMD or Intel, budget time for setup you would not spend on NVIDIA.
• Full fine-tuning is a trap on consumer cards. The 16-bit LoRA column in the VRAM table already needs 19GB for a 7B. Full fine-tuning is above that. The pill selector makes it one click away; the hardware does not.
• Nobody has independently verified the speed claims. "Up to 2× faster, up to 70% less VRAM" appears with no stated baseline. The absolute VRAM figures are checkable; the improvement percentages are not.

We have not yet run our own timing benchmarks across card tiers, so this guide deliberately quotes Unsloth's published requirements rather than inventing tokens-per-second figures for hardware we have not measured.

---

Should You Switch From Notebooks? {#verdict}

If you have never successfully fine-tuned anything, yes — this removes the failure mode that stops most people, which is environment setup rather than machine learning. Python versions, CUDA toolkits, bitsandbytes builds, dataset formatting: the app handles all of it and pre-fills defaults that work.

If you already have a Colab notebook you like, the app is not obviously better for training — it is the same engine underneath, and a notebook is easier to version and share. What you gain is the GPU monitor, the loss charts, the YAML config export, and the fact that the same window is also a chat client, a RAG system and an OpenAI-compatible server. That consolidation is the real pitch, more than the no-code part.

If you are on 8GB, this is the cheapest credible route to a custom model. An 11B QLoRA at 7.5GB on a card most people already own, with an export path straight into Ollama, is a genuinely different proposition from where local fine-tuning was two years ago.

One thing to try first: fine-tune a 3B at 3.5GB with a small dataset and three epochs. It will finish quickly, it will teach you what the loss curve should look like, and you will find out whether your export path works before you commit six hours to a 14B.

Pair it with a model worth training on top of — Qwen3.8-27B if you have the 22GB the table asks for, or something in the 8GB tier if you do not. And if you want to train image LoRAs rather than language models, our image LoRA training guide is the separate discipline it deserves to be.

---

Sources {#sources}

• unslothai/unsloth GitHub releases and repository metadata — release dates, titles, star and fork counts, licence
• Unsloth documentation, Requirements page — the QLoRA/LoRA VRAM table and per-OS system requirements
• Unsloth documentation, Studio install and Get Started pages — install commands, defaults, training walkthrough
• Unsloth documentation, Export page — export types and targets
• unsloth.ai/download — platform download sizes

---

FAQ {#faq}