LM Studio Download and Install on Windows 11, Mac and Linux (0.4.26): Real File Sizes, the AVX2 Check, Is It Free, First Model by RAM, Where Models Live, lms CLI and Headless llmster

LM Studio is a free desktop app that downloads open AI models and runs them on your own computer, offline, with a chat window and a local API. Download it only from lmstudio.ai/download; the current version is 0.4.26, and the installers are bigger than the page lets on: 619 MB for Windows x64, 571 MB for Mac, and a 1.02 GB AppImage for Linux. Install it, open the Discover tab, download one small model, load it, and you're chatting in about ten minutes on any PC with 16 GB of RAM. Here is the catch that stops the most people: on Windows and Linux, LM Studio needs a CPU with AVX2. On a PC from before about 2013 the app installs and opens, then refuses to load every model you download. Check that first; this page shows you how, then walks through Windows 11, Mac, Linux and Kali, the first model, where the files go, GPU settings, the local server for VS Code, the lms command line, and the no-GUI version called llmster.

Jake runs a phone repair shop, and he wanted what everyone wants this year: an AI that drafts the "your phone is ready" messages and reads warranty PDFs without sending customer names to a cloud service. His friend Ethan, a developer, had one word: LM Studio. Jake downloaded it, opened it, downloaded the first model the app suggested, and got "Failed to load model" on the shop's old front-desk PC. Then he installed it on his newer laptop and it worked in ten minutes. The difference was one CPU instruction, AVX2, and nothing on the download page mentions it. This page is the install guide Ethan wished he'd sent Jake first: the right file, the checks, every operating system, and the parts you only find out after the first week.

LM Studio download: the official page, the real file sizes and which file you need

There's one official source, lmstudio.ai/download, and a one-line installer for the headless version. Anything called "LM Studio free download" on a software-portal site is a repackaged copy at best; skip it. The download page shows a single big button for your current operating system and no file sizes, so here's what the buttons fetch as of October 24, 2026, measured from the download links themselves:

The version number tells you something useful: 0.4.x is the 2026 generation that added server deployment, parallel requests and a REST API in January; if a tutorial shows a 0.3.x screen, the menus have moved. The in-app updater keeps Windows and Mac current; on Linux the in-app updater isn't available yet, so you download a new AppImage when a version you want ships.

Jake: "Why doesn't the page just say 619 megabytes?"

Ethan: "Because the people who built it download a gigabyte before breakfast. For a shop PC on a metered connection, it matters, so now you know."

Is LM Studio free? Pricing, what costs money, open source or not, and what it collects

The desktop app is free for personal use and for work. Until July 8, 2025, using it inside a company needed a separate commercial license; that requirement was dropped that day, and the terms now grant a license for personal and internal business use with no form to fill in. What costs money is the cloud layer that arrived with the company's second app, Bionic: the Free plan is $0 and covers local models, Bionic+ is $20 a month for US-hosted models and web search, and Pro is $100 a month for five times the usage limits. If you only run models on your own hardware, you never see a bill.

Three questions people type into search engines, answered plainly:

• Is LM Studio open source? No. The app and its source are proprietary, owned by Element Labs, Inc. The pieces around it are open: the lms command-line tool is MIT licensed on GitHub, the engines underneath are llama.cpp and MLX, and the models you download are whatever license their publisher chose. Ollama and llama.cpp are the open-source alternatives if that matters to you; our comparison of local AI apps weighs them.
• Does LM Studio collect data? The privacy policy in force since June 2026 draws the line this way: the app has no telemetry or user-specific tracking; model searches are sent anonymized so the company can see which models are popular; the update check sends the app version and operating system, and the download network sees your IP address like any website; and for local use, messages, chat histories and documents are never transmitted from your system. Cloud features only send anything if you buy them and switch them on.
• Is LM Studio safe? As safe as the models you download. The app itself is signed and comes from one domain; the risk is a model file from an unknown publisher. Stick to the staff picks and well-known publishers in the Discover tab, and read the model's license page before using its output commercially.

LM Studio system requirements, and the AVX2 trap

Check AVX2 before you download

AVX2 arrived with Intel's 4th-generation Core (Haswell, 2013) and AMD's Excavator and Ryzen chips. Most PCs sold since 2015 have it; many Pentium, Celeron and Atom chips from the same years do not, which is why a cheap office PC can fail where an older gaming PC works. Check in ten seconds:

• Windows: open PowerShell and run (Get-CimInstance Win32_Processor).Name, then look the model up; or install the free CPU-Z and look for AVX2 in the Instructions line.
• Linux and Kali: grep -o -m1 avx2 /proc/cpuinfo prints avx2 if you have it and nothing if you don't.
• Mac: no check needed on Apple Silicon; on an Intel Mac, LM Studio isn't offered at all.

Without AVX2, the app opens but every model fails to load. Ollama and llama.cpp can run on such a machine, slowly, so the PC isn't useless for local AI; it's just the wrong PC for LM Studio. Our failed-to-load guide has the section on older computers.

How to install LM Studio on Windows 11 (x64 and ARM)

1. Open lmstudio.ai/download and select Download LM Studio for Windows. On a Snapdragon laptop the page offers the ARM build; if it offers x64 by mistake, the ARM link is on the same page under the other platforms.
2. Run the installer. It installs for the current user and finishes in about a minute; the first launch takes longer while it unpacks runtimes.
3. On first launch, pick a level: User hides the knobs, Power User shows load settings, Developer adds the server tab. You can change this at any time from the bottom-left of the window; start with Power User if you plan to follow this page.
4. Skip the suggested first download if your PC has 8 GB of RAM; pick one from the first-model table instead.
5. Press Ctrl + Shift + R to open the runtimes panel and confirm that a GPU runtime (CUDA for NVIDIA, Vulkan for AMD and Intel) is installed and selected. On a PC without a dedicated GPU, the CPU runtime is correct.

Updates arrive through the app: it checks on launch and offers the new version. If you manage several PCs, the clean route is llmster on one machine plus the local server, rather than the desktop app on every desk.

Windows on ARM

The ARM64 build is native, which matters: an x64 build under emulation would lose most of the speed. Build 0.4.26-5, the current one, fixed a bug where Windows on ARM didn't detect CUDA on machines that have an NVIDIA GPU, and 0.4.26 added CUDA 13 support on ARM. On a Snapdragon X laptop with no NVIDIA chip, the CPU and the integrated GPU do the work; a 4B to 9B model at 4-bit is the comfortable range.

How to install LM Studio on a Mac (Apple Silicon only)

1. Download the .dmg, open it and drag LM Studio to Applications. macOS 14 or newer is required; Sonoma, Sequoia and later all qualify.
2. Open it from Applications. If macOS says it can't verify the developer, open System Settings, Privacy & Security, and allow it; the app is signed, and this prompt appears when the download was quarantined by a browser.
3. Pick User, Power User or Developer as above.
4. Download your first model. On a Mac, LM Studio offers two engines: MLX files, built for Apple Silicon, and GGUF files, which run through llama.cpp with Metal. MLX is usually the faster choice for the same model; GGUF has the wider catalog.

Memory is the whole story on a Mac, because the GPU uses the same memory as everything else. 8 GB runs 3B and 4B models with a short context; 16 GB runs 7B to 14B at 4-bit comfortably; 32 GB and up opens the 27B to 35B class. One Mac user with an M1 Max and 64 GB loaded a 32B model and hit errors; the usual cause at that size is context length set too high for the memory left after the weights, and the fix is in the load settings, not a different Mac. Since 0.4.25, Macs with an M3 or newer chip on macOS 26.4 or later can also use the Splash engine, a third-party engine tuned for Qwen3.8 that the app offers as a runtime.

Intel Mac? LM Studio isn't available for it. Ollama and llama.cpp still support Intel Macs on the CPU, and our comparison covers what to expect from them.

How to install LM Studio on Linux and Kali (the AppImage)

Linux gets a single AppImage, which is a self-contained executable. There is no apt or dnf package from the project, and no automatic updates yet.

1. Download the x64 AppImage (1.02 GB) from the download page, or from a terminal:

   mkdir -p ~/Apps && cd ~/Apps
   curl -L -o LM-Studio.AppImage "https://lmstudio.ai/download/latest/linux/x64"
   chmod +x LM-Studio.AppImage

2. Run it: ./LM-Studio.AppImage. If it exits with a message about FUSE or libfuse.so.2, install the FUSE 2 compatibility library (sudo apt install libfuse2 on Debian, Ubuntu and Kali; libfuse2t64 on Ubuntu 24.04), or run it without FUSE: ./LM-Studio.AppImage --appimage-extract-and-run.
3. On Kali, which runs as a normal user since 2020, nothing else is needed. If you still run a desktop as root, Electron apps refuse to start; add --no-sandbox or, better, use a normal account.
4. For a menu entry, right-click the AppImage in your file manager and choose to integrate it, or use the AppImageLauncher package; LM Studio itself doesn't add a launcher.
5. Press Ctrl + Shift + R and check the runtime. NVIDIA needs the proprietary driver installed (CUDA comes with the runtime pack, not with your distro); AMD and Intel use Vulkan, which needs the Mesa Vulkan drivers (mesa-vulkan-drivers).

