MLX Quest

Tracks

1. 01🍎Foundations — Why MLX Exists

   0/6 lessons

   Apple Silicon, unified memory, and the gap MLX was built to fill

   Before any code, the hardware. MLX is not just another array library — it's a framework written by people who refused to translate CUDA's worldview onto a chip that doesn't have separate GPU memory in the first place. This track is the architectural why: what Apple Silicon actually is, why unified memory rewrites the rules, which Macs you can do this on, and how MLX honestly stacks up against PyTorch MPS and CoreML.

   Lesson list (6)

   • 01
     What MLX Actually Is~14 min · mlx, introduction, philosophy
   • 02
     Unified Memory: Why Apple Built a New Array Library~16 min · unified-memory, apple-silicon, metal
   • 03
     Which Macs Earn the MLX Stripes~10 min · hardware, apple-silicon, macos
   • 04
     Why 192 GB (and 512 GB) Changes the Conversation~12 min · large-models, memory, on-device
   • 05
     MLX vs PyTorch MPS vs CoreML — The Three-Way Honest Comparison~16 min · comparison, pytorch-mps, coreml
   • 06
     The MLX Community in 2026 — Where the Real Code Lives~10 min · community, ecosystem, github

   ✓Quiz · 4 questions→

2. 02⚡MLX Core — Installation Through nn.Module

   0/7 lessons

   Arrays, lazy evaluation, function transforms, and a working tiny network

   Where you stop reading about MLX and start using it. Install cleanly (the Rosetta trap is real), reach for arrays the way NumPy taught you, then catch the two reflexes that don't carry over (lazy evaluation and function transforms). By the end of this track you've built and trained a real, if tiny, network.

   Lesson list (7)

   • 01
     Installing MLX Without Hating Yourself~10 min · installation, conda, rosetta
   • 02
     Arrays, dtypes, and the Unified-Memory Difference~14 min · arrays, dtypes, unified-memory
   • 03
     NumPy Reflexes That Carry Over (and Where Things Diverge)~14 min · numpy, operations, reshape, broadcasting
   • 04
     Lazy Evaluation — The One Mental Model Shift That Matters~18 min · lazy-eval, graph, mx.eval
   • 05
     mx.grad and the Function-Transform Family~16 min · autograd, mx.grad, vmap, value-and-grad
   • 06
     nn.Module — Building the Smallest Useful Network~18 min · nn.Module, training-loop, optimizer
   • 07
     mx.compile — Kernel Fusion You Can Actually Measure~14 min · mx.compile, performance, fusion

   ✓Quiz · 4 questions→

3. 03🤖mlx-lm — Running Language Models on Your Mac

   0/7 lessons

   Load, prompt, stream, sample, serve — with the as-of-2026 stack

   mlx-lm is the package that took MLX from "interesting array library" to "why I'm running LLMs locally now." This track is the practical loop — load a model, generate text properly (streaming, stop tokens), tune sampling without superstition, handle chat templates, stand up the built-in OpenAI-compatible server, and understand what eats your RAM.

   Lesson list (7)

   • 01
     mlx-lm in Five Minutes — Load, Prompt, Done~10 min · mlx-lm, quickstart, loading
   • 02
     Generating Text — Streaming, Stopping, and Stop Tokens~14 min · generation, streaming, stop-tokens
   • 03
     Sampling Without Mythology — temperature, top-p, repetition_penalty~16 min · sampling, temperature, top-p
   • 04
     Architectures mlx-lm Already Speaks~12 min · architectures, llama, qwen, mistral
   • 05
     Chat Templates — When the Model Cares How You Wrap the Words~14 min · chat, templates, tokenizer
   • 06
     The Built-In OpenAI-Compatible Server~14 min · server, openai-compatible, api
   • 07
     Performance & Memory — What Eats Your RAM and Why~16 min · memory, kv-cache, wired-memory

   ✓Quiz · 4 questions→

4. 04🔄Conversion & Quantization

   0/6 lessons

   Hugging Face → MLX, plus the quantization choices that matter

   Most MLX models you'll actually run are converted from Hugging Face checkpoints. This track is the conversion pipeline (`mlx_lm.convert`), the quantization decisions (Q4 vs Q8 vs group-wise vs mixed-precision), where the trustworthy community uploads live, and the honest comparison with GGUF.

   Lesson list (6)

   • 01
     The MLX Model Format — safetensors + config + tokenizer~12 min · model-format, safetensors, config
   • 02
     mlx_lm.convert — Pulling a HF Model into MLX-Native Form~14 min · conversion, huggingface, convert
   • 03
     Quantization Basics — Q4, Q8, and What You're Actually Losing~16 min · quantization, q4, q8, precision
   • 04
     Group-wise & Mixed-Precision Quantization~14 min · quantization, group-size, mixed-precision
   • 05
     mlx-community on Hugging Face — Where to Pull, How to Trust~10 min · huggingface, mlx-community, trust
   • 06
     MLX-format vs GGUF — When to Pick Which~12 min · gguf, format-comparison, interop

   ✓Quiz · 4 questions→

