MLX Community Projects

[awni]

Let's collect some cool MLX integrations and community lead projects here for visibility!

If you have a project you would like to feature, leave a comment, and we will add it. If the project is build with MLX Swift, add it to the MLX Swift Community Project page.

Text Generation

• mlx-ui: A simple UI / Web / Frontend for MLX mlx-lm using Streamlit.
• mlx-moe: Scripts to create your own moe models using mlx
• mlx-rag: Explore a simple example of utilizing MLX for RAG application running locally on your Apple Silicon device.
• mlx-rag-gguf Minimal, clean code implementation of RAG with mlx using gguf model weights
• mlx-llm: LLM applications running on Apple Silicon thanks to mlx from Apple
• outlines-mlx: A fast minimalistic implementation of guided generation on Apple Silicon using Outlines and MLX
• mlx-whatsapp: An mlx project to train a base model on your whatsapp chats using (Q)Lora finetuning
• iClone: Clone your friends with iMessage and MLX
• autogram: Grammar checker with a keyboard shortcut for Ollama and Apple MLX with Automator on macOS.
• mamba.py: A simple Mamba implementation in PyTorch and MLX.
• nanoGPT_mlx: Port of Andrej Karpathy's nanoGPT to Apple MLX framework.
• mlx-tuning-fork: Very basic framework for parameterized large language model (Q)LoRa fine-tuning using mlx, mlx_lm, and OgbujiPT. Architecture for systematic running of easily parameterized fine-tunes
• mlx-moe-models: A lightweight package for extending the mlx-lm to support custom moe models
• chat-with-mlx: Chat with your data natively on Apple Silicon using MLX Framework.
• transformerlab-app: A research platform to run, train, RAG, and evaluate LLMs through a GUI.
• mlx-transformers: Model implementations in MLX with a similar interface as Hugging Face Transformers.
• plpxsk/bert-qa: Fine tune BERT model for Q&A on MacBook.
• VimLM A local LLM-powered Copilot for Vim—offline, private, and fully integrated into your workflow.
• Toolio: JSON schema-steered structured output (3SO) and tool-calling for MLX
• mlx-lm-lora: Train Large Language Models in MLX.
• mlx-lm-lens: Find the hidden meaning of LLMs

Vision

• ml-aim: AIM: Autoregressive Image Models
• mimm: MLX Image Models
• mlx-image: MLX image models for Apple Silicon machines
• aggressor: A simplest possible implementation of Autoregressive Image Generation without Vector Quantization in Apple MLX.
• DINO_DETR_MLX: A port of the DINO DETR model for object detection in MLX.

Speech and Audio

• mlx_bark: Port of Suno's Bark TTS transformer in Apple's MLX Framework

Multi-modal

• voice-assistant: A simple toy demo of a local voice assistant with whisper and large language model.
• Video_summarization_mlx: Transcribe and summarize youtube video using mlx
• MLX-VLM: Run Vision LLMs locally on your Mac using MLX.
• e2tts-mlx: A single-file implementation of Embarrassingly Easy Fully Non-Autoregressive Zero-Shot TTS model in MLX.
• whisper-turbo-mlx: A blazing fast single-file implementation of the OpenAI's Whisper Turbo (all in less than 250 lines of code).
• NotebookMLX: A port of NotebookLlama to MLX. Generate podcasts fully on device.

Misc

• mlx-omni-server: MLX Omni Server is a local inference server powered by Apple's MLX.
• mlx-optimizers: Seamlessly experiment with and adopt new optimization algorithms into your MLX workflow!
• mlx-graphs: Graph Neural Network library made for Apple Silicon
• flower: Flower: A Friendly Federated Learning Framework
• samplex: Package of useful sampling algorithms written in MLX.
• rlx: A reinforcement learning framework based on MLX.
• mlx3D: A library for deep learning with 3D data using MLX.
• mlx-ctrc: CTC loss in MLX on the CPU and GPU.
• mlx-hub: A command-line tool to search, download & manage MLX AI models on macOS.
• mlx-lm-kan: Kolmogorov–Arnold Networks (KAN) in MLX.

Educational

• Deep-Dive-Into-AI-With-MLX-PyTorch: "Deep Dive into AI with MLX and PyTorch" is an educational initiative designed to help anyone interested in AI, specifically in machine learning and deep learning, using Apple's MLX and Meta's PyTorch frameworks.
• cv-ml-lecture-notebooks: Computer Vision and Machine Learning Jupyter Notebooks for Educational Purposes
• mlx-micrograd: MLX port of micrograd - a tiny scalar-valued autograd engine with a small PyTorch-like neural network library on top.

