What Is LM Studio

LM Studio is a free, closed-source desktop application that lets you download and run open-weight large language models entirely on your own machine. It ships for Windows, macOS and Linux, bundles inference engines (llama.cpp on all platforms, MLX on Apple Silicon), provides a ChatGPT-style GUI, and exposes an OpenAI-compatible REST server on localhost:1234 so applications written against the OpenAI SDK can talk to a local model unchanged.

The app is developed by the team behind lmstudio.ai. It is free for personal use and, per the vendor’s work-use page, also free for use at work; commercial redistribution has its own terms.

What LM Studio actually does

LM Studio combines four things that would otherwise be separate tools:

• Model discovery. A built-in search UI queries Hugging Face for GGUF and MLX files. You pick a quantisation (Q4_K_M, Q5_K_M, Q6_K, Q8_0, etc.) and it downloads directly into a local models folder.
• Chat UI. A multi-turn chat window with per-conversation system prompts, temperature/top-p sliders, structured output (JSON schema), and support for attaching PDFs or images (the latter only with vision-capable models).
• Local inference server. An HTTP endpoint at http://localhost:1234/v1 that speaks the OpenAI Chat Completions, Completions and Embeddings API surface. See the vendor’s OpenAI-compatibility docs.
• CLI (lms). A command-line tool for scripting model loads, unloads and server control. Installation and commands are documented at lmstudio.ai/docs/cli.

Under the hood, inference runs on llama.cpp for GGUF models and on Apple MLX for MLX-format models on Apple Silicon. LM Studio ships prebuilt engine binaries and lets you switch or update them from the app’s runtime settings.

Supported platforms

Plattform	Requirements (per vendor)	Acceleration
Windows	x64 or ARM64; AVX2-capable CPU on x64	CPU, NVIDIA CUDA, Vulkan (AMD/Intel GPUs)
macOS	Apple Silicon (M1 or newer), macOS 13.4+	Metal (llama.cpp) and MLX
Linux	x64, glibc 2.35+, distributed as AppImage	CPU, NVIDIA CUDA, Vulkan

The current published requirements live on the official download page; check there before installing, since exact minimums shift between releases.

Windows

Installer is a standard .exe. Models default to %USERPROFILE%\.lmstudio\models. NVIDIA GPUs use CUDA when a supported runtime is selected; other GPUs fall back to Vulkan. AVX2 is required on x64 CPUs, so very old processors are excluded.

macOS

Distributed as a .dmg. On Apple Silicon, MLX-format models are available in addition to GGUF and generally use unified memory efficiently. Models default to ~/.lmstudio/models. Intel Macs are not supported by current builds.

Linux

Shipped as an .AppImage. Mark it executable (chmod +x LM-Studio-*.AppImage) and run it directly. NVIDIA GPUs use CUDA; AMD and Intel GPUs use Vulkan. There is no official .deb oder .rpm at the time of writing — check the download page for the current packaging.

What you can run in LM Studio

LM Studio can load any GGUF model that llama.cpp supports, plus MLX models on Apple Silicon. What actually fits on your hardware is the constraint. Approximate 4-bit VRAM footprints from the Convly-Modell-Datenbank:

Modell	Kontext	~VRAM bei 4-Bit
Gemma 3 4B	128 K	ca. 3 GB
Mistral 7B	32K	~4,5 GB
Llama 3.1 8B	128 K	~5 GB
Qwen3 8B	128 K	~5 GB
Phi-4	16K	~9 GB
Gemma 3 12B	128 K	~8 GB
Qwen3 14B	128 K	~9 GB
Gemma 3 27B	128 K	~16 GB
Qwen3 32B	128 K	~20 GB
Llama 3.3 70B	128 K	~40 GB

Anything above roughly 40 GB requires multi-GPU or high-VRAM cards. Very large models such as DeepSeek R1 (~400 GB at 4-bit) are not practical to run on a single desktop GPU. See the full VRAM-Anforderungstabelle und das GPU guide for local LLMs before buying hardware.

The OpenAI-compatible server

The most useful feature for developers is the local server. Start it from the Entwickler tab in the GUI or via the CLI. Once running, it accepts standard OpenAI-style requests:

curl http://localhost:1234/v1/chat/completions 
  -H "Content-Type: application/json" 
  -d '{
    "model": "loaded-model-identifier",
    "messages": [{"role": "user", "content": "Hello"}]
  }'