5. 05🎯Fine-Tuning — LoRA, QLoRA, DoRA, and Shipping the Result

   0/6 lessons

   Adapter-based fine-tuning end to end

   Full-model fine-tuning is dead for almost everyone — adapters are the workflow. This track walks the whole loop — why LoRA, how to prepare data the model will actually learn from, what the training-config knobs really mean, when to graduate to QLoRA or DoRA, how to merge and serve the adapter, and a complete walkthrough you can repeat with your own dataset.

   Lesson list (6)

   • 01
     LoRA — Why You Don't Train the Whole Model Anymore~14 min · lora, adapters, peft
   • 02
     Preparing Training Data — JSONL, Templates, and Cleaning~16 min · data, jsonl, chat-template
   • 03
     Training Config — Learning Rates, Ranks, Epochs, What Each Lever Does~16 min · training, hyperparameters, lora-rank
   • 04
     QLoRA & DoRA — When Vanilla LoRA Isn't Enough~14 min · qlora, dora, advanced-fine-tuning
   • 05
     Merging the Adapter — Inference Without the LoRA Round-Trip~12 min · merging, fuse, inference
   • 06
     End-to-End Walkthrough — Fine-Tune, Merge, Serve~20 min · walkthrough, end-to-end, deployment

   ✓Quiz · 4 questions→

6. 06🎨Beyond Text — Audio, Vision, Image, Video

   0/7 lessons

   mlx-audio, mlx-vlm, image diffusion, and the experimental edge

   MLX is no longer text-only. This track is the multimodal stack as it stands in 2026 — TTS and STT via mlx-audio, vision-language models via mlx-vlm, image generation via diffusion, the volatile video/music frontier, the mlx-examples repo as a reading library, and how MLX is being wired into LangChain / LlamaIndex / friends.

   Lesson list (7)

   • 01
     mlx-audio TTS — Speaking on Apple Silicon~12 min · mlx-audio, tts, speech-synthesis
   • 02
     mlx-audio STT — Listening on Apple Silicon~12 min · mlx-audio, stt, whisper
   • 03
     mlx-vlm — Vision-Language Models in MLX~14 min · mlx-vlm, multimodal, vision
   • 04
     Image Generation — Diffusion on the Mac~14 min · diffusion, image-generation, stable-diffusion
   • 05
     Video & Music — The Newest, Most Volatile Frontier~10 min · video, music, experimental
   • 06
     mlx-examples — The Reference Library Worth Reading~12 min · mlx-examples, reading, patterns
   • 07
     Tooling Around MLX — LangChain, LlamaIndex, and Friends~10 min · langchain, llamaindex, tooling

   ✓Quiz · 4 questions→

7. 07⚖️Comparisons — MLX in the Real Ecosystem

   0/6 lessons

   MLX vs Ollama / llama.cpp / PyTorch MPS / CoreML, plus the LLM-can't-write-MLX problem

   Most lessons elsewhere in this quest are MLX-positive by necessity. This track is the calibrating opposite — what the alternatives are, what each does better, when to *not* reach for MLX, and the meta-issue that quietly ruins everyone's first MLX experience — LLM coding assistants confidently writing wrong MLX code.

   Lesson list (6)

   • 01
     MLX vs Ollama — Different Layers, Same Mac~12 min · ollama, comparison, stack-layers
   • 02
     MLX vs llama.cpp / GGUF — When CPU Roots Matter~12 min · llama-cpp, gguf, cpu-inference
   • 03
     MLX vs PyTorch MPS — Translator vs Native Speaker~14 min · pytorch-mps, comparison, performance
   • 04
     MLX vs CoreML — Research Workbench vs App-Shipping Runtime~12 min · coreml, comparison, deployment
   • 05
     The 'LLMs Write Bad MLX Code' Problem (and How I Survive It)~16 min · llm-limits, self-aware, verification
   • 06
     Honest Assessment — What MLX Is Not, As of Today~16 min · honest, limits, linalg-gap

   ✓Quiz · 4 questions→

8. 08🚀Production — Wrapping, Profiling, and the Future

   0/6 lessons

   From experiment to service, plus what's coming next

   What you do after MLX runs in a notebook. Wrap it in a real API, find your real memory ceiling, ship Swift when Python is the wrong tool, run multiple models from the same process, profile what's actually slow, then look at where MLX is heading — JACCL, the M5 Neural Accelerators, and the still-evolving CUDA backend.

   Lesson list (6)

   • 01
     Wrapping MLX Behind a FastAPI Service~16 min · fastapi, service, api
   • 02
     Memory Optimization — Where the Mac's Wall Actually Is~14 min · memory, wired-memory, vm-pressure
   • 03
     MLX Swift — When Python Isn't an Option~14 min · swift, mlx-swift, ios-app
   • 04
     Multiple Models, Batch Inference, Sharing Memory~14 min · batching, multi-model, throughput
   • 05
     Profiling MLX — Finding the Slow Op~14 min · profiling, performance, metal-trace
   • 06
     The Future of MLX — JACCL, Neural Accelerators, CUDA Backend~14 min · future, jaccl, m5, cuda

   ✓Quiz · 4 questions→