• pikaGPT: A tiny implementation of a GPT, accelerated for Apple Silicon, built on picoGPT.

[chimezie]

Text generation: mlx-tuning-fork

[mzbac]

text generation: https://github.com/mzbac/mlx-moe-models
A lightweight package for extending the mlx-lm to support custom moe models

[noahfarr]

An implementation of Reinforcement Learning algorithms in MLX based in the Implementations from CleanRL. Still WIP because it’s missing a benchmark and some other minor things, but the implementations work correctly.
https://github.com/noahfarr/rlx

[RahulBhalley]

mlx-models. Currently supporting vision models by loading/converting from PyTorch checkpoints. Will later add support for text and audio models as well.

[awni]

Could you share a bit more about what it does?

[qnguyen3]

Hi I would love to add chat-with-mlx. It is a Chat UI + RAG Implementation on MLX. I wIll add more features later on (more advanced RAG pipeline + multimodal)

[adi-dhulipala]

I have an example of training a simple language model using BitLinear instead of nn.Linear. It's a port of Karpathy's minGPT to MLX along with a custom implementation of a BitLinear module. https://github.com/adhulipa/mlx-mingpt

I noticed this collection already has the far more meatier nanoGPT version ported to mlx, which is awesome! MinGPT, OTOH, is super simple, easy to follow and can serve as a reference example for folks looking to compare mlx equivalent operations from the original PyTorch implementation.

[aliasaria]

Transformer Lab https://github.com/transformerlab/transformerlab-app is an LLM research platform that allows you to run, train, perform RAG, and evaluate LLMs through a GUI.

[Jaykef]

MLX RAG with GGUF Models: https://github.com/Jaykef/mlx-rag-gguf

The code here builds on https://github.com/vegaluisjose/mlx-rag, it has been optimized to support RAG-based inferencing for .gguf models. I am using BAAI/bge-small-en for the embedding model, TinyLlama-1.1B-Chat-v1.0-GGUF as base model and the custom vector database script for indexing texts in a pdf file. Inference speeds can go up to ~413 tokens/sec for prompts and ~36 tokens/sec for generation on my 8G M2 Air.

[lin72h]

@Jaykef Very cool, thanks for sharing

[amirhossein-razlighi]

Vision: MLX3D A library for deep learning with 3D data using mlx.

[amirhossein-razlighi]

@awni
Can you please add this to the list? 🙏🏻

[lin72h]

very cool! thanks for working on the 3D support

[awni]

Done! Cool library btw!

[dc-dc-dc]

mlx-lite & mlx-onnx

[otriscon]

JSON schema decoding (allowing function calling, including an OpenAI-compatible server with tools) using MLX: https://github.com/otriscon/llm-structured-output

[Extremys]

Hello for text generation part, I'm happy to share with you that I've proposed and contributed to the integration of MLX with LibreChat.ai. So now you can use your local LLM powered by MLX through a fancy interface privately, enjoy! :D

See danny-avila/LibreChat#2580

If in the future the community proposes an API servers supporting also multimodality, transcription, image generation for example, I will add them into LibreChat ;) It could be great also to have and LLM API supporting /models endpoint and multiple models simultaneously :D

[awni]

Awesome!!

[NicoNico6]

Hello, mlx community, we are happy to share with you that we have contributed the first strong sub-4 bit LLM model zoo for MLX community.

• HF collections: https://huggingface.co/collections/GreenBitAI/greenbitai-mlx-llm-6614eb6ceb8da657c2b4ed58

The modern LLM families include Llama3/2, Phi-3, Mistral, 01-Yi, and Qwen. A mlx-style inference toolkit is also shared for the local web chatting.

• gbx-lm here: https://github.com/GreenBitAI/gbx-lm.

We are an active team here, supporting the better low-bit community on the local platform. Enjoy!

[awni]

This looks really interesting! I'm curious if there is somewhere one can learn more about how you reduce the precision of the models?

[NicoNico6]

Thanks for your interest!

The MLX models are a subset of our main work green-bit-llm.

We construct the lower-bit models by combining neural architecture search and post-training quantization technique. All models are built from a mix precision of 4/2 bit group-wise min-max quantization only (for better large-scale deployment, e.g., MLX only supports 4/2 bit min-max quantization currently). The MLX models in HF collection is the layer-mix version in the model zoo.

Except better but not harder inference, we are also interested in the low-cost fine-tuning. We released Bitorch Engine for low-bit quantized neural network operations. Our release supports full parameter fine-tuning directly in quantized space, even under extremely constrained GPU resource conditions.

