Accueil›Guides›MLX vs GGUF sur Mac : 7 modèles mesurés, ce que choisit Ollama et lequel télécharger

Choisir · Guide

MLX vs GGUF sur Mac : 7 modèles mesurés, ce que choisit Ollama et lequel télécharger

Sur un Mac Apple Silicon, prenez MLX avec mlx-lm ou le moteur MLX de LM Studio : sur 6 des 7 modèles mesurés, le MLX 4 bits pèse 4 à 8 % de moins que le GGUF Q4_K_M. Prenez GGUF pour llama.cpp, pour un autre ordinateur ou pour plus de niveaux de compression. Ollama choisit pour vous.

Mesuré et rédigé par Local AI ScopePublié le Chiffres mesurés par Local AI Scope

Sur un Mac Apple Silicon, prenez MLX avec mlx-lm ou le moteur MLX de LM Studio : sur 6 des 7 modèles mesurés, le MLX 4 bits pèse 4 à 8 % de moins que le GGUF Q4_K_M. Prenez GGUF pour llama.cpp, pour un autre ordinateur ou pour plus de niveaux de compression. Ollama choisit pour vous.

Cette dernière phrase cache la découverte la plus curieuse de cette page, et nous y viendrons. D’abord, la méthode. Le 27 octobre 2026, nous avons mesuré sur Hugging Face la taille réelle des mêmes 7 modèles dans les deux formats, lu le code d’Ollama 0.40.11 là où il décide quel fichier votre Mac télécharge, et demandé 9 modèles à son catalogue exactement comme Ollama les demande. Les versions ce jour-là : mlx-lm 0.32.2 avec mlx 0.32.4, llama.cpp v0.7.0, Ollama 0.40.11 et LM Studio 0.4.26. Ce que nous n’avons pas fait, c’est chronométrer MLX contre llama.cpp sur un Mac à nous : vous ne trouverez donc pas ici de vainqueur en vitesse, et nous expliquons pourquoi plus bas.

MLX (mlx-lm)MLX (mlx-lm)Fiche logiciel llama.cppllama.cppFiche logiciel
MLX GGUF
Ce que c’est Le framework d’apprentissage automatique d’Apple et son format de modèle : un dossier avec config.json, le tokeniseur et les poids en fichiers safetensors Le format créé par llama.cpp : 1 fichier avec les poids, le tokeniseur et les réglages (les gros modèles arrivent découpés en parties)
Où il tourne Mac Apple Silicon sous macOS 14 ou plus récent ; sous Linux, avec CUDA ou le processeur seul via des paquets supplémentaires Windows, macOS (processeur seul sur les Mac Intel), Linux et Android
Programmes qui l’exécutent mlx-lm, le moteur MLX de LM Studio et Ollama sur Apple Silicon llama.cpp, LM Studio et Ollama ; pas mlx-lm
Versions au 27 octobre 2026 mlx-lm 0.32.2, mlx 0.32.4 llama.cpp v0.7.0 (compilation b11669)
Niveaux de compression 2, 3, 4, 5, 6 ou 8 bits, plus mxfp4, nvfp4 et mxfp8, des recettes mixtes et des versions DWQ 25 fichiers pour Qwen3 8B dans un seul dépôt, de IQ1_S à Q8_0 et BF16
Le même modèle en 4 bits (Qwen3 Coder 30B) 16,00 Gio, 4,50 bits par poids 17,28 Gio en Q4_K_M, 4,86 bits par poids
Modèles qui comprennent les images La partie image voyage dans le même dossier Un fichier mmproj à part, 0,87 Gio pour Qwen3.6 27B
Dans Ollama 0.40.11 Téléchargé par un Mac Apple Silicon quand l’étiquette a une version MLX Téléchargé partout ailleurs, et sur Mac quand l’étiquette n’a pas de version MLX
Faire le vôtre mlx_lm.convert -q à partir des poids d’origine Le script convert_hf_to_gguf.py du dépôt de llama.cpp, puis son outil de quantification
Serveur local mlx_lm.server sur 127.0.0.1:8080 llama serve sur 127.0.0.1:9931
Vitesse Pas mesurée par nous Pas mesurée par nous

2 formats et 4 programmes : qui lit quoi

La comparaison s’embrouille parce que MLX désigne 2 choses à la fois. C’est le framework d’Apple, la couche de calcul qui travaille sur la puce graphique du Mac en profitant de sa mémoire unifiée, et c’est aussi le nom qu’on donne aux modèles convertis pour lui. GGUF n’est qu’un format de fichier, celui qu’a inventé llama.cpp, et les 3 programmes de cette page qui le lisent embarquent llama.cpp.

