TL;DR: Cline Desktop v0.0.49 (October 26, 2026) turns the standalone Apache 2.0 agent app into the easiest way to run a local coding model: a new Local Models page installs Ollama or LM Studio for you, checks your hardware, and recommends one of 7 curated models with honest fit labels. The catch: GPU detection only works on Apple Silicon and NVIDIA — AMD and Strix Halo machines get mislabeled. It costs $0; the hardware to run its best model costs about $1,500.

	Cline Desktop (v0.0.49)	Cline VS Code extension (v4.1.26)	Claude Code
Best for	Parallel sessions, schedules, managed local models	Inline coding inside your editor	Terminal-native agentic work on frontier models
Price	$0 app; free rotating models, ClinePass $9.99/mo, BYOK, or local	$0 extension; same model options	Included in Claude Pro $20/mo and up
The catch	macOS GA, Windows beta, Linux builds unannounced; AMD GPUs undetected	No session scheduling, one task at a time per window	No local-model story; cloud inference only

Honest take: If you want a local open-weight model doing real agentic coding with the least setup pain in 2026, Cline Desktop is now the tool I’d point you at — ahead of hand-rolling Ollama configs. Keep the VS Code extension for inline work; add Desktop for schedules and local models. If you have no GPU and no Apple Silicon, skip local entirely and put $9.99/mo into ClinePass instead.

---

What is Cline Desktop, and what changed in v0.0.49?

Cline Desktop is a standalone agent workspace — a Tauri app with a bundled Cline CLI runtime, so it needs no Node install and no VS Code. Cline (the company behind the Apache 2.0 extension we reviewed in our Cline review) launched it in mid-September 2026 with a pitch that is unusual in this market: “an open-source app for open-weight models.” It runs multiple agent sessions in parallel, schedules recurring tasks, and imports conversations from Claude Code and Codex so you can continue them on a cheaper model.

The v0.0.49 release on October 26, 2026 is the biggest update since launch — the version number has climbed from 0.0.27 at launch to 0.0.49 in about six weeks, with three releases in the last ten days alone, which tells you how fast this thing is moving. The headline additions, from the official release notes:

New in v0.0.49	Why it matters
Local Models settings page	Installs/starts Ollama or LM Studio, recommends models for your hardware, downloads and loads them
Changes pane + project files panel	Per-file diffs per turn, file tree with git status — review agent work without an IDE
Integrated terminal (Ctrl+`)	Run commands beside the session
Attach to running tasks	Opening a task already running in another Cline app attaches instead of duplicating
Model catalog refresh	Adds Liquid Inference and Munito AI providers; ClinePass default is now Kimi K3.1 Pro

The rest of this review focuses on the Local Models page, because it addresses the single biggest friction point we’ve documented across dozens of local-setup guides on this site: wiring a runtime, a model, and an agent together without errors like the Ollama tool-use loop or out-of-memory crashes.

What does the new Local Models page actually do?

It removes every manual step between “fresh machine” and “local model answering in the chat.” From Settings → Provider → Local, Cline Desktop:

• Detects whether Ollama or LM Studio is installed and running, and installs or starts the one you pick (Ollama at localhost:11434, LM Studio at localhost:1234 — both Base URLs stay editable for remote servers)
• Reads your CPU, RAM, and GPU, and states how large a model can run fully on the GPU
• Shows 7 recommended models, each labeled Runs well on this machine, Will run slowly, or Too large
• Downloads the model (resumable progress, disk-space check), loads it into memory, sets the matching provider and a recommended context window, and switches your chat to it
• Shows a live memory chip under the composer — how much RAM the model is using, with one-click load/unload

Two details stand out against doing this by hand. First, loading ahead of time: Cline pre-loads the model so your first message doesn’t stall for a minute while 18 GB streams into memory. Second, the model details view exposes what Ollama is actually doing — quantization, context window requested, keep-alive, sampling settings — which is exactly the information you need when a local agent misbehaves and which usually requires ollama show spelunking.

LM Studio gets equal treatment, including a service-only install command if you don’t want the LM Studio GUI, and MLX model support on Apple Silicon — the reason we’ve recommended LM Studio over Ollama for Mac users since our Cline + LM Studio guide.

Which models does Cline Desktop recommend, and what hardware do they need?

The catalog is 7 models, hardcoded in the app’s source with exact memory budgets (we verified these against webview/lib/local-models.ts at the v0.0.49 tag). Download size, memory needed, and context window come straight from that file:

Model	Download	Memory needed	Context	Cline’s one-line pitch
Qwen3.8 27B	18 GB	~23 GB	64K	Strongest all-round local model for agentic coding
Laguna XS 2.1	20 GB	~24 GB	64K	Poolside MoE, 3B active params, fast
Qwen3.6 35B A3B	24 GB	~26 GB	64K	Speed over depth
Devstral Small 2	15 GB	~21 GB	32K	Codebase exploration, multi-file edits
gpt-oss 20B	14 GB	~16 GB	64K	Best fit for 16–24 GB machines
Qwen3-Coder-Next	52 GB	~56 GB	64K	80B MoE, needs 64 GB+ machines
Qwen3 8B	5.2 GB	~10 GB	32K	8–16 GB machines, simple edits only

That list matches what our own testing has converged on all year — Qwen3.8 27B has been this site’s default 24 GB-class recommendation since August — so the curation is credible, not filler.

The fit logic is worth knowing because it decides what you’re told to buy. From the v0.0.49 source:

// apps/examples/desktop-app/webview/lib/local-models.ts (v0.0.49)
if (hardware.unifiedMemory) {
    // macOS lets the GPU use roughly three quarters of unified memory.
    return { gpuGb: hardware.totalMemoryGb * 0.75,
             totalGb: hardware.totalMemoryGb * 0.85 };
}
const gpuGb = hardware.gpus.reduce((sum, gpu) => sum + gpu.memoryGb, 0);
return { gpuGb, totalGb: gpuGb + hardware.totalMemoryGb * 0.7 };

A model whose memory need fits in gpuGb is “Runs well”; one that only fits in the combined budget is “Will run slowly” (CPU spill); anything else is “Too large.” If nothing runs well, the badge falls back to the fastest mixture-of-experts model that fits at all — a sensible choice, since MoE models hold up far better on CPU.

What does the hardware actually cost in late 2026?

Memory prices roughly quadrupled since 2025 and GPU street prices sit far above MSRP, so here is the honest mapping from Cline’s fit labels to money. Prices below are US street prices we verified between September and October 2026, not launch MSRPs:

• ~23–26 GB models (Qwen3.8 27B, Laguna XS 2.1, Qwen3.6 35B A3B): a 24 GB card. A used RTX 3090 runs $1,456–$1,558 as of October 20, 2026 — up roughly $400 since March. On Macs, 0.75 × unified memory means a 32 GB Apple Silicon machine clears the 24 GB GPU budget.
• ~16 GB model (gpt-oss 20B): a 16 GB card, and note 16 GB is exactly the budget — nothing to spare for other GPU apps. An RTX 4060 Ti 16GB is $450–$853; the faster RTX 5060 Ti 16GB is $679–$805 (MSRP $429 — nobody pays that; see our 5060 Ti local coding benchmark).
• ~10 GB model (Qwen3 8B): a used RTX 3060 12GB at $260–$296. Cline’s own description is blunt that this tier “struggles with larger multi-step tasks” — treat it as autocomplete-and-small-edits, not an agent.
• ~56 GB model (Qwen3-Coder-Next): 96 GB+ unified memory on a Mac (0.75 × 96 = 72 GB budget), or a 64 GB+ machine running it in slow mode. No consumer NVIDIA card fits it.

What to actually buy

Prices as of October 2026, all taken from the mapping above:

Your situation	The move	Price	Where
You want Cline’s top pick (Qwen3.8 27B) on a PC	Used RTX 3090 24GB	~$1,456–$1,558	Check price
New card, 16 GB tier for gpt-oss 20B	RTX 5060 Ti 16GB	~$679–$805	Check price
Testing whether local agentic coding fits your workflow before buying	Rented RTX 3090, from ~$0.07/hr	pay per hour	Vast.ai
No GPU budget at all	ClinePass subscription	$9.99/mo	cline.bot

Renting first is underrated: a week of evenings on a rented 3090 costs a few dollars and tells you whether a 27B-class local model is good enough for your codebase before you spend $1,500. For the full GPU decision tree, our sister site’s GPU buying guide for local AI goes deeper than this article can.

Where the Local Models page breaks

AMD and Intel GPUs don’t exist as far as Cline is concerned. The hardware detection in v0.0.49 queries nvidia-smi and treats macOS-on-Apple-Silicon as unified memory; everything else reports zero GPUs (unifiedMemory = platform === "darwin" && arch === "arm64", GPUs via detectNvidiaGpus() — that’s the whole detection surface in the source). Own an RX 7900 XTX with 24 GB of VRAM ($900–$1,358 street)? Cline labels every model “Will run slowly” or worse, because it computes your GPU budget as 0 GB and falls back to 0.7 × system RAM. Same for Strix Halo mini-PCs like the GMKtec EVO-X2, whose whole point is a big unified pool for models. The docs admit the labels “may be more cautious than necessary” and you can still download and run any model — but the recommendation engine, the feature this page is built around, is effectively NVIDIA-and-Apple-only today.

LM Studio quietly ignores Cline’s context window when it auto-loads. If LM Studio loads a model on its own (because you messaged a model that wasn’t loaded), it uses the context length configured in LM Studio — not the 64K Cline recommends — and unloads after an hour. The fix is in the docs: always load via Cline’s Load or Use with Cline buttons. This is exactly the silent-truncation failure mode we keep seeing in Ollama context-length bug reports, now with a one-click fix.

The Linux story is ahead of the documentation. The download page and docs say “macOS or Windows (beta).” The v0.0.49 release page on GitHub ships signed Linux packages anyway — .deb for amd64/arm64 and .rpm for x86_64/aarch64, 182 MB each (no AppImage). The release notes even fix a Linux-specific behavior: on desktops without a system tray, like stock GNOME, closing the window now quits the app. We’d call Linux support real but pre-announcement; expect rough edges like that tray quirk.

What else does Desktop add over the VS Code extension?

Three things you can’t get in the extension, all of which compound with local models:

Parallel sessions. Each session keeps its own context and workspace, so a coding agent and a research agent don’t trample each other. The extension gives you one task per window.

Schedules. One-time or recurring agent runs — name, frequency, prompt, provider, model, workspace, optional system prompt and timeout. You can also just describe the automation in chat (“review new issues daily and summarize what needs my attention”) and Cline creates the schedule. Paired with a local model, this is recurring automation with zero marginal cost: a nightly repo check on Qwen3.8 27B consumes electricity, not API credits. Failed runs show the full error as of v0.0.49 — an early-days rough edge that got fixed.

Imports from Claude Code and Codex. Start a debugging session in Claude Code on Fable 5, import the conversation, and continue on a free or local model once the hard reasoning is done. That workflow is the strongest practical argument for the two-tool stack we analyzed this month: frontier model for the hard 20%, open-weight model for the cheap 80%.

Session work syncs with the same Cline account as the extension and CLI, and v0.0.49’s attach-to-running-task change means opening the same task in two Cline apps no longer forks it.

What does it cost to run?

The app is $0 and Apache 2.0 (the desktop app’s source lives in the main cline/cline repo). Inference is where money happens, and there are four paths:

1. Free rotating models — no card required, quota-limited, and the docs state plainly that free-model usage “may be used to help improve model performance.” Don’t send proprietary code through the free tier; that caveat is why our privacy-first Cline setup exists.
2. ClinePass, $9.99/mo — 2–5x the usage of standard API rates on 12 curated open models (GLM-5.3, Kimi K3, DeepSeek V4 Pro and V4.1 Flash, Qwen3.8 Max, MiniMax M3, and others; the default is Kimi K3.1 Pro as of v0.0.49). This is the best dollar-for-dollar deal in the app if your machine can’t run local models.
3. BYOK — your own Anthropic/OpenAI/Gemini/OpenRouter keys, same as the extension.
4. Local — $0 per token after the hardware. Break-even against ClinePass: a $1,500 used 3090 costs the same as 12.5 years of ClinePass, so buy the GPU for privacy, latency, and offline use — not to save money. A $280 used 3060 running Qwen3 8B never pays for itself in capability; put the money toward ClinePass unless on-device is a hard requirement. (For how much system RAM you need alongside the GPU, see our RAM-for-local-inference guide — RAM prices make this a real line item now.)

Verdict: who should install Cline Desktop today?

Switch to (or add) Desktop if you’re on macOS or Windows with an NVIDIA GPU or Apple Silicon, you want local open-weight models with managed setup, or you want scheduled agent runs. It’s the best local-model onboarding of any coding agent we’ve tested this year — ahead of raw Ollama configs, ahead of Kilo Code’s local setup, and far ahead of Cursor, where pointing BYOK at a local endpoint works but nothing manages the models for you.

Stay on the VS Code extension if your work is inline editing in an IDE all day. Desktop doesn’t replace the editor; the Changes pane and file viewer are read-only review surfaces, not an editing environment.

Skip it for now if you’re on an AMD GPU or Strix Halo machine and wanted the Local Models page specifically — the recommendation engine can’t see your hardware yet. Run llama-server directly and point Cline’s BYOK Ollama/OpenAI-compatible provider at it instead.

The pace matters too: a release cadence of multiple desktop builds per week, each with substantive features, from the team behind the most-installed open-source coding agent. For the fully-FOSS perspective on how Cline compares to Continue.dev and Aider, aifoss.dev’s three-way comparison covers the licensing and self-hosting angles we skipped here.

FAQ

Is Cline Desktop free? The app itself, yes — Apache 2.0, source in the cline/cline GitHub repo. You pay for inference: free quota models, ClinePass at $9.99/mo, your own API keys, or local hardware.

Does Cline Desktop work on Linux? Unofficially, yes. The docs list macOS (GA) and Windows (beta), but the desktop-v0.0.49 GitHub release ships signed .deb and .rpm packages for x86_64 and ARM64. Expect rough edges; there’s no AppImage.

Which local model should I pick on a 24 GB GPU? Qwen3.8 27B (~23 GB needed, 64K context) — Cline’s “best overall” badge matches our own standing recommendation. If responses feel slow, Laguna XS 2.1 trades some depth for MoE speed at ~24 GB.

Can it use a GPU server elsewhere on my network? Yes. The Local Models page only manages runtimes on the same machine, but you can point the Ollama or LM Studio Base URL in BYOK settings at any host — including a rented Vast.ai box.

Does the Local Models page support llama.cpp, vLLM, or other runtimes? No — Ollama and LM Studio only. Other OpenAI-compatible servers still work through the BYOK provider; you just manage models yourself.

Do scheduled tasks run if the app is closed? Schedules are configured inside the desktop app and run through its local Hub, so the app needs to be running. On stock GNOME Linux (no tray), closing the window quits the app — and with it, your schedules.

Recommended Gear

Hardware linked in this article, all verified at October 2026 street prices:

• Used RTX 3090 24GB — ~$1,456–$1,558; runs Qwen3.8 27B, Laguna XS 2.1, and Qwen3.6 35B A3B fully on GPU
• RTX 5060 Ti 16GB — ~$679–$805; the new-card path to gpt-oss 20B
• RTX 4060 Ti 16GB — $450–$853; same 16 GB tier, slower memory
• Used RTX 3060 12GB — ~$260–$296; Qwen3 8B only, simple edits

Sources

• Cline Desktop v0.0.49 release notes — official GitHub release
• Cline Desktop documentation — official docs
• Local Models in Cline Desktop — official docs
• Local model catalog and hardware-fit logic — cline/cline source, desktop app
• ClinePass pricing and model list — official docs
• Cline Free Models terms — official docs
• Cline Desktop launch coverage — runtimewire

Last updated October 27, 2026. Cline Desktop ships multiple releases per week; features and the model catalog verified against the desktop-v0.0.49 tag, in-repo docs, and release assets on this date. GPU street prices verified September–October 2026; they move fast — check before buying.

Know which coding tool is worth paying for

Hands-on comparisons of AI coding assistants and what each one costs to run — including the local-model path. Sent only when something changes. Unsubscribe anytime.

Email address Subscribe