MLX and llama.cpp models on Mac: where they're stored and how to remove them

The llama.cpp models location on a Mac depends on how each model arrived. Since spring 2026, llama.cpp saves the models it downloads from Hugging Face in the shared Hugging Face cache, ~/.cache/huggingface/hub. Models it fetched from a web address or Docker Hub, and Hugging Face downloads made by older versions, are in ~/Library/Caches/llama.cpp.

MLX models go to the same Hugging Face cache. mlx-lm, the MLX team's Python package for running language models, downloads each model into a folder named after its repository, such as models--mlx-community--Qwen3-8B-4bit. Apps built on either engine, such as LM Studio, Jan and Ollama, keep their own copies in their own folders.

Nothing removes these downloads for you, and one model takes anywhere from under 1 GB to 40 GB or more. Removing a downloaded model is safe: it comes back with another download. What doesn't come back is anything you converted or trained yourself.

This post shows where each kind of model lives, how big they get, and how to remove them in Finder or in the tools themselves. For the inner layout of the shared cache, see the Hugging Face cache on a Mac.

Where llama.cpp and MLX keep models on a Mac

Both are built for developers first, and both lean on Hugging Face, where most open models are published. So most of their models end up in one shared folder, and the rest are scattered by how you got them.

How the model arrived	Folder	Shared with
llama.cpp, from a Hugging Face name, current versions	~/.cache/huggingface/hub	Every Hugging Face tool
llama.cpp, from a web address or Docker Hub	~/Library/Caches/llama.cpp	Nothing else
llama.cpp, from Hugging Face, before spring 2026	~/Library/Caches/llama.cpp	Nothing else
A GGUF file you downloaded yourself	Wherever you saved it, often ~/Downloads	Any app you point at it
mlx-lm and other MLX Python packages	~/.cache/huggingface/hub	Every Hugging Face tool
Mac apps built with MLX Swift	The app's choice, often a huggingface folder in Documents	Usually nothing else
LM Studio, Jan, Ollama and similar apps	Each app's own folder	Nothing else

Why llama.cpp has two folders

In March 2026, llama.cpp switched to Hugging Face's standard cache, so a model it downloads can be used by other Hugging Face tools, and the other way round. Before that, it kept every download in ~/Library/Caches/llama.cpp, the folder macOS gives programs for their caches.

Builds from late March to mid-May 2026 moved old Hugging Face downloads into the new cache once, the first time they ran. Later builds dropped that step. If you upgraded from an older build after May, your old downloads may still be in the old folder, while llama.cpp downloads the same model again into the new one.

The old folder is still in use for models fetched from a plain web address or from Docker Hub. Those were never part of the move, and llama.cpp still puts new ones there.

What's in the old llama.cpp folder

Each download is a GGUF file whose name joins the publisher, the repository and the file name with underscores. Beside it is a small .etag file, which llama.cpp uses to tell whether the file has changed online.

Hugging Face downloads from older versions also left a short file whose name starts with manifest=, recording what was downloaded for each model. A model's GGUF file, its .etag file and its manifest belong together.

Settings that move the folders

Environment variables can put both caches somewhere else. LLAMA_CACHE points llama.cpp at another folder, and since March 2026 that folder holds everything llama.cpp downloads, Hugging Face models included. HF_HOME and HF_HUB_CACHE move the Hugging Face cache for llama.cpp, mlx-lm and the other tools that read them.

None of these has a window. They're set in your shell's settings or in a script. If the folders above are empty but models still load without downloading, one of these settings is the likely reason.

How to open these folders in Finder

In Finder, choose Go › Go to Folder, type the path, such as ~/.cache/huggingface/hub, and press Return. The tilde stands for your home folder. Folders whose names start with a period are hidden, but Go to Folder opens them anyway.

To see how much a folder takes, select it and choose File › Get Info. For a model in the Hugging Face cache, select the model's whole folder: its readable file names are links, and the data sits in the blobs folder beside them.

What Storage settings shows

