LM Studio: Install, Run Models, and the Engine Protocol

Updated 31 August 2026. Verified against LM Studio 0.4.23 (released 28 August 2026), the official docs, and the LM Studio changelog.

What is LM Studio, and is it actually free?

LM Studio is a desktop application that discovers, downloads and runs open-source large language models on your own hardware. You will see it written as LM Studio, lmstudio and — from people half-remembering the name — LLM Studio. They all mean this app.

The pitch is simple: no API key, no per-token bill, no data leaving the machine. You install a normal desktop package, search a model by name, click download, and chat with it. Underneath that GUI sits a genuine developer stack — an OpenAI-compatible HTTP server, an Anthropic-compatible /v1/messages endpoint, a scriptable CLI, TypeScript and Python SDKs, and a headless daemon for servers with no display attached.

On price, the answer has two halves, and most write-ups get the second half wrong:

• The app is free. LM Studio's pricing page puts the desktop app, local inference through llama.cpp and MLX, offline voice transcription, and LM Link for up to five devices in the free tier.
• Work use is covered by the standard terms. The terms of use grant a licence to use the software "solely for Your personal and / or internal business purposes". There is no separate commercial licence to buy for using it at your job. What the terms prohibit is reselling it — you may not "sublicense, distribute, sell, use for service bureau use, as an application service provider, or a software-as-a-service, lease, rent, loan, or otherwise transfer the Software". Building LM Studio into a product you sell needs an Enterprise conversation. Running it on your work laptop does not.

Two paid things now sit alongside the free app. There is pay-as-you-go cloud inference — credits for frontier open models with zero data retention by default, priced per million tokens (input pricing currently spans roughly $0.13 to $3.00 depending on model). And there is Bionic, LM Studio's agent for open models, whose "Bionic Pass" pricing is still listed as coming soon. Neither is required to run models locally.

How do you download and install LM Studio?

The installer lives at lmstudio.ai/download, which detects your OS. The current release is 0.4.23. Here is what each platform actually requires, from the official system requirements:

Installing LM Studio with Homebrew

This is a genuinely common question and the answer is yes — there is an official Homebrew cask. On an Apple Silicon Mac:

brew install --cask lm-studio

The cask currently tracks 0.4.23 and is flagged as auto-updating, so Homebrew will not fight the app's built-in updater. Note the cask metadata lists macOS 12+ and arm64, which is looser than LM Studio's own stated floor of macOS 14 — trust the vendor requirement, not the cask, if you are on an older OS.

Installing headless (servers, CI, no GUI)

If the target machine has no display — a Linux GPU box, a cloud instance, a build runner — you do not want the desktop app at all. You want llmster, which the docs describe as "the core of the LM Studio desktop app, packaged to be server-native, without reliance on the GUI":

# macOS / Linux
curl -fsSL https://lmstudio.ai/install.sh | bash

# Windows
irm https://lmstudio.ai/install.ps1 | iex

# then bring the daemon up
lms daemon up
lms server start

This is now the recommended headless path. Running the desktop app in headless mode is documented as a fallback for existing installs, not the default choice.

How do you load your first model in LM Studio?

Hit ⌘ + 2 (macOS) or Ctrl + 2 (Windows/Linux) to jump to the Discover tab. The search box queries Hugging Face directly — search a keyword like "qwen", use user/model form, or paste a full Hugging Face URL.

You will be offered the same model at several quantisation levels: Q3_K_S, Q4_K_M, Q8_0 and so on. Quantisation compresses the weights and trades a little quality for a lot of size. LM Studio's own guidance is blunt and worth following: choose a 4-bit option or higher if your machine can run it. Going below 4-bit to squeeze a bigger model onto the same RAM is usually a bad trade — you get a larger model that reasons worse than the smaller one you could have run properly.

The load settings that actually matter

Three settings account for nearly every "it won't load" or "it's crawling" problem:

• Context length. The default is 8k tokens (set in 0.4.16). Context is expensive — the KV cache grows with it, and a 32k context on a large model can cost more memory than the weights you were worried about. Raise it only when you actually need long documents.
• GPU offload. How much of the model lives on the GPU versus system RAM. In the CLI this is --gpu, taking 0–1, off, or max. Partial offload is the usual cause of mysterious slowness: if even a few layers spill to CPU, throughput collapses.
• Physical batch size. Exposed for llama.cpp engines since 0.4.15. Larger batches speed up prompt processing at the cost of peak memory during ingestion. If a long prompt OOMs but short ones are fine, this is your dial.