The Python SDK works by pointing base_url at the local server:

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

Der api_key value is ignored by default but the field must be present because the OpenAI SDK requires it. Supported endpoints and any deviations from OpenAI’s schema are listed in the API reference.

LM Studio vs. Ollama

The two are the most common ways to run local LLMs on a workstation. Rough shape of the difference:

	LM Studio	Ollama
Hauptoberfläche	Desktop GUI (chat, model browser)	CLI and HTTP API
Lizenz	Closed-source app; free for personal and work use	Open source (MIT)
Modellquelle	Hugging Face (GGUF, MLX) via in-app search	Ollama model registry (with import from GGUF)
Server	OpenAI-compatible at :1234	Native API at :11434, OpenAI-compatible layer
Apple Silicon MLX	Ja	No (llama.cpp only)

If you want a point-and-click UI and MLX support on a Mac, LM Studio is the easier starting point. If you want a scriptable open-source stack and headless server, see the Ollama-Leitfaden und installation walkthrough.

When to use LM Studio instead of a hosted API

Local inference is a real tradeoff. The upside is privacy (nothing leaves the machine), predictable cost after hardware amortisation, and offline availability. The downside is capital cost, slower tokens/second than a hosted GPU cluster, and no access to frontier proprietary models.

For a rough sense of the cost boundary: hosted models on the Convly LLM leaderboard range from about $0.02 per million input tokens for small open models on serverless providers up to $10 in / $50 out per million tokens for frontier proprietary models. If your workload sits at the small-model end and you can tolerate 8B–30B quality, self-hosting on a single consumer GPU frequently wins on total cost. Run your own numbers with the Selbsthosting vs. API-Rechner und das API-Kostenrechner.

Practical setup checklist

1. Check VRAM. Anything larger than your GPU’s memory will spill to system RAM and slow down dramatically. Use the VRAM-Rechner.
2. Download LM Studio from lmstudio.ai/download. Do not install from third-party mirrors.
3. In the app’s Discover tab, pick a model that fits. Start with a Q4_K_M quantisation for the best size/quality tradeoff.
4. Load the model. Watch the VRAM indicator; if it can’t fully offload to GPU, choose a smaller quant or a smaller model.
5. Enable the server from the Entwickler tab if you plan to hit it from code. Confirm with curl http://localhost:1234/v1/models.

For a step-by-step walkthrough with screenshots, see the LM Studio – umfassende Anleitung. For model shortlists tuned to local hardware, see best local models (the recommendations apply equally to LM Studio, since both engines use llama.cpp).

Häufig gestellte Fragen

Is LM Studio free?

Yes. LM Studio is free to download and use for personal and, per the vendor’s work-use policy, professional use. The app itself is closed-source, but the models you run in it are open-weight models licensed by their respective publishers (Meta, Google, Alibaba, Mistral, etc.).

Does LM Studio send data to the cloud?

Inference runs entirely on your machine — prompts and responses do not leave the device. The app does connect out to Hugging Face when you search or download models, and it checks for updates. There is no telemetry of chat contents according to the vendor’s privacy page; review it directly for the current policy.

What model formats does LM Studio support?

GGUF on all platforms (via llama.cpp) and MLX on Apple Silicon. Raw Hugging Face safetensors and PyTorch checkpoints are not supported directly — convert them to GGUF first, or download a pre-quantised GGUF that the community has already published.

Can I use LM Studio as a drop-in replacement for the OpenAI API?

For chat completions, completions and embeddings, largely yes: point the OpenAI SDK’s base_url auf http://localhost:1234/v1 and existing code works. Features that depend on OpenAI-specific server behaviour (assistants, file API, image generation, moderation) are not implemented. Check the current endpoint list.

How much RAM or VRAM do I need?

Rule of thumb at 4-bit quantisation: model size in billions of parameters times ~0.6 gives GB of VRAM needed for weights, plus a few GB for KV cache at long contexts. A 7–8B model runs comfortably on an 8 GB GPU; a 70B model needs roughly 40 GB (see the Convly Modelldatenbank figures above). For a full breakdown by model, see VRAM requirements.

Does LM Studio support tool calling and structured outputs?

Yes for structured outputs via JSON schema, and tool/function calling is supported for models whose chat templates advertise it (recent Llama, Qwen, Mistral, and Gemma releases in particular). The quality of tool calling depends on the underlying model, not on LM Studio itself. Test with your target model before committing to it in production.