Choose Apple menu › System Settings, click General, then Storage. There's no category for AI models. Apple describes the Documents category as files in your home folder that aren't in other categories, with buttons for large files and downloads, so a GGUF file you saved in Downloads can show up there.

Models in the hidden caches are easier to find in Finder. Storage settings works the same way in macOS 26 Tahoe and macOS 27 Golden Gate.

The llama.cpp models location on Mac, file by file

llama.cpp runs models stored as GGUF files. A GGUF file holds a model's weights along with the settings and tokenizer it needs, so one file is usually a complete model. What lands on your disk depends on what you asked for.

What does one download bring?

Given a Hugging Face repository, llama.cpp picks one quantization, Q4_K_M unless you name another, and falls back to the first file in the repository if there's none by that name. If the repository has an mmproj file, the part that lets a model read images, llama.cpp downloads that too.

In the cache, those files appear in the repository's folder: the data in blobs, under long hashed names, and readable names in snapshots that point to it.

Why is a GGUF repository so much bigger than the download?

Publishers put many quantizations of one model in a single repository, and you need only one. Qwen's own Qwen3 8B GGUF repository holds about 32 GB of GGUF files, but llama.cpp's default download from it is the 5 GB Q4_K_M file.

File in Qwen's Qwen3 8B GGUF repository	What it is	Size
Qwen3-8B-Q4_K_M.gguf	4-bit, and llama.cpp's default	5.0 GB
Qwen3-8B-Q5_0.gguf	5-bit	5.7 GB
Qwen3-8B-Q5_K_M.gguf	5-bit	5.9 GB
Qwen3-8B-Q6_K.gguf	6-bit	6.7 GB
Qwen3-8B-Q8_0.gguf	8-bit, close to the original	8.7 GB

Each file you try is a complete copy of the model. If you compared two or three quantizations, the cache keeps all of them until you remove them. A tool that downloads a whole repository, rather than one file, fetches every quantization: here, all 32 GB.

What are split files and mmproj files?

Very large models come in numbered parts, with names ending in something like -00001-of-00006. llama.cpp needs every part to load the model, so the parts stay and go together.

An mmproj file is a vision add-on. For Gemma 3 4B, it's 0.85 GB beside a 2.5 GB Q4_K_M model. If you only ever send text, llama.cpp has an option to skip it, which saves the download.

GGUF files you downloaded yourself

A GGUF file you downloaded in a browser, or made with llama.cpp's own conversion and quantization tools, is wherever you put it, often Downloads. llama.cpp doesn't track these files, so they stay until you remove them like any other file.

Files you made yourself, such as a quantization of a model you fine-tuned, may not exist anywhere else. Keep a copy before you remove them.

How big MLX and GGUF models are

A model's size depends mostly on how many parameters it has and how many bits store each one. Here are real download sizes from Hugging Face for some common models:

• Gemma 3 1B, GGUF Q4_K_M0.8 GB
• Llama 3.2 3B, MLX 4-bit1.8 GB
• Gemma 3 4B, GGUF Q4_K_M with vision3.3 GB
• Qwen3 8B, MLX 4-bit4.6 GB
• Qwen3 8B, GGUF Q4_K_M5 GB
• Qwen3 8B, MLX 8-bit8.7 GB
• gpt-oss 20B, GGUF12.1 GB
• Qwen3 8B, original 16-bit16.4 GB
• Qwen3 30B-A3B, MLX 4-bit17.2 GB
• Llama 3.3 70B, MLX 4-bit39.7 GB

Sizes of the files each model needs in its Hugging Face repository in October 2026: mlx-community for MLX, ggml-org and Qwen for GGUF and the original. Other publishers' builds differ a little.

Sizes add up quickly. An 8B model in two formats and a 30B model come to about 27 GB.

4-bit, 8-bit and 16-bit

MLX models on Hugging Face usually say their precision in the name: 4bit, 8bit or bf16. For Qwen3 8B, those are 4.6 GB, 8.7 GB and 16.4 GB. The 16-bit version is the same size as the original.