From the CLI the same controls are flags on lms load:

lms load qwen3-8b --context-length 8192 --gpu max --identifier work-model
lms load gpt-oss-120b --estimate-only     # check the memory bill before committing
lms load some-model --ttl 1800            # auto-unload after 30 min idle

--estimate-only is the underused one. It reports what a model would need without loading it, which beats discovering the answer through a crashed process.

When a model won't load

In order of likelihood: (1) the quant genuinely does not fit — drop a size or reduce context; (2) your engine is stale, which is now the single most common cause and is covered in the engine protocol section below; (3) the architecture is too new for your engine build — several 2026 features are gated on specific llama.cpp engine versions, for example assistant drafters requiring llama.cpp 2.29.1 or newer; (4) you are on an Intel Mac, where current LM Studio simply does not run.

Which backend should you use — llama.cpp or MLX?

LM Studio runs models through llama.cpp (the GGUF format) on every platform, and additionally through MLX, Apple's native machine-learning framework, on Apple Silicon Macs. Both are bundled; MLX has shipped with the Mac build since 0.3.4.

The honest decision rule on a Mac: try MLX first when an MLX build of your model exists, fall back to GGUF when it does not. MLX talks to Apple's GPU and unified memory through Apple's own framework rather than a portability layer, and it is the path LM Studio documents for Apple Silicon. But the size of the win depends on the model, the quant and the chip, and published third-party numbers vary widely enough that quoting a single percentage would be misleading. Download both formats, watch the tokens-per-second readout in the chat window, and keep whichever wins on your hardware. It takes five minutes and beats any benchmark you read online, including this one.

Everywhere except Apple Silicon the question does not arise: llama.cpp is the engine. For a fuller treatment of Apple's local-inference stack see our Apple Silicon LLMs guide.

What is the LM Studio Engine Protocol?

This is the least-documented part of LM Studio and the part most likely to be silently causing your problems, so it is worth getting right.

The LM Studio Engine Protocol is the interface between the LM Studio app and the inference engines it runs. It was introduced in 0.4.15 (29 May 2026) with a one-line description that tells you the whole motivation: "New architecture to enable us to ship more frequent engine updates."

Before it, engines were effectively welded to the app — a new llama.cpp build meant a new app build. The protocol decouples the two. Engines become independently versioned, independently downloadable artefacts that the app speaks to over a defined boundary. That is why LM Studio release notes now cite engine versions separately from app versions, with things like "requires llama.cpp engine version 2.29.1 or newer".

Its rollout was cautious, which is itself informative:

What this means for you in practice. "Update LM Studio" and "update your engine" are now two different actions, and the second one is the one people forget. If a model refuses to load, or a brand-new architecture is unsupported, or a feature described in the release notes is missing from your UI, your engine build is probably behind your app build. Check and fix it from the GUI under Settings → Runtimes, or from the CLI:

lms runtime ls        # what's installed
lms runtime get       # install a runtime
lms runtime select    # switch the active one
lms runtime update    # bring it current
lms runtime remove

Two clarifications, since the term gets used loosely. The Engine Protocol is internal plumbing — it is not a public specification you can implement to register a third-party engine, and there is no docs page for it beyond the changelog entries. If what you actually want is to substitute a different token source behind LM Studio's interface, the supported route is a generator plugin in the TypeScript SDK: "Generators are replacement for local LLMs. They act like a token source." A generator appears in the model dropdown like any other model and can front a remote endpoint, an OpenAI-compatible API, or another LM Studio instance. And if you were searching for the protocol LM Studio's *server* speaks, that is the OpenAI- and Anthropic-compatible REST API in the next section — a different thing entirely.

How do you run the LM Studio local server and CLI?

This is what turns LM Studio from a chat toy into infrastructure. Toggle "Start server" in the Developer tab, or run lms server start. It binds to http://localhost:1234 and speaks three API dialects:

• OpenAI-compatible — /v1/chat/completions, /v1/completions, /v1/embeddings, /v1/models. Any OpenAI SDK works by changing the base URL.
• Anthropic-compatible — POST /v1/messages, authenticated with an x-api-key header. The Anthropic client libraries work against it directly. Image support landed in both API families in 0.4.22.
• Native REST + SDKs — LM Studio's own API covering stateful chats, streaming, model load/download/list, structured output, embeddings, tool use and MCP, with first-party TypeScript and Python SDKs.

from openai import OpenAI