Sur un Mac, 4 programmes se partagent la lecture, et chacun choisit son camp :

  • mlx-lm exécute MLX et rien d’autre. Il charge un dossier avec config.json et des fichiers model*.safetensors ; un *.gguf ne figure même pas dans la liste des fichiers qu’il télécharge. Il sait exporter un modèle en GGUF, mais seulement les modèles de type Mistral, Mixtral et Llama en fp16.
  • llama.cpp exécute GGUF et rien d’autre, sur la puce graphique du Mac via Metal. Un modèle en safetensors doit d’abord être converti.
  • LM Studio exécute les deux. Sa recherche affiche GGUF et MLX côte à côte ; le GGUF part vers son moteur llama.cpp et le MLX vers son propre moteur MLX, open source sous licence MIT.
  • Ollama exécute aussi les deux, mais choisit à votre place : sur un Mac Apple Silicon, il télécharge la version MLX d’un modèle quand elle existe, sinon la version GGUF.
LM StudioLM StudioFiche logiciel OllamaOllamaFiche logiciel
MLX exécutant un modèle de langage dans le terminal d’un Mac (session WWDC25)
mlx_lm.chat dans le terminal d’un Mac, pendant la session d’Apple sur MLX à la WWDC25 : mlx-lm lit des dossiers MLX et aucun GGUF Image extraite de la vidéo officielle · Apple

« MLX ou GGUF ? », ce sont donc en réalité 2 questions : quel fichier, et quel programme va l’exécuter. Si le programme est llama.cpp, la réponse est GGUF et la page s’arrête là. Le plus amusant commence avec les 3 autres.

Même modèle, 2 tailles : ce que nous avons mesuré sur 7 modèles

Nous avons pris 7 modèles qui existent dans les deux formats et additionné les octets de tous leurs fichiers de poids sur Hugging Face le 27 octobre 2026 : la version MLX 4 bits de l’organisation mlx-community face au GGUF Q4_K_M des dépôts qu’utilise déjà notre trouveur de modèle, pour que les chiffres puissent être recoupés avec lui.

Modèle MLX 4 bits GGUF Q4_K_M Écart
Qwen3 8B 4,29 Gio 4,68 Gio −0,39 Gio (−8,4 %)
Qwen3.5 9B* 5,54 Gio 5,29 Gio +0,25 Gio (+4,7 %)
Gemma 4 12B 6,28 Gio 6,63 Gio −0,35 Gio (−5,3 %)
gpt-oss-20b 10,41 Gio 10,83 Gio −0,42 Gio (−3,8 %)
Qwen3.6 27B* 14,95 Gio 15,66 Gio −0,71 Gio (−4,5 %)
Qwen3 Coder 30B A3B 16,00 Gio 17,28 Gio −1,28 Gio (−7,4 %)
Qwen3.6 35B A3B* 19,00 Gio 20,61 Gio −1,61 Gio (−7,8 %)

Mesuré : taille des fichiers de poids sur Hugging Face le 27 octobre 2026, en Gio (l’unité de notre trouveur de modèle). MLX : mlx-community, versions 4 bits (affine, groupes de 64 ; pour gpt-oss-20b, sa version MXFP4-Q4). GGUF : unsloth, Q4_K_M (UD-Q4_K_M pour Qwen3.6 35B A3B, le fichier que compte notre catalogue). *Le dossier MLX de ces 3 modèles inclut la partie qui lit les images ; en GGUF, c’est un fichier à part de 0,84 à 0,87 Gio, utile seulement pour les images. Le dossier MLX de Gemma 4 12B embarque aussi une petite partie image et audio ; son fichier image GGUF séparé pèse 0,16 Gio.

MLX sort plus léger dans 6 cas sur 7, de 0,35 à 1,61 Gio. L’intrus, Qwen3.5 9B, ne fait pas exception à la règle : son dossier MLX embarque le lecteur d’images, et dès qu’on ajoute au GGUF son fichier image séparé (0,86 Gio), MLX redevient plus léger, de 9,9 %.

Lequel répond le mieux « en 4 bits » ? Q4_K_M dépense plus de bits, mais ce que cela change dans les réponses, nous ne l’avons pas mesuré, et la taille d’un fichier ne le dit pas. Ce que nous pouvons vous dire, c’est que les 2 étiquettes, « 4-bit » et « Q4 », ne décrivent pas la même chose.