The ARM64 AppImage (1.29 GB) runs on a Raspberry Pi 5 with 8 GB and on ARM servers; it's CPU-only there, so stay with 1B to 4B models. For a Linux box without a desktop, skip the AppImage entirely and install llmster.

Jake: "A gigabyte for a Linux download when Windows gets 619 megabytes?"

Ethan: "The AppImage carries its own copy of everything a desktop app normally borrows from the system. It's the price of running the same file on Ubuntu, Kali and Fedora without a package for each."

Your first model: Discover, the right quantization, download, load, chat

Open the Discover tab (Ctrl + 2, or Cmd + 2 on a Mac). You can search by keyword, by a publisher/model name, or by pasting a Hugging Face URL. Each model lists several files with names like Q4_K_M or Q8_0: the Q is the quantization, a compression level, and a 4-bit file is the default pick unless your machine has room for more. The app estimates whether a file fits your memory and marks the ones that won't. Download, then open the Chat tab, open the model loader at the top, select the model, leave the load settings alone the first time, and start typing.

Pick your first model from this table, not from the top of the download chart; the chart leans to models that need 24 GB of VRAM.

A reader with an i9-14900K, an RTX 4080 Super and 64 GB of RAM asked what token speed he should expect from Qwen3.8-27B so he'd know whether his setup was healthy. The honest check is the load, not a number: with the Q4_K_M file fully offloaded on a 16 GB card, generation should feel like fast typing; if it crawls at a few tokens a second, the model spilled into system RAM, and the GPU offload slider in the GPU section is the fix. Another reader on Windows 11 Home asked which model to download at all, given a PC spec sheet and no experience: the 16 GB row above, a 7B to 9B model at Q4_K_M, is the answer for nearly every laptop made since 2022.

Where LM Studio stores models (and how to move them to another drive)

Every model you download lands under one folder, laid out the way Hugging Face lays out repositories:

~/.lmstudio/models/<publisher>/<model>/<file>.gguf
Windows:  C:\Users\<you>\.lmstudio\models\
Mac:      /Users/<you>/.lmstudio/models/
Linux:    /home/<you>/.lmstudio/models/

Three things follow from that layout:

• Moving to another drive. Open My Models and use the models-directory control at the top to point LM Studio at a folder on the bigger drive, then move the existing publisher/model folders into it. Change the setting first and move second, so the app re-indexes once.
• Using a GGUF you already have. Create the two-level folder by hand, for example models/unsloth/Qwen3.8-9B-GGUF/, drop the .gguf inside, and it appears in My Models at the next refresh. The command-line route, lms import path/to/model.gguf, does the same with a prompt, and is marked experimental.
• Sharing with Ollama. Ollama stores models as content-addressed blobs, not as named .gguf files, so the two apps don't share a folder. If you use both, download twice or point Ollama at a Modelfile that references the GGUF in LM Studio's folder.

The lms ls command lists what's on disk, in the directory set in My Models, with sizes, which is the quickest way to see where 80 GB of SSD went.

GPU offload, runtimes and multi-GPU settings

Three panels decide how fast a model runs, and new users find one of them by accident.

Runtimes: Ctrl + Shift + R

LM Studio runs models through engines it calls runtimes and updates separately from the app: llama.cpp builds for CPU, CUDA (NVIDIA), Vulkan (AMD, Intel and NVIDIA) and ROCm (AMD), plus MLX and Metal on Macs. The runtimes panel shows which is installed and selected for GGUF and for MLX models, and offers updates; 0.4.26 shipped with llama.cpp runtime 2.50.0, and the packs keep moving every couple of weeks. If a brand-new model says "unknown model architecture," update the runtime here before anything else.

Load settings: the GPU offload slider

In the model loader (Power User or Developer level) the GPU offload slider sets how many layers go to the graphics card; the rest run on the CPU from system RAM. Max is right when the whole file fits in VRAM with a couple of gigabytes to spare for the context; otherwise lower it until the model loads and the speed is steady. Context length is the other dial that matters: every token of context costs memory, so 4K to 8K is the sensible default on small machines, and 32K or more is for 16 GB cards and up. Flash Attention on, and the K/V cache quantization options, reduce that cost on NVIDIA and Apple hardware. Save your choices with the gear icon in My Models so they apply every time, including from lms load.