client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")
resp = client.chat.completions.create(
    model="qwen3-8b",
    messages=[{"role": "user", "content": "Summarise this changelog."}],
)
print(resp.choices[0].message.content)

Because the shapes match, the whole ecosystem points at it unchanged: Continue.dev, Cursor's custom base-URL setting, LangChain, LlamaIndex, Open WebUI, and any internal script already written against OpenAI. Cherry Studio is a good example of a separate desktop client that treats LM Studio purely as a backend.

The lms CLI, in the commands you will actually use

# models
lms ls                    # installed models
lms ps                    # loaded models
lms get <model>           # download
lms import <file>         # bring in a local GGUF
lms load / lms chat       # load, or start an interactive REPL

# server + daemon
lms server start | status | stop
lms daemon up | down | status | update
lms log stream            # live request log

# engines
lms runtime ls | get | select | update | remove

# multi-device
lms login
lms link enable | status | set-preferred-device

Three server-side features are worth knowing before you deploy this anywhere real. Authentication exists — 0.4.21 added local server API key support in enterprise internal-network endpoint mode. Serve on local network binds beyond loopback, which you should pair with a firewall rule. And idle TTL with auto-eviction unloads models after a period of inactivity, which is how you run several models on one box without holding all of them in memory at once.

LM Link

LM Link, which left its waitlist in 0.4.16 (8 June 2026), connects your LM Studio devices to each other. Run lms login then lms link enable, and models on one machine become usable from another — including from Bionic, as of 0.4.20. The free tier covers five devices. Practically, this is how a laptop borrows the 64 GB desktop in the other room rather than trying to run a 70B model on battery.

LM Studio vs Ollama vs Jan vs llama.cpp: which should you pick?

The short version. Pick LM Studio if you want a real interface, MLX on a Mac, and an OpenAI/Anthropic-compatible endpoint without writing setup code. Pick Ollama if you live in a terminal and deploy in containers. Pick Jan if a fully open-source GUI is a requirement. Use llama.cpp directly when you want every flag. For production serving with real concurrency, none of these is the answer — that is vLLM's job.

We have measured this comparison properly elsewhere; see Ollama vs LM Studio vs vLLM vs llama.cpp vs MLX for the head-to-head, and the self-hosting LLMs guide for the wider landscape.

How much RAM do you need for LM Studio?

Assume 4-bit quantisation, and leave headroom for context and the OS. On Apple Silicon, unified memory counts as VRAM, so the numbers below are total system RAM; on Windows and Linux with a discrete GPU, aim to fit the model in VRAM.

Two shortcuts beat estimating. The Discover tab flags whether a given quant fits your machine before you download it, and lms load <model> --estimate-only gives you the memory bill from the CLI. For a worked example of sizing a specific large model locally, see our GLM 5.2 local setup guide.

What changed in LM Studio during 2026?

If your mental model of LM Studio is the 0.3.x era, several things have moved:

• The Engine Protocol (0.4.15 → stable in 0.4.19) split engine updates from app updates. This is the biggest structural change and the one that changes your troubleshooting habits.
• Anthropic-compatible /v1/messages joined the OpenAI-compatible endpoints, with image support in both as of 0.4.22.
• LM Link went general availability in 0.4.16, alongside a "Locally" mobile app for iPhone and iPad.
• MTP speculative decoding went stable in 0.4.14, and CUDA tensor parallelism arrived in 0.4.15.
• Bionic launched as a separate agent product for open models — document work, coding, computer control and local voice transcription, running on the same MLX and llama.cpp runtime.
• Server authentication and enterprise internal-network endpoints arrived in 0.4.20–0.4.21, which is what makes a shared LM Studio box defensible rather than merely convenient.

When should you not use LM Studio?

• Production inference at scale. It is single-node. High-concurrency serving belongs to vLLM or TGI.
• You are on an Intel Mac. Current builds require Apple Silicon. This is a hard stop, not a performance note.
• You need to embed it in a product you sell. The terms prohibit SaaS and service-bureau use; that is an Enterprise conversation.
• You need a fully open-source stack. The desktop app is closed source. The CLI, both SDKs and the MLX engine are on GitHub, and llama.cpp and MLX are open — but the app itself is not.
• Frontier-quality reasoning. Local open models have closed a lot of ground, but on hard multi-file refactors and long-horizon reasoning a frontier API model is still the better tool. Use LM Studio for offline work, sensitive data and cost control; reach for the API when the task is genuinely hard.

The short recommendation

