The Complete LM Studio Bible: The GUI Way to Run Local LLMs (2026)

If Ollama is the command line of local AI, LM Studio is its polished desktop app. It is the tool for people who want to see what they are doing: browse models in a store-like catalog, watch a green badge tell you whether one fits your machine, download it with a click, and start chatting in a window that looks and feels like ChatGPT — except nothing you type ever leaves your computer.

This is the complete guide to LM Studio. We will install it, tour every tab, download your first model the right way, and then go deep: the GPU-offload slider, GGUF versus Apple's MLX format, presets and system prompts, chatting with your own documents, the built-in OpenAI-compatible server, the lms command-line companion, speculative decoding, and how to reach your models from your phone. It is written to be followed by a total beginner and kept as a reference by anyone who already lives in it.

Table of contents

• What LM Studio is (and who it's for)
• Installing LM Studio
• The interface, tab by tab
• Discovering and downloading models
• Your first chat
• The stats bar: tokens, speed and context
• GGUF vs MLX: which to download on a Mac
• The GPU offload slider and memory
• Quantization in LM Studio
• Managing your model library and disk
• Presets, system prompts and sampling
• Prompt engineering that works locally
• Comparing models to find your favourite
• Chatting with your documents (RAG)
• Vision and multimodal models
• The local server: an OpenAI API on your desk
• The lms command-line companion
• Speculative decoding for a free speed boost
• Performance tuning
• Reaching your models from your phone
• What to actually build with LM Studio
• Capstone: a private writing and research desk
• Troubleshooting
• LM Studio vs Ollama vs Jan
• Frequently asked questions

What LM Studio is (and who it's for) {#what-lm-studio-is}

LM Studio is a desktop application for running open-weight language models locally. It bundles the same llama.cpp engine that powers most of the local-AI world (plus Apple's MLX engine on Macs), wraps it in a clean graphical interface, and adds the two things a GUI does best: discovery and feedback. You browse a searchable catalog of thousands of models pulled from Hugging Face, and the app tells you — before you download anything — whether each one will fit comfortably in your memory, run but tightly, or fail to load.

That feedback loop is why LM Studio is the tool we recommend to newcomers. With a raw engine you have to already know that a 32B model needs about 20 GB; LM Studio just shows you a green "Full GPU Offload Possible" badge or a yellow warning. It turns hardware guesswork into a glance.

Who should use it:

• Anyone new to local AI who wants results in five minutes without a terminal.
• People on laptops and Macs — the Apple Silicon experience, with MLX support, is excellent.
• Tinkerers who like to try many models quickly and compare them in a real chat window.
• Developers who want a local OpenAI-compatible API but prefer a GUI to manage which model is loaded.

Who might prefer something else:

• If you love the command line, want to script everything, or are building a headless server, Ollama is leaner and more composable. (You can run both — they read the same GGUF files.)
• If you want a multi-user, self-hosted ChatGPT for a household or team, pair either runner with Open WebUI.

For a direct three-way comparison, see Ollama vs LM Studio vs Jan and our review Open WebUI vs LM Studio vs Jan. LM Studio is free for personal use, and it added a free-for-work tier for commercial use — always check the current terms on their site if you are deploying at a company.

A word on why this matters. The reason to run models locally in LM Studio is not just cost — it is control. When you type into ChatGPT or any cloud assistant, your words travel to someone else's servers, where they may be logged, retained, or used to train future models. For a casual question that is fine; for a client contract, a patient note, unreleased code, or a private journal, it is not. With LM Studio, the model runs on your silicon and your text never touches a network. That is the same argument the site makes in why local LLMs are cheaper and more secure and why regulated industries are moving to on-premise AI. LM Studio just makes that control click-easy.

Installing LM Studio {#installing}

LM Studio ships as a normal desktop installer for all three platforms. Download it from lmstudio.ai.

• Windows: run the installer. Requires a 64-bit machine; a GPU with recent drivers is recommended but not required. AVX2 CPU support is needed (virtually all CPUs since ~2015 have it).
• macOS: requires Apple Silicon (M1 or newer). Drag the app to Applications. This is where LM Studio shines, thanks to unified memory and MLX.
• Linux: ships as an AppImage. Make it executable and run it. NVIDIA and AMD GPUs are supported.

On first launch the app detects your hardware — GPU model, VRAM, system RAM — and uses that throughout to tell you what fits. If you want to sanity-check those numbers against a full model catalog before you even open the app, run our Hardware Analyzer; it reads the same specs and recommends models by expected speed.

What hardware do you actually need?

LM Studio scales from a modest laptop to a serious workstation. Roughly:

• 8 GB RAM, no GPU / weak GPU: you can run 1B–4B models on CPU. Usable for chat and light writing; not fast. See Do you need an expensive PC?.
• 8 GB VRAM (e.g. RTX 4060, RTX 3060 Ti): comfortable with 7–8B models like qwen3:8b — the sweet spot for most laptops. Browse budget GPUs under $500.
• 12 GB VRAM (RTX 3060 12GB, 4070): step up to 14B models with strong reasoning.
• 16 GB VRAM (RTX 4080/5080): 14B comfortably, or a 30B MoE, with room for big context.
• 24–32 GB VRAM (RTX 4090 / RTX 5090): 32B dense models fully on-GPU — near-frontier quality at high speed.
• Apple Silicon 16–128 GB: unified memory lets a Mac punch above a similarly priced PC; a 64 GB Mac runs models a 24 GB PC GPU cannot. See Best Mac for Local LLMs.

The green "fits your machine" badge does this reasoning for you at download time — but knowing the tiers helps you shop. The Best GPU Buyer's Guide and VRAM Requirements Guide go deeper.

The interface, tab by tab {#interface}

LM Studio is organized as a left-hand rail of a few big modes. Learn these four and you know the app.

• Chat — the default view. A model picker sits at the top; a settings panel on the right controls the system prompt, temperature, context length, and GPU offload. Conversations are saved in folders on the left.
• Discover — the model catalog. Search by name (qwen, deepseek, gemma), filter, and see per-model quantization options each tagged with whether it fits your machine.
• My Models — your downloaded library. Delete models to reclaim disk, set per-model defaults, and choose where models are stored.
• Developer / Local Server — turns LM Studio into an API server and shows you exactly what requests come in.

There is also a power-user toggle in settings that reveals advanced options (raw parameters, experimental features). Flip it on once you are comfortable.

Discovering and downloading models {#discovering}

This is LM Studio's superpower. Open Discover and search for a model family. For each result you will see a list of quantizations — the same Q4_K_M, Q5_K_M, Q8_0 options explained in the quantization section below — and next to each, a compatibility indicator based on your detected hardware:

• Green — "Full GPU offload possible": the whole model fits in VRAM. Pick this. It will be fast.
• Yellow — "Partial GPU offload": it will load but spill some layers to system RAM, so it will run slower. Fine for occasional use; not ideal for daily driving.
• Red / "Likely too large": it will not fit well. Choose a smaller size or a lower quant.

The practical workflow: search the family you want, then pick the largest model that still shows green at Q4_K_M. That gives you the smartest model that stays fully on your GPU. If you are unsure which family to pick in the first place, the Model Library tags every model by strength and the Choosing the Right LLM guide walks through the decision. You can also confirm a specific model with the VRAM Calculator or a quick Can I Run It? check.

LM Studio also has a "Staff Picks" / curated area highlighting well-behaved, popular models — a safe place for beginners to start. And because the catalog is backed by Hugging Face, brand-new models appear within hours of release.

Your first chat {#first-chat}

Once a model finishes downloading:

1. Go to the Chat tab. 2. Click the model selector at the top and load your model. You will see a memory readout as it loads onto the GPU. 3. Type a message and press Enter. The reply streams back token by token.

At the top you can see live stats — tokens per second, time to first token, and how much context you have used. (If those numbers are new to you, the Ollama guide's tokens-and-speed section explains them; the same physics applies here.)

A few first-chat tips:

• Eject a model (unload it) from the top bar when you are done to free memory, or before loading a different one.
• Use the right-hand system prompt box to set the model's persona and rules — the single biggest lever on output quality. See System Prompts & Personas 101.
• Start a new chat for a new topic; a long history eats context and slows things down.

The stats bar: tokens, speed and context {#stats-bar}

LM Studio shows a small readout above or beside each response with real numbers. Learning to read them turns "it feels slow" into a precise diagnosis.

• Tokens/second (tok/s) — how fast the answer streams out. Tokens are chunks of text, roughly ¾ of a word each. Below ~5 tok/s feels like waiting; 7–10 is comfortably readable; 15–30 feels snappy; above 30 arrives faster than you can read. Decode speed is governed mostly by your GPU's memory bandwidth, which is why an RTX 5090 is dramatically faster than an older card and why the benchmarks page predicts speed from bandwidth.
• Time to first token (TTFT) — the pause before the answer starts. It grows with how much you gave the model to read, so a long prompt or a big attached document lengthens it.
• Context used — how much of the model's memory (its context window) your conversation is consuming. When you approach the limit, the model starts "forgetting" the oldest messages. Start a fresh chat, or raise the context length if you have VRAM.

If your tok/s is far below what the benchmarks predict for your GPU, the usual culprit is a spill — part of the model is on the CPU because GPU Offload is too low or the model is too big. The GPU offload section is the fix. The same token-and-speed physics is explained in more depth in the Complete Ollama Bible and Context Windows Explained.

GGUF vs MLX: which to download on a Mac {#gguf-vs-mlx}

On Windows and Linux you will always use GGUF — the universal quantized format. On a Mac, LM Studio offers a second option: MLX, Apple's own machine-learning format, optimized for the Metal GPU and unified memory in M-series chips.

The rule: on a Mac, prefer the MLX build when one exists — it is usually a bit faster and uses memory a touch more efficiently. If a model only has a GGUF build, that works fine too. On any PC, GGUF is your only choice and it is a good one. LM Studio labels each download clearly, so you never have to guess. For Mac buying advice tuned to local AI, see Best Mac for Local LLMs.

The GPU offload slider and memory {#gpu-offload}

This is the one LM Studio control worth truly understanding. When you load a model, LM Studio splits it into layers and lets you choose how many to place on the GPU versus the CPU (system RAM), via a slider labeled GPU Offload.

Most of the time you should leave GPU Offload at maximum. LM Studio auto-detects a sensible value, but if you have VRAM to spare, push it to the top. The moment layers spill to CPU, decode speed collapses — the PCIe bus between GPU and system RAM is roughly ten times slower than VRAM itself. If a model will not fully fit even at max offload, the right answer is almost always to drop to a smaller model or a lower quant rather than run half of it on the CPU. This is the same lesson as the VRAM requirements guide: fit first, then optimize.

The right-hand panel also exposes context length. A bigger context uses more VRAM, so on a full GPU, cranking context can itself trigger a spill. Balance the two.

Quantization in LM Studio {#quantization}

Quantization is the compression that lets big models fit on small hardware, and LM Studio surfaces it directly in the download list. Every model offers several quant levels; here is how to choose.

The short version, identical to every other runner: download Q4_K_M unless you have a specific reason. Step up to Q5/Q6 if the green badge says a higher quant still fits; step down to Q3 only to squeeze a larger, smarter model onto a tight card. LM Studio's compatibility badges make this almost foolproof — you can see which quants stay green. For the underlying theory, read Quantization Explained and the deep dive LLM Quantization Explained.

Managing your model library and disk {#library}

Models are big, and a curious tinkerer accumulates them fast — it is easy to have 150 GB of models before you notice. The My Models tab is your control center.

• See sizes and reclaim space. Every model shows its on-disk size. Delete ones you no longer use; there is no penalty for re-downloading later.
• Move the models folder. By default LM Studio stores models on your system drive. If that fills up, point the models directory at a larger or external drive in settings — the standard fix for "my C: drive is full." Keep models on a fast SSD if you can; loading a 20 GB model off a slow spinning disk is painfully slow.
• Per-model defaults. You can pin a default context length, GPU offload, and system prompt to each model, so it always loads the way you like.
• Know what "loaded" means. Downloading a model puts it on disk; loading it puts it into memory (VRAM). Only a loaded model uses VRAM. Eject models you are not using to free memory for the one you are.

A healthy habit: keep two or three daily-driver models (a small fast one, a mid reasoning one, and maybe a coder or vision model) and delete the experiments. The Model Library is always there when you want to try something new, and the VRAM Calculator tells you what a candidate will cost in memory before you commit the download.

Presets, system prompts and sampling {#presets}

The right-hand settings panel in Chat is where you shape a model's behavior, and LM Studio lets you save those settings as presets you can reload instantly.

The controls that matter:

• System prompt — the model's standing instructions. "You are a concise technical writer. Answer in Markdown. Never apologize." A good system prompt changes a model more than switching models does. See System Prompts & Personas 101.
• Temperature — randomness. Low (0.1–0.3) for code and facts; medium (0.7) for chat; high (1.0+) for creative writing.
• Top-P / Top-K — how many candidate tokens the model considers; the defaults are fine for almost everyone.
• Context length — how much the model remembers; bigger uses more VRAM.
• Repeat penalty — nudge up to ~1.2 if the model loops.

Save a preset per use case — "Coder" (low temp, coding system prompt), "Brainstorm" (high temp), "Extractor" (low temp, JSON-only system prompt) — and switch with one click. This is LM Studio's equivalent of Ollama's Modelfiles, minus the file editing.

Prompt engineering that works locally {#prompting}

Open models are capable, but they are less forgiving of vague prompts than a giant cloud model. A little technique goes a long way, and it costs nothing to apply in LM Studio.

• Lead with the system prompt. Define the role, the format, and the rules once, up top. "You are a careful legal analyst. Answer in Markdown with a short summary then bullet points. If unsure, say so." This shapes every reply.
• Be specific about the output. "Give me 5 subject lines, each under 8 words, no emojis" beats "write some subject lines." Local models follow explicit constraints well.
• Show, don't just tell. One or two examples of the input→output you want (few-shot prompting) dramatically improves consistency, especially for extraction and formatting tasks.
• Match temperature to the task. Facts and code: 0.1–0.3. Everyday chat: ~0.7. Fiction and brainstorming: 1.0+. This single dial fixes most "too random" or "too boring" complaints.
• For reasoning, let it think. With models like DeepSeek R1 or Qwen in thinking mode, ask it to "reason step by step" and give it room; the visible chain-of-thought is where the accuracy comes from.
• Keep chats focused. Long, meandering conversations fill the context and confuse the model. Start a new chat per task.

These habits transfer to every runner and every model. The deeper playbook is in System Prompts & Personas 101, and for machine-readable output specifically, Reliable JSON & Structured Output.

Comparing models to find your favourite {#comparing}

Part of the fun — and the point — of a GUI is trying models against each other. A simple, rigorous way to do it in LM Studio: keep a short test set of prompts that represent your real work (a tricky coding question, a summarization task, a reasoning puzzle, a creative brief). Run each candidate model through the same set, at the same temperature, and judge the answers.

You will quickly learn things the benchmarks cannot tell you: which model matches your writing voice, which one is fast enough to feel good on your hardware, which one refuses too much or too little. Watch the tok/s on each — a slightly weaker model that runs at 40 tok/s often beats a slightly stronger one at 6 tok/s for daily use. For head-to-head data on capabilities, the Compare tool puts two models' benchmark scores side by side, and Who is winning the local LLM race in 2026 gives the current lay of the land.

Chatting with your documents (RAG) {#rag}

LM Studio can answer questions about your own files. Attach a PDF, text file, or document to a chat and the app retrieves the relevant passages and feeds them to the model — a built-in, no-code Retrieval-Augmented Generation pipeline.

How to use it well:

• Attach the document using the paperclip/attach control in the chat box.
• For a short document that fits in the context window, LM Studio can load the whole thing. For a long one, it chunks and retrieves the most relevant parts.
• Ask specific questions ("What is the termination clause in section 7?") rather than vague ones; retrieval works best with a clear target.
• Use a low temperature and a system prompt that says "answer only from the provided document" to keep it honest.

This makes LM Studio genuinely useful for privacy-safe document analysis — contracts, research papers, medical notes — since the file never leaves your disk. For a heavier, scalable pipeline over hundreds of documents, graduate to a dedicated setup as in the Complete Local RAG Pipeline.

Vision and multimodal models {#vision}

LM Studio supports vision models — download a multimodal model (Gemma, Qwen VL, or another vision build) and you can attach an image to your message and ask about it: describe a photo, read text from a screenshot (OCR), interpret a chart, or extract fields from a scanned invoice. The Discover tab labels vision-capable models, and attaching an image works just like attaching a document. See Multimodal LLMs (Vision + Text) for which models see best and how to prompt them.

The local server: an OpenAI API on your desk {#server}

Here is where LM Studio stops being just a chat app. The Developer / Local Server tab turns it into an OpenAI-compatible API server on http://localhost:1234. Flip it on, and any app or script written for the OpenAI API works against your local model by changing one line: the base URL.

Start the server, load a model, and call it:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")

resp = client.chat.completions.create(
    model="local-model",   # LM Studio uses whatever is loaded
    messages=[{"role": "user", "content": "Explain RAG in two sentences."}],
)
print(resp.choices[0].message.content)

The Developer tab even shows ready-made snippets (curl, Python, Node) you can copy, and streams a live log of every request — which makes debugging an integration far easier than with a headless server. This is the fastest way to stand up a personal or team local API server, and it plugs straight into coding assistants like Continue and Aider (point them at :1234). Because it exposes an /v1/embeddings endpoint too, you can build local RAG apps against it.

> Security: like all local servers, the API is unauthenticated by default and bound to localhost. Only expose it to your network deliberately, and never straight to the public internet — put it behind a VPN or Tailscale, as covered in the home-server guide.

Tool use, MCP and structured output

The server does more than plain chat. Recent LM Studio versions expose the pieces you need to build real applications, not just conversations:

• Structured output. You can pass a JSON schema and constrain the model to return valid JSON that matches it — the reliable way to extract data for spreadsheets, databases, or downstream code. Far more dependable than asking the model nicely and hoping. The request format is the same one described in Reliable JSON & Structured Output.
• Tool / function calling. Models that support it can be given a list of "tools" (functions) and will ask to call them — the foundation of agents that look things up, do math, or hit an API. This is how a local model graduates from chatbot to autonomous agent.
• MCP (Model Context Protocol). LM Studio can act as an MCP host, letting compatible models connect to external tools and data sources through a standard protocol — a fast-moving area worth watching if you build agentic systems.

Because all of this rides on the OpenAI-compatible endpoint, code you write against LM Studio's server also runs against a cloud API later, or against Ollama, with only a URL change. You are never locked in.

The lms command-line companion {#lms-cli}

LM Studio ships a small CLI called lms for people who want to automate the GUI app — load and unload models, start the server, and manage things from scripts or on a headless machine.

lms server start          # start the local API server
lms ls                    # list downloaded models
lms load qwen3-8b         # load a model into memory
lms unload --all          # free memory
lms status                # what's loaded and served

This bridges LM Studio's friendly download experience with server-style automation, and it enables headless mode — run LM Studio's engine on a home server without keeping the window open. If your goal is a fully scripted, terminal-first workflow, though, Ollama is purpose-built for that and may be the better fit.

Speculative decoding for a free speed boost {#speculative}

LM Studio supports speculative decoding, a clever trick that can make a large model generate noticeably faster with no loss in quality. You pair your main model with a much smaller, faster draft model from the same family.

In LM Studio you enable this in a model's load settings by selecting a compatible draft model. It works best when the draft and main models share a tokenizer (same family, different sizes — e.g. a 1B draft for a 32B main). The catch: the draft model uses some extra memory, so it helps most when you have VRAM to spare. On a big card like the RTX 5090 it is close to a free win.

Performance tuning {#performance}

Beyond keeping GPU Offload maxed, a few levers help:

• Flash attention — enable it in model load settings; it speeds up attention and reduces context memory on modern GPUs.
• KV-cache quantization — store the context cache at lower precision to fit longer contexts or bigger models; near-lossless at Q8.
• Right-size the context — do not load a 128K context if your chats are short; that memory is better spent on the model.
• Close VRAM hogs — games, browsers with many tabs, and video editors all compete for VRAM. Check your usage before loading.
• Pick MLX on Macs — as covered above, it is typically faster than GGUF on Apple Silicon.

A quick way to confirm everything is working: watch your GPU while a model generates. On Windows, Task Manager's Performance tab shows GPU memory and utilization; on Linux, run nvidia-smi -l 1 in a terminal; on a Mac, Activity Monitor's GPU history or asitop. You want to see VRAM filled to roughly the model's size and the GPU busy during generation. If VRAM is barely used and the CPU is pegged instead, the model is running on the CPU — raise GPU Offload or pick a model that fits.

If you are still bottlenecked, the honest fix is hardware: the benchmarks page shows how much faster each GPU decodes, and the Best GPU Buyer's Guide helps you choose your next upgrade.

Reaching your models from your phone {#phone}

You do not have to sit at the machine running LM Studio. Because it exposes a network server, you can reach your models from a laptop, tablet, or phone on the same network — or securely from anywhere via a VPN. LM Studio's own LM Link feature is built exactly for this: pair a phone with your desktop and chat with your local models on the go. We wrote a dedicated walkthrough — LM Studio on Your Phone (LM Link) — and a companion article, Run models from your phone with LM Link. For a general approach that works with any runner, see Run a Local LLM on Your Phone.

What to actually build with LM Studio {#use-cases}

Once the mechanics click, the question becomes "what do I do with this?" LM Studio suits a surprising range of real work, all of it private and offline:

• A private writing assistant — drafting, editing, rewriting, and tone changes on documents you would never paste into a cloud tool. See Local LLM for Email & Writing.
• A study and learning partner — explain concepts, quiz yourself, summarize textbooks. Using LLMs for Learning has a workflow.
• A coding helper — via the server + Continue/Aider, with your source never leaving the machine (Local Coding Assistant Setup).
• A document analyst — drop in contracts, papers, or reports and ask questions using the built-in RAG, safely (privacy-safe document analysis).
• A data extractor — turn messy text into clean JSON through the API for spreadsheets and pipelines.
• A brainstorming and ideation desk — high-temperature chat for names, outlines, and first drafts.
• An image reader — with a vision model, parse receipts, screenshots, and diagrams offline.

The through-line is privacy plus zero marginal cost: once the hardware is paid for, every query is free and confidential. That is exactly the value laid out in local LLM use cases for 2026 and why companies choose local AI.

Capstone: a private writing and research desk {#capstone}

Let us assemble a genuinely useful setup that shows off what LM Studio does best.

1. Download two models. In Discover, grab a strong general model at the largest green quant (say qwen3:14b on a 12–16 GB card) and a small fast model (qwen3:8b or a 4B) for quick tasks. On a Mac, prefer the MLX builds. 2. Build three presets. In Chat, create and save:

• Editor — system prompt: "You are a sharp copy editor. Improve clarity and flow, keep my voice, and explain each change in one line." Temperature 0.4.
• Researcher — system prompt: "Answer only from the attached document. Quote the passage, then explain. If it's not there, say so." Temperature 0.2.
• Brainstorm — system prompt: "You are a wildly creative partner. Give 10 varied ideas." Temperature 1.1.

3. Work with your documents. Switch to the Researcher preset, attach a PDF, and interrogate it — the file stays on your disk. Switch to Editor and paste a draft to polish it. 4. Wire it into your other tools. Start the local server, point your VS Code coding assistant and any OpenAI-based scripts at http://localhost:1234/v1, and now the same models power your editor, your terminal, and your automations — all local.

That is a private writing, research, and coding desk built entirely from a free app and free models, with nothing leaving your computer. Swap in DeepSeek R1 when you need heavier reasoning, or add Open WebUI on top for a polished multi-user front end and stronger document handling.

Troubleshooting {#troubleshooting}

LM Studio vs Ollama vs Jan {#comparison}

The three most popular desktop runners, and where each fits.

The honest recommendation: most people should start with LM Studio for its friendliness, and reach for Ollama when they want to script or serve. They coexist happily — LM Studio for exploring, Ollama for automating — and both read the same GGUF files, so a model you downloaded in one can be used by the other.

Frequently asked questions {#faq}

Is LM Studio free?

Yes for personal use, and it added a free tier for commercial/work use — check the current terms on their site before deploying at a company. The models themselves are free open weights. Compared to a cloud API subscription, your only ongoing cost is electricity; the Cost Calculator shows the difference, and why local is cheaper and more secure makes the case.

Does LM Studio send my data anywhere?

No. Chats and documents are processed entirely on your machine. The only network traffic is downloading models (and optional telemetry you can disable). This is what makes it safe for confidential document analysis.

Can LM Studio and Ollama share models?

They both use GGUF, so the weights are compatible, but they store models in different folders and manage them separately. In practice most people just download in each app as needed; disk is the only cost of keeping both.

Do I need a GPU?

No, but it helps a lot. LM Studio runs on CPU for small models; a GPU (or Apple Silicon) is what makes larger models fast. Check your machine with the Hardware Analyzer, and if you are shopping, see Do you need an expensive PC for local AI?.

What's the difference between GGUF and MLX again?

GGUF runs everywhere via llama.cpp; MLX is Apple-Silicon-only and usually faster on Macs. On a Mac, prefer MLX when a build exists; otherwise use GGUF. On PC, always GGUF.

Can I use LM Studio as a coding assistant?

Yes — start the server, then point Continue (VS Code) or Aider at http://localhost:1234/v1. Use a code-tuned model like qwen3-coder. See Local Coding Assistant Setup.

Which model should I download first?

For most machines, Qwen 3 at the largest size that shows green — qwen3:8b on 8 GB, qwen3:14b on 12 GB, qwen3:32b on 24 GB. For reasoning, DeepSeek R1; for multimodal, Gemma. See the Complete Qwen Guide and Complete DeepSeek Guide.

How do I update a model?

Re-download the newer build from the Discover tab. Update LM Studio itself via its built-in updater or by reinstalling.

Can I run LM Studio without an internet connection?

Yes, once your models are downloaded. Inference is fully offline; you only need a connection to browse and download new models. Pre-download everything and LM Studio works on a plane or in an air-gapped environment — see running LLMs offline.

Why is my model slower than the benchmarks say it should be?

Almost always a spill: part of the model is running on the CPU. Check the stats bar, raise GPU Offload, and if it still will not fit, drop to a smaller model or lower quant. A close second is a huge context length eating VRAM that the weights need.

Can LM Studio download models straight from Hugging Face?

Yes — the Discover catalog is backed by Hugging Face, and you can search by repository name to find community quantizations, including brand-new models within hours of release.

Is there a limit on model size?

Only your hardware. LM Studio will happily list 70B and larger models; whether they load depends on your VRAM plus RAM. The fit badge tells you, and the VRAM Calculator confirms the number before you download.

Does LM Studio support embeddings for building search or RAG?

Yes — the server exposes an /v1/embeddings endpoint, and you can load a dedicated embedding model for it. That is the backbone of any custom RAG pipeline you build on top.

Where to go next

You can now install LM Studio, read the fit badges, pick the right format and quant, shape behavior with presets, chat with your documents, and serve an OpenAI-compatible API to the rest of your tools. From here:

• Add a team-friendly UI: the Complete Open WebUI Guide for a multi-user, self-hosted ChatGPT.
• Go terminal-first: the Complete Ollama Bible for scripting and servers.
• Choose your model: the Complete Qwen Guide and Complete DeepSeek Guide.
• Choose your hardware: the Complete RTX 5090 Guide and Best GPU Buyer's Guide.

LM Studio gets you from zero to a private, capable AI faster than anything else. Everything after that is refinement.

---

Check which models your machine can run → Hardware Analyzer Browse every open model, always current → Model Library Compare local running costs to cloud APIs → Cost Calculator