GGUF names use llama.cpp's quantization types instead, such as Q4_K_M, Q6_K and Q8_0. The number is roughly the bits per weight, so Q8_0 is about 1.7 times the size of Q4_K_M.

The same model in MLX and GGUF

At the same precision, the two formats come out close. Qwen3 8B is 4.6 GB as a 4-bit MLX model and 5.0 GB as a Q4_K_M GGUF file, and gpt-oss 20B is about 12.1 GB in either.

MLX runs only on Apple silicon, while llama.cpp runs on Intel Macs too. Apps that support both, such as LM Studio, let you choose a format for each model, which makes it easy to end up with both versions of one.

Original models in mlx-lm

mlx-lm can also load many models straight from their publishers, not only MLX conversions. Those are usually stored at 16 bits, about three and a half times the 4-bit size: Qwen's own Qwen3 8B repository is 16.4 GB.

If you've run a model by its publisher's name rather than an mlx-community name, check the cache. That one download may be the largest thing in it.

A worked example: converting a model with mlx-lm

mlx-lm's convert command makes your own MLX version of a model. To do it, it first downloads the original into the Hugging Face cache, then writes the converted model into a folder called mlx_model in the folder you ran it from.

Converting Qwen3 8B to 4 bits that way leaves the 16.4 GB original in the cache, and adds a converted model of about the size of mlx-community's, 4.6 GB. Once the converted model works, the original is the part to remove. It downloads again if you ever need to convert it a second time.

Where MLX models go

MLX is Apple's framework for machine learning on Apple silicon. It doesn't download anything by itself: the packages and apps built on it do, and where they put models depends on which one you use.

mlx-lm and the Hugging Face cache

mlx-lm downloads models through Hugging Face's own library, so they land in ~/.cache/huggingface/hub, in a folder per repository. Most MLX models come from the mlx-community organization, so their folders start with models--mlx-community--.

mlx-lm fetches only the files MLX needs: weights in safetensors files, JSON settings and tokenizer files. If another tool later downloads more from the same repository, the same folder grows.

Other MLX packages, such as mlx-vlm for models that read images, use the same cache in the same way. One model downloaded for one package is there for the others. Speech models from mlx-whisper land there too.

Folders mlx-lm makes in your projects

Some mlx-lm commands write into the folder you run them from, not the cache:

• Converting writes the new model into mlx_model.
• Fine-tuning with LoRA saves the trained adapters into adapters.
• Fusing adapters into a model writes fused_model, and exporting that to GGUF adds a 16-bit GGUF file to the same folder.

These are your own work. They don't download again, so keep the ones you still use, and back them up before you tidy the folders around them.

Mac apps built with MLX Swift

Native Mac apps that run MLX models are often built with MLX Swift, MLX's Swift version, and can download models with Hugging Face's Swift library. Each app chooses where models go. The library's default is a huggingface folder in Documents, and the MLX team's example chat app uses one in Downloads instead.

For a sandboxed app, Documents means the app's own folder in ~/Library/Containers, not your Documents folder. Either way, clearing the Hugging Face cache doesn't remove these models, because the app's copy is in its own folder.

So if you find a huggingface folder full of model files in Documents or Downloads, an app built this way most likely put it there. Delete models from inside the app where it offers that, so the app knows they're gone.

If Desktop & Documents Folders is turned on for iCloud Drive, a model in Documents is stored in iCloud too, and counts against your iCloud storage. If the app lets you choose its download folder, pick one outside Documents.

Apps that bundle llama.cpp or MLX

Many Mac apps run models with llama.cpp or MLX inside them. They don't use llama.cpp's or mlx-lm's folders. Each keeps its own models, in its own folder, and removes them in its own window.