Ce qui tient dans votre Mac : le même calcul, avec MLX presque toujours du côté sûr

Notre trouveur de modèle et nos fiches matériel additionnent le fichier GGUF Q4_K_M, la mémoire du contexte pour la longueur choisie et une marge pour le programme, et mettent de côté 3 Gio de mémoire unifiée pour macOS et vos applications ouvertes. Ces tailles sont celles du GGUF. Dans 6 des 7 modèles ci-dessus, la version MLX 4 bits pesait moins : pour ceux-là, le calcul du trouveur reste du côté sûr pour ce qui est du fichier ; Qwen3.5 9B, avec son lecteur d’images intégré, pèse 0,25 Gio de plus en MLX. Pour un modèle que nous n’avons pas mesuré dans les deux formats, vérifiez la taille des fichiers MLX avant de vous fier au calcul fait sur le GGUF.

Le contexte coûte la même chose des deux côtés. mlx-lm garde son cache de contexte en pleine précision, sauf si vous demandez --kv-bits, et llama.cpp le garde sur 16 bits par défaut : la mémoire que prend une longue conversation dépend du modèle et de la longueur, pas du format.

Puces Apple M4, M4 Pro et M4 Max
Les puces M4, M4 Pro et M4 Max d’Apple : processeur et partie graphique partagent une seule mémoire, donc les poids d’un modèle et son contexte puisent dans la même réserve que vos applications Image : Apple

Il y a un piège propre à MLX. mlx-lm demande à macOS combien de mémoire il recommande pour la puce graphique et en verrouille jusqu’à cette quantité, et sur un Mac de 16 Go cette recommandation reste bien en dessous des 13 Gio que nos fiches laissent au modèle. Quand les poids dépassent 90 % de ce chiffre, mlx-lm vous prévient avant le premier jeton ; au-delà, tout ralentit ou plante. Les chiffres réels d’un Mac de 16 Go, l’avertissement et la façon de relever ce plafond sont dans notre guide des erreurs de MLX. Et si vous préférez mesurer plutôt que calculer, mlx_lm.generate affiche Peak memory (en Go de 10^9 octets) après chaque réponse : ce que le modèle et la conversation ont réellement occupé sur votre Mac.

Ollama choisit pour vous : MLX sur Mac, GGUF partout ailleurs

Voici la découverte curieuse. Depuis la 0.40.0, une étiquette du catalogue d’Ollama peut être une liste à 2 versions : une MLX, faite de safetensors, et une GGUF. Dans le code de la 0.40.11, la fonction runnerPreferences() décide de l’ordre : sous macOS avec Apple Silicon, MLX d’abord, puis llama.cpp ; sur tous les autres systèmes, llama.cpp d’abord et MLX en dernier. Au chargement, un GGUF part vers le serveur de llama.cpp lui-même et un modèle MLX vers l’exécuteur MLX d’Ollama.

Nous avons demandé 9 étiquettes au catalogue d’Ollama avec la même requête qu’Ollama envoie, celle qui accepte une liste. 6 sont revenues avec 2 versions, et voici ce que télécharge chaque machine :

Étiquette Mac Apple Silicon (MLX) Windows, Linux, Mac Intel (GGUF)
qwen3.5:9b 7,11 Gio 6,10 Gio
gemma4:e4b 8,81 Gio 6,13 Gio
gemma4:12b 7,18 Gio 7,47 Gio
qwen3.6:27b 17,49 Gio 16,55 Gio
qwen3.6:35b 21,98 Gio 21,07 Gio
flint:latest 21,03 Gio 21,29 Gio

Mesuré : somme des couches de chaque version dans le registre d’Ollama le 27 octobre 2026, parties image et d’appoint comprises. Les 3 autres étiquettes demandées, qwen3:8b, gpt-oss:20b et qwen3-coder:30b, n’ont qu’une version GGUF, le même fichier sur toutes les machines.

Regardez bien : dans 4 cas sur 6, le Mac télécharge le fichier le plus gros, jusqu’à 2,68 Gio de plus pour gemma4:e4b. La raison : les versions MLX d’Ollama ne sont pas les versions 4 bits de mlx-community de la section précédente. La plupart sont produites avec l’outil ModelOpt de NVIDIA en NVFP4, un format 4 bits propre à NVIDIA, et certaines gardent des parties du modèle sur 8 bits ou plus ; la version MLX de Flint utilise de simples entiers sur 4 bits. « MLX est plus léger » vaut donc pour les fichiers que vous choisissez vous-même, pas pour ce qu’Ollama choisit à votre place.