If you are on an Apple Silicon Mac, install it with brew install --cask lm-studio, start with an 8B model at Q4, and try the MLX build before the GGUF one. If you are on Windows or Linux with a discrete GPU, take the installer, keep GPU offload at max, and size the model to your VRAM rather than your ambition. If the machine is a headless server, skip the desktop app entirely and install llmster.

Then, whatever you are on, do the thing nobody tells you to do: check Settings → Runtimes and update your engine. Since the Engine Protocol shipped, a stale engine — not a stale app — is the most common reason LM Studio underperforms or refuses to load a model that everyone else says works fine.

FAQ

Is LM Studio free?

Yes. The desktop app is free, and that includes local inference through llama.cpp and MLX, offline voice transcription, and LM Link for up to five devices. Optional paid extras exist — pay-as-you-go cloud credits for frontier open models, and a Bionic Pass whose pricing has not been announced — but nothing about running models locally on your own machine costs money.

Is LM Studio free for commercial use?

Yes for internal business use. LM Studio's terms grant a licence for "personal and / or internal business purposes", so using it at work needs no extra licence or payment. What is prohibited is redistribution: you may not sublicense, sell, rent, or run it as a service bureau, application service provider or SaaS. Embedding it in a product you sell requires an Enterprise agreement.

How do I install LM Studio?

Download the installer from lmstudio.ai/download for macOS, Windows or Linux. On an Apple Silicon Mac you can instead run brew install --cask lm-studio. For a headless server, skip the desktop app and install llmster with curl -fsSL https://lmstudio.ai/install.sh | bash on macOS or Linux, or irm https://lmstudio.ai/install.ps1 | iex on Windows, then run lms daemon up.

Does LM Studio work on Apple Silicon?

Yes, and Apple Silicon is the only supported Mac hardware. LM Studio requires macOS 14 or newer on an M1, M2, M3 or M4 Mac; Intel Macs are not supported by current builds. Apple Silicon also unlocks the MLX engine alongside llama.cpp, and unified memory counts toward what you can load, so a 32 GB Mac behaves roughly like a 32 GB GPU.

What is the LM Studio Engine Protocol?

It is the architecture that separates LM Studio's inference engines from the app itself, introduced in 0.4.15 and on by default since 0.4.19. Its stated purpose is to let LM Studio ship engine updates more frequently. The practical consequence: engines are versioned independently of the app, so "update LM Studio" and "update your runtime" are two separate actions — manage the second via Settings → Runtimes or lms runtime update.

LM Studio vs Ollama — which should I use?

Use LM Studio if you want a graphical interface, MLX acceleration on a Mac, or an endpoint that speaks both OpenAI and Anthropic API formats without setup. Use Ollama if you work primarily in the terminal, want official Docker images, or are deploying into containers and CI. Both wrap llama.cpp and both expose an OpenAI-compatible local API, so switching later is inexpensive.

How much RAM do I need for LM Studio?

16 GB is the recommended minimum and comfortably runs 7B–8B models at 4-bit quantisation. 32 GB handles 13B–14B models and is the sweet spot for local coding work; 64 GB opens up 30B–70B. 8 GB works only with small models. Remember context length also consumes memory — use lms load <model> --estimate-only to check before downloading.

Can I install LM Studio with Homebrew?

Yes. brew install --cask lm-studio installs the official cask on Apple Silicon Macs, currently tracking version 0.4.23. The cask is marked auto-updating, so LM Studio's own updater keeps it current rather than conflicting with Homebrew. The cask metadata lists macOS 12+, but LM Studio's official requirement is macOS 14 or newer.

Can I run LM Studio headless on a Linux server?

Yes, and there is a purpose-built way to do it. Install llmster — described in the docs as the core of LM Studio packaged to be server-native without the GUI — using the install script, then run lms daemon up and lms server start. Combine it with idle TTL auto-eviction to share one box across several models, and enable server authentication before exposing it beyond loopback.

Is LM Studio open source?

Partly. The desktop application is closed source. The lms CLI, the TypeScript and Python SDKs, and the Apple MLX engine are all published under the lmstudio-ai GitHub organisation, and the underlying inference engines — llama.cpp and MLX — are open source projects in their own right. If a fully open-source stack is a hard requirement, Jan or llama.cpp directly are the closer fits.

References

• LM Studio homepage
• Download LM Studio
• LM Studio changelog
• LM Studio pricing
• LM Studio terms of use
• System requirements
• Local server docs
• Headless / llmster docs
• lms runtime reference
• Generator plugins
• Homebrew cask: lm-studio