App	Engine	Where its models live	Remove them in
LM Studio	llama.cpp, and MLX on Apple silicon	~/.lmstudio/models	My Models
Jan	llama.cpp and MLX	~/Library/Application Support/Jan/data	Settings, under Llama.cpp or MLX
Ollama	llama.cpp, and MLX builds on Apple silicon	~/.ollama/models	Ollama's command-line tool
GPT4All	llama.cpp	~/Library/Application Support/nomic.ai/GPT4All	Models, in the sidebar
Docker Model Runner	llama.cpp	~/.docker/models	Models, in Docker Desktop
A llamafile	llama.cpp	The file itself, wherever you saved it	Finder

LM Studio's folder and its quirks have a post of their own, and so does removing Ollama's models, whose files can't be removed one by one in Finder.

Jan, GPT4All and Docker Model Runner

Jan keeps llama.cpp models and MLX models in separate folders inside its data folder, llamacpp/models and mlx/models. Its Delete All button removes the models Jan downloaded and leaves the ones you imported.

GPT4All saves each model as one GGUF file in its download folder. Docker Model Runner keeps models outside Docker's disk image, and Docker deletes them permanently rather than to the Trash.

What's a llamafile?

A llamafile is a single program that contains both llama.cpp and a model's weights. It runs without installing anything, and it takes as much space as the model inside it. Remove it in Finder like any other file you downloaded.

Why the same model can be on your Mac three times

Each app downloads its own copy, even of the same file. Qwen3 8B in llama.cpp's cache, in LM Studio and in Ollama is three downloads of about 5 GB each, because none of them looks in the others' folders unless you point it there.

Before you download a model in a new app, check whether a copy you already have will do. LM Studio and Jan can import GGUF files, so one download can serve more than one app.

Leftover models after uninstalling an app

Dragging one of these apps to the Trash removes the app, not its models. The folders in the table stay until you remove them, so check them after uninstalling.

How to see which models you have

No single window lists every model on a Mac. Finder shows them all if you know where to look, and each tool can list its own.

In Finder

Open ~/.cache/huggingface/hub with Go › Go to Folder and choose View › as List. Each model is a folder named models-- plus the publisher and the repository, so models--ggml-org--gemma-3-4b-it-GGUF is Gemma 3 4B in GGUF, from ggml-org.

To see what each takes, choose View › Show View Options and turn on Calculate all sizes, then sort by size. Do the same for ~/Library/Caches/llama.cpp, and for any huggingface folder in Documents or Downloads.

Which quantizations are in a model's folder?

Open a GGUF model's models-- folder, then snapshots, then the folder inside it, named with a long hash. The files there carry readable names, such as gemma-3-4b-it-Q4_K_M.gguf, so you can see which quantizations you downloaded.

Those names are only links, which is why Finder shows them as tiny. The sizes that matter are in blobs, or in Get Info on the model's whole folder.

In the tools themselves

llama.cpp's programs have an option that lists the models in their cache. mlx-lm has a manage command that scans the Hugging Face cache for MLX models and shows each one's size and when it was last used. Both are typed in Terminal; neither has a window.

Hugging Face's own command-line tool lists everything in the shared cache, whichever tool downloaded it, with each model's size and revisions.

In llama-server's web page

llama-server, llama.cpp's built-in server, has a web page for chatting with models. Started without a model, it runs in what llama.cpp calls router mode, lists every model in its cache, and loads each one when you choose it.

Builds from October 2026 add a Models manager to that page, where you can search, sort and hide models, and delete them from disk.

How to remove llama.cpp and MLX models

Downloaded models are safe to remove, as long as you remove a whole model at a time. Finder is the gentlest route, because everything goes to the Trash first.

Move a model's folder to the Trash

1. Quit whatever is using the model: llama-server, a script that uses mlx-lm, or an app built on either.
2. In Finder, choose Go › Go to Folder, type ~/.cache/huggingface/hub and press Return.
3. Select the models-- folder of the model you no longer need and choose File › Move to Trash.
4. When you're sure, empty the Trash to get the space back.

This removes every file downloaded from that repository, every quantization and every revision, for every tool that shares the cache. The next tool that asks for the model downloads it again.