Logo d’Ollama
Logo d’Ollama. Son code est sous licence MIT, c’est ce qui nous a permis de lire quelle version télécharge un Mac et laquelle reçoivent les autres machines Logo : Ollama

Les étiquettes à une seule version GGUF tournent aussi sur Mac : Ollama les confie à llama.cpp, qui utilise la puce graphique via Metal. Ce n’est pas vous qui choisissez le moteur ; c’est l’étiquette. Le moteur MLX d’Ollama est son propre code, pas mlx-lm, et notre comparatif MLX vs Ollama vérifie quels modèles connaît chacun des deux.

Niveaux de compression : 25 fichiers GGUF contre une poignée de versions MLX

Ici, GGUF gagne sur le choix. Pour Qwen3 8B, un seul dépôt GGUF propose 25 fichiers : les i-quants de IQ1_S à IQ4_NL, les k-quants de Q2_K à Q6_K, Q4_1, Q8_0 et BF16, plus des versions mixtes « XL ». Cette échelle très fine permet de caser un modèle dans la mémoire exacte dont vous disposez, un barreau à la fois. Le poids de chaque barreau, sa vitesse d’écriture et son écart avec l’original, nous les avons mesurés dans notre guide de la quantification GGUF : sur Qwen2.5 1.5B, Q4_K_M a fait le même premier choix que le modèle non quantifié pour 89 % des tokens.

Côté MLX, l’organisation mlx-community propose Qwen3 8B en 3, 4, 6 et 8 bits et en bf16, plus quelques versions 4 bits spéciales : AWQ et DWQ. DWQ est l’astuce maison de mlx-lm : on entraîne un modèle déjà compressé à imiter l’original, si bien qu’il garde la taille du 4 bits tout en essayant de regagner une partie de ce que la compression a enlevé. Combien il regagne, nous ne l’avons pas mesuré.

Convertir un modèle vous-même est plus simple en MLX. 1 commande télécharge les poids d’origine et les compresse :

mlx_lm.convert --model Qwen/Qwen3-8B -q

Seul, -q signifie 4 bits par groupes de 64, en mode affine ; --q-bits change le nombre de bits, --q-mode accepte mxfp4, nvfp4 et mxfp8, et --quant-predicate prend 4 recettes mixtes, de mixed_2_6 à mixed_4_6. Pour GGUF, vous passez le script convert_hf_to_gguf.py du dépôt de llama.cpp, puis son outil de quantification. Dans les deux cas, vous téléchargez d’abord les poids d’origine : environ 15 Gio pour un modèle 8B en BF16.

Si vous préférez voir avant de faire, la session d’Apple sur les grands modèles de langage avec MLX montre mlx-lm en train de générer du texte et, dans son chapitre sur la quantification, ce même mlx_lm.convert. Elle a été enregistrée avec un mlx-lm plus ancien : là où ses options et cette page diffèrent, cette page suit la 0.32.2.

S’ouvre sur YouTube (sans cookies) seulement si vous appuyez. Plus de vidéos sur sa fiche →

Vitesse : pourquoi cette page ne désigne pas de vainqueur

Nous aimerions beaucoup vous donner un chiffre ici, et nous n’allons pas l’inventer. Nous n’avons pas mesuré MLX contre llama.cpp sur un Mac à nous, et un chiffre de vitesse n’a de sens qu’avec la machine, le modèle, la compression, le contexte et les 2 versions écrits à côté. Les deux tournent sur la même puce graphique et avec la même mémoire, et MLX est le framework qu’Apple conçoit pour ses propres puces ; c’est une raison de l’essayer, pas une mesure.

La bonne nouvelle, c’est que vous pouvez trancher sur votre propre Mac en 2 exécutions. mlx_lm.generate affiche à chaque exécution les jetons par seconde pour la lecture de la question et pour l’écriture de la réponse ; donnez à llama.cpp le même modèle en GGUF et la même question, et croyez votre machine plutôt que n’importe quel graphique, le nôtre compris.

Mac mini avec M6 relié à un écran
Un Mac mini avec M6 : MLX et llama.cpp travaillent tous deux sur sa puce graphique, chacun avec son propre code Metal Photo : Apple

