Loading a Model Straight From Hugging Face in LM Studio

LM Studio’s model catalogue is Hugging Face. There is no separate registry and nothing is curated away, which means almost any GGUF on the Hub is reachable from inside the app — and also that the handful of repositories which do not show up need explaining, because the reason is never an error message.

What the search box accepts

The app’s documentation states that it comes with a built-in model downloader that can fetch any supported model from Hugging Face, reached from the Discover tab — documented as ⌘ + 2 on macOS and ctrl + 2 on Windows and Linux from anywhere in the app.

The input accepts three different things, and knowing that saves most of the fumbling:

• A keyword — llama, gemma, qwen. Fuzzy, ranked, and the right move when you do not know what you want.
• A user/model string — lmstudio-community/Meta-Llama-3.1-8B-Instruct-GGUF. Exact, and the right move when somebody has told you which repository to use.
• A full Hugging Face URL, pasted straight in. This is the documented behaviour and it is the one people do not expect: you can browse the Hub in a browser, copy the address bar, and paste it into the app.

Once a repository resolves you get its quantizations, each with a file size and an indication of whether it will fit on this machine. Which one to take is its own question — which quant to download works through the arithmetic. The short version is that the size shown is the honest input and the name is not.

Why a repository you can see does not appear

This is the part of the row that most needs writing down, because every cause looks the same from the search box: nothing found.

• It is not in a format the app runs. The overwhelming majority of repositories on the Hub hold safetensors weights for PyTorch, and LM Studio runs GGUF, plus MLX on Apple Silicon. A repository with no GGUF file in it is not a repository the app can offer you, and it is filtered rather than shown-and-refused. This is the cause perhaps nine times in ten, and the fix is to search for the same model name with GGUF appended — a community re-upload almost always exists.
• The weights are gated. Some publishers, Meta’s own meta-llama repositories among them, require you to accept a licence on Hugging Face before the files are readable. That is a deliberate condition of use, and the right way through it is to accept the licence on the Hub with your own account, not to look for a route around it. Community GGUF conversions of gated models exist and carry the same licence, which still applies to you.
• The format is newer than your build. GGUF has had breaking revisions, and a brand-new architecture needs engine support that ships with an app update. A model published this week may genuinely not be loadable this week; updating the runtime is the fix, not a different quant.
• It is a component, not a model. Adapter-only repositories — a LoRA without its base — are not loadable on their own. See LoRA explained for what those actually contain.

Pulling one and running it

1. Open Discover with ctrl + 2 (or ⌘ + 2 on macOS).
2. Paste a repository path or a full Hub URL rather than searching by keyword, so that you know exactly which upload you are getting. Two repositories with similar names are frequently different conversions.
3. Pick the quantization from the list using the file size and the fit indication, not the name. If nothing is marked as fitting, take a smaller model rather than a smaller quant.
4. Start the download and let it finish. Partial downloads are resumable but a partially written GGUF that is later treated as complete is a reliable way to get a load failure that looks like corruption, because that is what it is.
5. Load it and send it something, from the CLI so the result does not depend on the interface:

   lms ls
   lms load <model-key> --gpu max
   lms ps

6. Confirm it answers over HTTP, which is the check that matters if anything else is going to call it:

   lms server start
   curl -s http://localhost:1234/v1/models

The same thing from the CLI

Everything above has a command-line form, which is what you want on a machine you are configuring rather than using. Per its documentation, lms get searches and downloads models from online repositories, and takes a quantization directly with an @ suffix:

# search interactively
lms get llama-3.1-8b

# take a specific quantization without being asked
lms get llama-3.1-8b@q4_k_m

# restrict the search to one format
lms get --gguf
lms get --mlx

The --gguf and --mlx flags are documented as including only that format in results, which is the explicit version of the filtering the graphical search does silently. On a machine that is not Apple Silicon, --gguf is what you want and saves you scrolling past MLX builds you cannot run.

Two further flags are worth knowing: -a, --always-show-download-options forces the quantization prompt even when the name matched exactly, and --always-show-all-results forces the selection prompt rather than taking an exact match. Both exist because the default is to be helpful, and being helpful is the wrong behaviour in a script.

When the download has to happen elsewhere

Sometimes the machine that runs the model is not the machine that can reach the Hub — an air-gapped host, a locked-down network, or simply a file you already have on an external drive and do not want to fetch twice.

lms import is the documented command for adding a model file into LM Studio, and it is the supported alternative to dropping a GGUF into the models directory by hand and hoping the index notices. Copying files in manually mostly works and occasionally does not, because the app maintains its own record of what it has; using the import path means that record is updated with the file.

Note that a sideloaded GGUF carries its own metadata, including its chat template if the person who converted it included one. When a sideloaded model produces rambling output that will not stop, a missing or wrong template is the first thing to suspect rather than the quant — the same failure mode described in the TEMPLATE field in an Ollama Modelfile, which is the same problem in a different runtime. For the wider offline case, see air-gapped AI.