If the hub folder also has a blobs folder of its own at the top, newer Hugging Face libraries keep shared files there, and a model's folder may free little on its own. The Hugging Face cache post explains that layout and what clears it.

Can you remove one quantization in Finder?

It's possible but fiddly. The readable names in snapshots are links to hashed files in blobs, and you'd need to find and remove both. llama-server's Models manager does this cleanly for models in its cache. In Finder, the whole repository folder is the safe unit.

The old llama.cpp folder

~/Library/Caches/llama.cpp holds plain files, so Finder works well there. Move a model's GGUF file to the Trash along with its .etag file and, for an old Hugging Face download, its manifest= file. Remove every numbered part of a split model together.

If you use a current llama.cpp and everything there is an old Hugging Face download, the whole folder can go: anything you run again downloads into the new cache. Keep any file you load by its path.

llama-server's Delete from disk

In the Models manager, Delete from disk stops the model if it's running and removes its files from the cache. When the model's name includes a quantization, only that quantization's files go; otherwise the repository's whole folder does.

It deletes permanently, without the Trash. It works only on models in the cache, not on files you pointed the server at through a models folder or a preset.

mlx-lm's manage command

mlx-lm's manage command can delete models from the Hugging Face cache. It matches repositories by part of their name, shows the list with each one's size, and asks you to confirm.

Read that list carefully. Without a pattern it matches every repository with mlx in its name, and a short pattern such as Qwen matches every Qwen model you have. What it deletes skips the Trash.

Way	What it removes	Can you undo it?
A model's folder to the Trash, in Finder	Every file from that repository	Yes, until you empty the Trash
Files in the old llama.cpp folder, in Finder	The files you chose	Yes, until you empty the Trash
llama-server's Delete from disk	One quantization, or the whole repository	No
mlx-lm's manage command	Every repository matching its pattern	No
Hugging Face's own tool	What you choose, down to one revision	No
An app's own delete button	That app's copy only	Check the app

What removing a model costs

A model you downloaded comes back with another download of the same size. On a connection that downloads 100 MB a second, an 8B model takes under a minute and a 70B one about seven minutes. On slower connections it's much longer.

Models you need permission for

Some publishers make you sign in to Hugging Face and accept a license before you can download a model. Getting one of those back needs your Hugging Face account, and the access token your tool uses, set up again.

Working offline

llama.cpp has an offline option that uses only the cache, and Hugging Face's libraries have an offline setting too. Either way, a model you removed can't come back until you're online again, so keep the ones you need for travel.

What doesn't come back

• Models you converted with mlx-lm or llama.cpp's tools, unless you uploaded them somewhere.
• Adapters and fused models from fine-tuning.
• GGUF files you quantized yourself.
• Models their publisher has since removed or changed. A repository can be deleted, and a new revision may not behave like the one you had.

Uninstalling llama.cpp and MLX themselves

The programs are small next to the models. Homebrew's llama.cpp took 16 MB on one Mac in October 2026, and MLX's Metal library for macOS 26 is about a 68 MB download.

Removing the programs never removes models. Homebrew removes llama.cpp with its own uninstall command, with no window. llama.cpp's installer from its website puts a program called llama in a hidden .local/bin folder in your home folder, with a copy in a hidden .llama-app folder.

mlx-lm and MLX live in whichever Python environment you installed them in, and go when that environment goes. The models they downloaded stay in the Hugging Face cache until you remove them.

Choosing what to keep

Downloaded models aren't your own work, so the only question is whether you'll want them again soon, and how long the download takes.

A quick way to decide

If	Then
You have one model in both GGUF and MLX	Keep the format your tools use
You compared several quantizations	Keep one, usually Q4_K_M or 4-bit, unless you need more quality
You converted a model with mlx-lm	Remove the original from the cache once the conversion works
A model is in llama.cpp's cache and in an app	Keep one copy, and import it where you can
You upgraded llama.cpp from a build before spring 2026	Check the old folder for downloads it no longer uses
You converted or fine-tuned something yourself	Back it up before you remove anything near it