We are preparing a blog in huggingface for a better understanding of everything. Please stay tuned and star us in git if you like our project QvQ.

[BuildBackBuehler]

Thanks for your interest!

The MLX models are a subset of our main work green-bit-llm.

We construct the lower-bit models by combining neural architecture search and post-training quantization technique. All models are built from a mix precision of 4/2 bit group-wise min-max quantization only (for better large-scale deployment, e.g., MLX only supports 4/2 bit min-max quantization currently). The MLX models in HF collection is the layer-mix version in the model zoo.

Except better but not harder inference, we are also interested in the low-cost fine-tuning. We released Bitorch Engine for low-bit quantized neural network operations. Our release supports full parameter fine-tuning directly in quantized space, even under extremely constrained GPU resource conditions.

We are preparing a blog in huggingface for a better understanding of everything. Please stay tuned and star us in git if you like our project QvQ.

Heck yeah, this is truly awesome! I've been banging my head trying to get a 3-bit Omniquant model to work but this'll be so much better. I'd love to see a low-bit precision Wizard LM2-8x22B (2.2, 2.5, 3.0 range)!

It'd also be great to see some metrics versus exllama/QUIP/AQLM as far as speed/accuracy. I'm (trying) to run an AQLM model right now and I believe it is still considered SotA but its about as much degradation as I'm willing to deal with. IIRC -10 to -15 (so say 78-80% Llama3 -> 65-68% accuracy).

In any case, I'll be giving your project an updoot and following it

[Jaykef]

mlx_micrograd - mlx port of Karpathy's micrograd - a tiny scalar-valued autograd engine with a small PyTorch-like neural network library on top.

Installation

pip install mlx_micrograd

Example usage

Example showing a number of possible supported operations:

from mlx_micrograd.engine import Value

a = Value(-4.0)
b = Value(2.0)
c = a + b
d = a * b + b**3
c += c + 1
c += 1 + c + (-a)
d += d * 2 + (b + a).relu()
d += 3 * d + (b - a).relu()
e = c - d
f = e**2
g = f / 2.0
g += 10.0 / f
print(f'{g.data}') # prints array(24.7041, dtype=float32), the outcome of this forward pass
g.backward()
print(f'{a.grad}') # prints array(138.834, dtype=float32), i.e. the numerical value of dg/da
print(f'{b.grad}') # prints array(645.577, dtype=float32), i.e. the numerical value of dg/db

[Jaykef]

@awni this should be under Educational.

[JosefAlbers]

mlx-code: Local Claude Code-style agent via mlx-lm

It's a local Claude Code style coding agent built on mlx-lm for Apple Silicon. The goal is to keep things extremely minimal: no frameworks, no heavy deps, just a simple tool loop around a local model.

Current features:

• CLI coding agent (mlx-code)
• Tool loop with bash + write_file
• Modular skills (~/.claude/skills/.../SKILL.md)
• Persistent project context via CLAUDE.md
• Runs fully local with Qwen via mlx-lm

This is very early / first-pass code, basically a minimal proof-of-concept to see how far a simple local agent can go.

[raullenchai]

I've been maintaining Awesome MLX — a curated list of 80+ MLX community projects, organized by category (inference, training, audio, vision, Swift, etc.) with a Quick Start guide and model recommendations by RAM size.

Anyone can add their project via a simple issue form. PRs welcome too!

[bstnxbt]

MOLA: multi-LoRA inference server for MLX. One base model stays loaded, adapters route per request, no reloads.

8 adapters on Qwen3.5-9B, M5 Max 64GB: 732 tok/s same-adapter, 555 tok/s mixed at c64 (~24% overhead). Uses mx.gather_mm for batched multi-adapter decode.

Still alpha, needs a small mlx-lm patch (script included). OpenAI-compatible API.

https://github.com/0xbstn/mola

[raspoli]

mlx-serve — OpenAI-compatible inference server that manages text, vision, embeddings, TTS, and STT models through a single endpoint, loading one at a time to stay within unified memory limits.

• Subprocess isolation — text and vision models run as separate processes. When swapped out, the OS reclaims all memory cleanly — no fragmentation over long sessions.
• Auto-unload on inactivity — configurable idle timeout frees memory when not in use. Also supports per-request keep_alive control.
• Wraps the MLX ecosystem — mlx-lm, mlx-vlm, mlx-embeddings, mlx-audio, and mlx-whisper under one server. Send a request to any configured model and it handles loading/unloading automatically.
• CLI included — mlx-serve init, start, stop, status, logs.

pip install mlx-serve[all] · PyPI · MIT licensed

Thanks to the MLX team for the foundation libraries that make this possible.