Si vous voulez voir des moteurs côte à côte avant d’essayer, ce test fait passer 5 modèles par 3 moteurs d’inférence sur un Mac mini M6. Ses chiffres viennent de sa machine et de ses versions, qui ne sont pas celles de cette page.

S’ouvre sur YouTube (sans cookies) seulement si vous appuyez. Plus de vidéos sur sa fiche →

Portabilité, portes ouvertes et ce que chacun envoie

Un fichier GGUF va partout : le même fichier tourne dans llama.cpp sous Windows, sous Linux, sur un Mac Intel ou sur un téléphone Android, ainsi que dans LM Studio et Ollama. Un dossier MLX est fait pour Apple Silicon. Le framework mlx existe aussi pour Linux avec CUDA ou le processeur seul, et mlx-lm y propose les extras cuda12, cuda13 et cpu, mais sous Windows pip install mlx-lm installe les outils sans le moteur. Si vos modèles vivent sur un disque partagé avec un PC, c’est GGUF qui fonctionne des deux côtés.

Le format lui-même n’écoute personne et n’envoie rien : c’est le programme qui le fait. Chacun ouvre une porte différente sur votre machine, et d’origine, toutes uniquement sur la machine elle-même :

  • mlx-lm : mlx_lm.server sur 127.0.0.1:8080, sans clé et avec un CORS ouvert à n’importe quelle page web. De lui-même, il ne passe aucun appel ; la bibliothèque Hugging Face qui lui sert à télécharger demande à huggingface.co si un modèle a changé chaque fois que vous le chargez par son nom, jusqu’à ce que vous définissiez HF_HUB_OFFLINE=1.
  • llama.cpp : 127.0.0.1:9931 depuis la v0.7.0, sans clé sauf si vous ajoutez --api-key, CORS ouvert à n’importe quelle page web, et rien d’envoyé de lui-même.
  • LM Studio : son serveur sur 127.0.0.1:1234, avec le CORS désactivé par défaut. Selon son éditeur, l’application vérifie les mises à jour et ses moteurs se mettent à jour tout seuls ; son code est fermé, c’est donc tout ce qu’on peut en dire de l’extérieur.
  • Ollama : 127.0.0.1:11434, CORS ouvert seulement aux pages de localhost, 127.0.0.1 et 0.0.0.0. Avec ollama serve seul, 2 types d’appel vers ollama.com, que OLLAMA_NO_CLOUD=1 coupe ; avec l’application de bureau, 4.
Logo de llama.cpp
llama.cpp, le moteur open source qui a créé GGUF : le même fichier tourne sur un Mac, sur un PC sous Windows ou Linux, et dans LM Studio et Ollama Logo : ggml-org / llama.cpp

Chaque destination, avec sa source et sa date, figure sur nos pages consacrées à MLX, llama.cpp, LM Studio et Ollama.

Ce que nous téléchargerions, selon votre profil

  • Un Mac Apple Silicon et une fenêtre pour discuter : LM Studio, avec les versions MLX quand elles existent. Vous avez en général le fichier le plus léger, et le GGUF est à 1 clic quand un modèle n’a pas de version MLX.
  • Un Mac et le terminal : mlx-lm avec les versions 4 bits de mlx-community ; notre guide d’installation de MLX vous mène de l’installation au serveur.
  • Un Mac avec Ollama : laissez-le choisir, mais comptez le téléchargement : sur 4 des 6 étiquettes que nous avons mesurées, sa version MLX est la plus grosse.
  • Les mêmes modèles sur un Mac et un PC, ou un Mac Intel : GGUF, avec llama.cpp, LM Studio ou Ollama.
  • Peu de mémoire, et le modèle doit tenir au gigaoctet près : GGUF, pour son échelle de 25 fichiers.
  • Vos propres compressions ou un affinage sur le Mac : MLX, avec mlx_lm.convert et son DWQ.

Si quelque chose coince en route, nous avons des guides pour quand MLX ne fonctionne pas et quand llama.cpp ne fonctionne pas. Vous hésitez entre les programmes plutôt qu’entre les fichiers ? Nos comparatifs LM Studio vs Ollama et llama.cpp vs Ollama les mettent face à face, et le trouveur de modèle vous dit quels modèles tiennent dans votre Mac. Si le choix se joue entre mlx-lm et llama.cpp eux-mêmes, notre comparatif MLX vs llama.cpp compte lesquels de nos 27 modèles chaque moteur connaît.