A worked example

Say you've spent a few weekends trying models. The Hugging Face cache holds Qwen3 8B as a Q4_K_M and a Q8_0 GGUF file, its 4-bit MLX version, and the 16.4 GB original that mlx-lm downloaded when you ran it by Qwen's own name.

LM Studio has its own Q4_K_M copy of the same model. And an old llama.cpp build left Gemma 3 4B in the old folder before a newer one downloaded it again into the new cache.

That's about 46 GB. Keep LM Studio's copy for chatting, the 4-bit MLX version for scripts and the newer Gemma download, and you keep every model you use in about 13 GB. The other 33 GB downloads again if you change your mind.

Mistakes to avoid

• Removing single files from blobs or snapshots. The model breaks, and tools that share it may download it again.
• Deleting with a broad pattern. Read the list a delete command shows before you confirm.
• Removing the whole hub folder to get rid of one model. That removes every tool's models.
• Removing a model while it's loaded. Quit the server, script or app first.
• Expecting the Hugging Face cache to hold app models. LM Studio, Jan, GPT4All and Ollama keep their own.
• Pasting cleanup commands from a web page. Nothing here needs one.

Keeping it from growing back

Name the quantization you want rather than trying several, and remove the ones you compared once you've chosen. Use one app's copy of a model where you can, and check the cache's size with Get Info every month or two.

Removing models doesn't make your Mac or the models faster. It only gives the space back.

Keeping models on another drive

HF_HOME or HF_HUB_CACHE can put the Hugging Face cache on another drive, and LLAMA_CACHE does the same for llama.cpp. They're environment variables, with no window, and they must be set every time a tool runs. Keep the drive connected whenever you use them.

The apps have their own settings for this. Where local AI tools keep models, and how each one moves, is in the guide to local AI models.

How the app does it

Wombit explains these folders like everything else on your disk. Select one in the map, the app's home screen, to see what it is, how safe it is to remove and what removing it costs, from the catalog's entries.

• ~/.cache/huggingface/hub

  Hugging Face cache

  Models and datasets downloaded from Hugging Face, shared by every library and tool that uses them.

  Review first · Moves it to the Trash

• ~/Library/Caches/llama.cpp

  llama.cpp model cache

  Model files llama.cpp downloaded from a web address or Docker Hub, and Hugging Face models saved by older versions.

  Usually safe · Moves it to the Trash

• ~/.lmstudio/models

  LM Studio models

  Language models downloaded or imported in LM Studio, in a folder for each publisher and model.

  Review first · Moves it to the Trash

• ~/Library/Application Support/Jan/data/{llamacpp,mlx}/models

  Jan models

  Language models downloaded or imported in Jan, grouped by the engine that runs them.

  Review first · Explained only: the app shows you how

• ~/Library/Application Support/nomic.ai/GPT4All/*.gguf

  GPT4All models

  Language model files downloaded in GPT4All, each stored as a .gguf file in its download folder.

  Review first · Explained only: the app shows you how

• ~/.docker/models

  Docker Model Runner models

  AI models pulled or packaged with Docker Model Runner, kept on your Mac outside Docker's disk image.

  Review first · Explained only: the app shows you how

The Hugging Face cache and the apps' model folders are Review first: models are yours to choose, so they never start checked. llama.cpp's own cache is Usually safe: everything in it comes back with a download. Neither counts in the headline number, which counts only Safe items.

Checking the Hugging Face cache in Cleanup moves the whole folder, every model in it, to the Trash after the review sheet, where you can put it back. To remove one model, use the Finder steps above. Jan, GPT4All and Docker Model Runner models are explained with the steps to remove them in those apps.

Folders no catalog entry explains, such as an MLX app's own model folder, can get a Best guess written on your Mac by Apple Intelligence and labelled as a guess. They're never offered for removal.

Seeing what your models take is free. Moving them to the Trash is PRO, one $4.99 payment with lifetime access. Every Pro tool's review is free to open, so you see what would go and why before you buy.