[maksimov]

Looks like the "Deep Dive Into AI With MLX PyTorch" has moved to a different location (a link you have in the top post is broken):
https://github.com/gmichel007/Deep-Dive-Into-AI-With-MLX-PyTorch

[Brooooooklyn]

mlx-node is an inference and training library that exposes Node.js APIs. It also includes an experimental WebGPU backend: https://mlx.void.app

[waleed-sh]

I would like to share a small early-beta sparse primitives package for MLX, called mlx-sparse

It is an attempt at an MLX-native sparse array package for Apple Silicon. It provides Python-facing sparse array containers, with the performance-critical parts implemented as MLX primitives using C++, CPU backends, and Metal kernels.

It is still an early beta, but I hope it can be useful for people experimenting with sparse linear algebra, graph-like workloads, scientific computing, and sparse model components in MLX. Feedback, issues, and any contributions are very welcome!

Edit: it also supports some linalg operations.

More in the docs.

[IonDen]

Two MLX diffusion tools for Apple Silicon, both drop into mflux:

• mlx-teacache: TeaCache step-skipping to speed up FLUX.1 / FLUX.2 generation.
• mlx-taef: TAESD/TAEF tiny autoencoders for fast latent previews and low-memory FLUX decode.

[matthewdcage]

llm-swarm-router — LLM server mesh router for oMLX/Ollama/LM Studio/vLLM; OpenAI + Anthropic Messages on :11400 (macOS menubar + home-lab routing): https://github.com/matthewdcage/llm-swarm-router

[Da1sypetals]

• FCPE: A fast f0 estimation for vocal audio https://github.com/Da1sypetals/fcpe-mlx
• GAME: An accurate MIDI transcription for vocal clips https://github.com/Da1sypetals/game-mlx-rs
• mlx-singing: Deep learning based SVC (singing voice conversion) https://github.com/Da1sypetals/mlx-singing

These are all meant to be runnable on personal mac mini or macbooks.

[igurss]

Benchmarking / Misc: mlx-chronos - A benchmark suite and community leaderboard for MLX inference engines on Apple Silicon, with TTFT, throughput, RAM, thermal metadata, and reproducible JSON submissions.

Leaderboard: https://igurss.github.io/mlx-chronos

[amirhossein-razlighi]

MLX Diffuser: Train from scratch, fine-tune, or run inference for diffusion & flow models - for image, video, and discrete modalities.

mlx_diffuser

[prateekiiest]

is this trainable on Apple Macbook M3/M2 for reasonable datasets and research purposes ?

[amirhossein-razlighi]

Hi. It depends on which dataset and what amount of VRAM. Can you specify this in the issues and I'll give you a specific answer.

[brickheadbs]

Hi! I'd love to have this added to the list:

• mlx-fish-speech-finetuning: A local training and fine-tuning pipeline for the Fish-Speech S2 Pro voice-cloning model on Apple Silicon. It trains both the slow-AR (semantic) and fast-AR (residual) transformers with correct causal alignment.

More details in the Show & Tell thread #3732. Thanks!

[ddalcu]

mlx-serve — native Zig inference server for Apple Silicon, no Python. Runs MLX-format models and exposes OpenAI-compatible and Anthropic-compatible HTTP APIs out of the box, so the same localhost endpoint works with Claude Code, the OpenAI SDK, Continue, Cursor, Open WebUI, etc.

Highlights:

• Arch coverage on the MLX path: Gemma 4 (+ SigLIP vision), Qwen 3.5/3.6 (MoE + GatedDeltaNet), Llama/Mistral, Nemotron-H (Mamba2 hybrid), LFM2, and DiffusionGemma
  block-diffusion generation.
• Speculative decoding: prompt-lookup (PLD), a Gemma 4 cross-attention drafter, and native multi-token-prediction (MTP) heads for Qwen 3.6 — ~1.1–2.1× decode depending on
  workload.
• KV-cache quantization (4/8-bit + TurboQuant), encoder-only /v1/embeddings, OpenAI Responses API (+ WebSocket transport), and the full Anthropic Messages API with
  streaming thinking + tool calls.
• Ships with MLX Core, a macOS menu-bar app: chat, agent mode, MCP tool calling, RAG-over-a-folder, and model management.

MIT, Apple-Silicon only. Site: ddalcu.github.io/mlx-serve

[Matth21]

atlas — measured-cost quantization for MLX: profiles per-block KL sensitivity, then solves (bit-width, group-size) allocation exactly for any RAM budget. Benchmarked vs uniform MLX and llama.cpp K-quants. https://github.com/Matth21/atlas