Several GPUs: Ctrl + Shift + H

The GPU controls panel lists every GPU with a switch to disable it, an allocation strategy (evenly across cards, or priority order that fills one card before the next, CUDA only), and a setting to limit offload to dedicated GPU memory so weights never spill into slow shared memory (also CUDA only). A reader with an RTX 5070 asked whether adding an AMD or Intel card would let LM Studio split a model across both. Within one vendor it works through the matching runtime; across vendors it does not, because a load uses one runtime, and CUDA can't see a Radeon. The practical answer is a second NVIDIA card, or a single bigger one.

Use LM Studio from VS Code and other apps: the local server

Every chat app, coding assistant and script that speaks the OpenAI API can talk to LM Studio instead of the cloud. Open the Developer tab, switch the server on, and it listens on http://localhost:1234. The endpoints are /v1/models, /v1/chat/completions, /v1/completions, /v1/embeddings, /v1/responses and, since 0.4.26, /v1/decisions; there's also an Anthropic-compatible endpoint for tools built for that API. Test it from any terminal:

curl http://localhost:1234/v1/models

curl http://localhost:1234/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "qwen3.8-9b", "messages": [{"role":"user","content":"Say this is a test"}], "temperature": 0.7}'

In Python, the official OpenAI client works unchanged: OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio"). The key can be any string unless you've configured authentication on the server. The model field is the identifier shown in LM Studio, and with just-in-time loading on (the default), asking for a downloaded model that isn't in memory loads it on the first request and unloads it after a period of idleness.

A beginner asked whether people connect their IDE to the local model or copy code blocks out of the chat window. Connect it: in VS Code, extensions such as Continue, Cline and Roo Code take a base URL and a model name, and once that's set the editor sends code with its context, which the chat window can't. Tick Run the LLM server on login in the app settings (Ctrl + ,) so the server is up before the editor is; closing the window then minimizes LM Studio to the tray and keeps serving. For a second machine on your network, enable Serve on local network and use the PC's IP instead of localhost; put a firewall rule in front of it before you do that on a laptop that leaves the house.

The lms command line: load, serve and script LM Studio from a terminal

lms ships inside the app and inside llmster, and talks to whichever is running; if the app isn't running when you call it, it starts it. Run the app once before the first use, then open a terminal:

If a terminal says lms is not recognized, the app hasn't been run yet on this account, or the PATH entry it adds hasn't reached that terminal: open a new terminal window, or run the bootstrap once (cmd /c %USERPROFILE%/.lmstudio/bin/lms.exe bootstrap on Windows, ~/.lmstudio/bin/lms bootstrap on Mac and Linux).

llmster: LM Studio without the app, on servers and in scripts

The engine inside LM Studio also ships on its own as llmster, a daemon you install with one line and drive entirely with lms. It's the right choice for a Linux box with no desktop, a GPU server in a cupboard, a CI pipeline, or a PC where you want the model server to start at boot without a window. The desktop app is the full experience with chat, document chat, MCP servers and presets; llmster is the serving half.

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

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

# then
lms daemon up
lms get openai/gpt-oss-20b
lms load openai/gpt-oss-20b --yes
lms server start
curl http://localhost:1234/v1/models

Read the script before you pipe it to a shell; it's 18 KB and plain. What it does, from its own text: detects your platform, downloads an archive named like 0.0.25-1-linux-x64.full.tar.gz from llmster.lmstudio.ai, verifies a checksum, unpacks into ~/.lmstudio/bin (or ~/.cache/lm-studio/bin; on Windows %USERPROFILE%\.lmstudio\bin or %LOCALAPPDATA%\lm-studio\bin), and adds that folder to your PATH through your shell profiles, or through lms bootstrap -y on Windows. Two details you'll meet on Linux: it refuses to run without ldconfig and the libatomic library (sudo apt-get install -y libatomic1 on Debian, Ubuntu and Kali; sudo dnf install -y libatomic on Fedora), and on x64 it fetches a +cuda12 bundle when it detects an NVIDIA driver at CUDA 12.4 or newer, so the download size depends on your GPU. Set LMS_NO_MODIFY_PATH=1 if you'd rather manage PATH yourself.

Start at boot on Linux

