Unsloth Desktop is here: run local models, train them, and fine-tune them right on your computer
- Unsloth turned its signature trick — "2x faster training, 70% less VRAM" — into a desktop app.
- Other local tools let you run models; this one lets you train them. Drag in a PDF or spreadsheet and it starts fine-tuning, no code needed.
- Both headline numbers are missing half the story; I've filled in the caveats below. And the limitation they wrote themselves is worth more attention than the numbers.
Local model apps are everywhere — ones that can train are not
Unsloth released its desktop app on August 11: Unsloth Desktop, in Beta, free and open source, available on Mac, Windows, and Linux. Its pitch: the first desktop app that both runs local models and trains them. Drop in a PDF, CSV, or JSON and fine-tune without writing a single line of code.
Apps that run models on your computer have been around for a while — install, click, chat. The hard part was always the other half: teaching a model with your own data meant setting up a Python environment, wrestling with GPU drivers and VRAM limits. Most people gave up right there.
And Unsloth's specialty was always making training faster and cheaper
Anyone who fine-tunes models knows the name. Unsloth started as an open-source framework that made fine-tuning faster, and its banner numbers have been up for a long time: 2x faster, 70% less VRAM, no loss in accuracy. 70k stars on GitHub (verified by us).
Take an existing large model and train it a bit more on your own data, so it understands your specific domain.
It's like hiring a capable newcomer and spending a month showing them your company's old files — after that, they know the ropes.
The training features in the desktop app are that same engine, moved into a GUI. The same code repo now describes itself as a "local interface for running and training models."
So dragging a file in really does start the fine-tune — no code
Drop in a PDF, CSV, or JSON and you're off. Three training modes: LoRA, which attaches a small patch and leaves the base model untouched; full fine-tuning, which updates the whole model; and pretraining from scratch. Multi-GPU is supported, and text, image, diffusion, and audio models all train.
Instead of modifying the base model, LoRA trains a small "patch" that sits alongside it. It's fast and light on VRAM. The finished patch is only tens of MB, and you can swap it out anytime.
Like changing the lens on a camera — the body stays, only the glass in front changes.
For image models, they get specific: train your own LoRA for generators like SDXL, FLUX.2, Qwen-Image, and Z-Image, using your own images. In the built-in Studio, caption the images, pick a patch size, and hit start.
What you train isn't locked inside this app: you can export to standard formats like GGUF or NVFP4 and take them anywhere.
But that 13-second video generation ran on a data-center card
Unsloth gave one number for generation: with MiniMax-H3, rendering a 960×544, 124-frame, 8-step video dropped from over 70 seconds to 13 seconds.
70+ seconds
13 seconds
This was benchmarked on an NVIDIA B200 — a data-center accelerator that costs more than several top-end desktops put together. Not in the same league as the GPU under your desk. Unsloth didn't say how long the same video takes on consumer hardware.
Generation isn't just video: FLUX, Z-Image, LTX, and Wan all run, and you can attach your own LoRAs. Besides generating from scratch, you can edit images, do regional inpainting, outpaint edges, upscale, and edit based on a reference image.
Audio lives in the same window: speech-to-text and text-to-speech both run locally, with Whisper and Qwen3-ASR supported — and both can be trained, too.
Unsloth also claims tool-call accuracy improved by 50%. But compared to what, on what benchmark, and over how many runs? The docs don't say. Take it as a directional hint at best.
And the most common way local models fail is tool calling
Models running on your own machine are generally smaller than cloud models. Small models do fine at most things, but they trip over tool calls: malformed parameter formats, getting stuck in a loop retrying the same action, or spitting internal markup straight into the chat.
Unsloth has a fix for each of those three failure modes:
When a model fails a tool call, the system spots the mistake itself, corrects it, and retries — without bothering you.
Like a waiter who writes the order wrong, the kitchen catches the mismatch, checks it, and fixes it — instead of serving a dish nobody asked for.
Code execution runs Bash and Python inside an isolated sandbox, so a bad run can't harm your system.
And for permissions, Unsloth went straight at Claude Code
This is explicitly modeled on Claude Code (Anthropic's command-line coding agent). Any model that calls tools falls under the permission system: without your approval, neither the model nor Unsloth can access or modify your files, or go online. How loose you want it is your call — four tiers.
And you can plug Claude Code into your local model
It's a single command: launch Unsloth, load a model, open your project folder, then run
unsloth start claude
Officially supported for this: Claude Code, Codex, Hermes Agent, OpenClaw, OpenCode, and Unsloth's own interface. So you keep the coding agent you already use — you're just swapping the model doing the work from the cloud to the one on your machine.
There's also a more granular setup, shown in the launch video: instead of replacing the whole backend, you hand only some tasks to the local model. Claude Code keeps using its own model; you add one flag to the command and it gains a helper running on your machine. Then, inside Claude Code, you say something like "send a local agent to implement this function," and that sliver of work lands on your hardware. Pick your coding tool, model, and quantization level in the UI, and the command is generated for you — copy and go.
Once it's running, you don't have to sit at that desk: a free official Cloudflare tunnel gives you an HTTPS address to check progress from your phone; or keep it off the public internet and bind it to your LAN.
Search comes in two tiers. Regular search is the model looking things up as it goes. Deep research plans a few steps first, then hunts for what it considers the best sources, and hands back a fully cited report. Both are unlimited and both originate from your machine.
Two other staples are here: attach your own document collection for Q&A (RAG), and connect to MCP servers to reach external tools. The same interface also works with cloud models — OpenAI, Anthropic, Ollama, llama.cpp, vLLM — so flipping between local and cloud doesn't mean switching apps.
And Unsloth itself wrote down when it gets slower
The FAQ has a question that reads: "Why is inference sometimes slower?" The answer, written by Unsloth itself:
Web search, code execution, and tool-call self-healing all take time. Turn them off, and the speed should match any other llama.cpp app. If it's still slow, open an issue.
Unsloth official docs · FAQ
You don't often see a vendor volunteer the conditions under which its product gets slower — and hand you the off switch in the same breath.
The same FAQ section has two more practical points: no telemetry — it only detects your GPU model and device class to know what will run, and the whole app works fully offline; and it's not GPU-only — CPU and Mac both work, with NVIDIA, Intel, AMD, and Apple chips all supported, though very old hardware may struggle. Models you've downloaded before are recognized automatically, so you don't redownload them.
So how do you install it, and what can run it?
Three steps: download and install; pick a model and quantization from the dropdown at the top or the Model Hub tab that matches your hardware; then start typing.
It lowers the numerical precision of the model's weights, trading a tiny bit of quality for a much smaller footprint and faster inference. The more you compress, the less VRAM you need — which is the only way smaller machines run these models at all. When you pick a level, you're choosing where to land between "runs on my machine" and "answers well."
Like compressing a lossless track to MP3 — the file gets a lot smaller, you lose a little detail, but it still sounds fine.
The launch acknowledgments thank NVIDIA and Hugging Face for their involvement, and Jan for the inspiration — plus llama.cpp, PyTorch, and stablediffusion.cpp for providing the foundation. That last line basically tells you where this interface came from.
Unsloth ships a desktop app: local models don't just run — drag a file in and train
Free and open source, on Mac / Windows / Linux. One speed figure came from a data-center card; the other hasn't got a baseline yet.
↓ Everything in one page · there's a moving diagram
Apps that run local models are a dime a dozen — install, click, chat. But training a model on your own data meant setting up environments, fighting drivers and VRAM. Most people bounced off right there. Unsloth Desktop skips that whole step: free and open source, all three platforms, and the same window runs and trains.
Local model apps only ran models. Install, chat, done. Training one of your own was a separate world.
The same window trains. Drag in a PDF, CSV, or JSON and fine-tune — no code required.
Drop in a PDF, CSV, or JSON, pick a method: LoRA attaches a small patch and leaves the base model alone; or full fine-tuning, or pretraining from scratch. Multi-GPU works; text, image, and audio models all train.
Xiaohu drags in a product manual and picks LoRA: the base model doesn't budge, and the output is a hot-swappable patch, tens of MB.
For video generation, Unsloth's own test gave a figure: with MiniMax-H3, generating a video dropped from over 70 seconds to 13 seconds.
Small local models trip most often on tool calls: malformed parameters, stuck loops, or internal markup leaking into the chat. Unsloth pairs automatic repair-and-retry with an isolated sandbox; touching your files or going online defaults to asking permission first, with four levels of freedom, taking direct aim at Claude Code.
In the FAQ, Unsloth itself says when it's slower: search, code execution, and self-healing all cost time. Turn those off and it matches any other llama.cpp app — and if it's still slow, file an issue.
The "50% better tool-call accuracy" figure comes with no comparison point or methodology. Treat it as a vibe, not a measurement.
Free and open source, currently Beta. All three platforms; GPU and CPU on NVIDIA, Intel, AMD, and Mac all work, though older hardware might not. Already using an agent like Claude Code or Codex? One command swaps the backend to the model on your own machine.
something new?
- ✗ Set up Python
- ✗ Configure GPU drivers
- ✗ Wrestle with VRAM
All three platforms
Add a patch
code?
NVIDIA B200
costs more than a whole PC
wrong format
through
retried once
and it's as fast as any other
but check the fine print on numbers