The documented way is a systemd unit. Replace the username and the model, save it as /etc/systemd/system/lmstudio.service, then sudo systemctl daemon-reload && sudo systemctl enable --now lmstudio:

[Unit]
Description=LM Studio Server

[Service]
Type=oneshot
RemainAfterExit=yes
User=YOUR_USERNAME
Environment="HOME=/home/YOUR_USERNAME"
ExecStartPre=/home/YOUR_USERNAME/.lmstudio/bin/lms daemon up
ExecStartPre=/home/YOUR_USERNAME/.lmstudio/bin/lms load openai/gpt-oss-20b --yes
ExecStart=/home/YOUR_USERNAME/.lmstudio/bin/lms server start
ExecStop=/home/YOUR_USERNAME/.lmstudio/bin/lms daemon down

[Install]
WantedBy=multi-user.target

Leave out the lms load line if you'd rather let just-in-time loading pull models on the first request. Check with systemctl status lmstudio and curl http://localhost:1234/v1/models. On a server that other machines will call, bind to the network interface in the server settings and put it behind a firewall rule or a reverse proxy with authentication; it ships open to anything that can reach the port.

Jake: "So the shop's old tower in the back, the one with the decent graphics card and no monitor, could run the model for every PC in the shop?"

Ethan: "That's exactly what llmster is for. Install it, point the front-desk PCs at the tower's IP and port 1234, and the model lives in one place."

LM Studio not working after install: the first-week errors

"Error fetching staff picks" or an empty Discover tab

The app couldn't reach its servers or Hugging Face. The same session usually logs "Network connection failed" for the update check too. Causes, in order of how often they turn out to be the reason: a VPN or corporate firewall that blocks lmstudio.ai or huggingface.co; a proxy the app doesn't know about (start it from a terminal with https_proxy set); and SSL inspection at work that re-signs certificates, which the app won't trust. The models you already have load and chat fine offline; only search and download need the network. If you can't fix the network, download the GGUF in a browser and drop it into the models folder as described in the storage section.

"Failed to load model"

The error line underneath says which of a dozen causes it is: insufficient system resources (reduce context or pick a smaller quantization), unknown model architecture (update the runtime with Ctrl + Shift + R), a CPU without AVX2, a damaged download, or a GPU driver problem. Each is decoded in our failed-to-load guide.

The Linux AppImage won't start

A FUSE message means the libfuse2 library is missing; a sandbox message means you're running as root. Both fixes are in the Linux section. A silent exit on a very old distribution is a glibc that's too old for Electron; Ubuntu 20.04 is the floor.

The server answers nothing, or port 1234 is in use

lms server status tells you whether it's running; lms log stream shows whether requests arrive. If another program holds port 1234, change the port in the Developer tab and in your client. If requests arrive but take forever, the model spilled into system RAM: lower the context length or raise the GPU offload until lms ps shows it fully on the GPU.

"lms is not recognized"

Run the desktop app once on this user account, open a new terminal, and try again; if it still fails, run the bootstrap command from the CLI section.

LM Studio vs Ollama vs Bionic: which one are you installing?

Three names come up together, and two of them come from the same company.

• LM Studio is the desktop app on this page: a window for chatting with local models, plus the local server and CLI. Best for people who want to see what's happening and tune it.
• Ollama is a command-line-first runner with a large library and a simpler mental model: ollama run model. Open source, no AVX2 requirement, and the better fit for scripts and containers. Our comparison goes feature by feature, and the Docker Compose guide covers the container route.
• LM Studio Bionic is a separate app from the same company, launched July 2026: an agent that works on files and code using local models, remote models over LM Link, or paid cloud models. Since LM Studio 0.4.26 and Bionic 1.1.8 the two run side by side, with Bionic using LM Studio for local inference when both are open. If you want an agent that edits your project, install Bionic; if you want to run and serve models, install LM Studio; many people end up with both.

LM Studio download and install: frequently asked questions

Jake's laptop runs a 9B model at Q4 with an 8K context, serves it on port 1234, and the front-desk PC, the one without AVX2, now sends its drafts to the laptop over the shop Wi-Fi instead of to the cloud. The old tower in the back is next: Ethan has the llmster unit file ready, and the tower has a graphics card that's done nothing since 2022. Ethan left the line below on the counter.

Revision note. Written October 24, 2026, for everyone whose first model failed to load on a perfectly good office PC. "Measure twice, cut once," says the old proverb; one CPU check saves a gigabyte and an evening.