MLX Swift Community Projects

[awni]

Let's collect some cool MLX Swift projects here for visibility! If you have a project you would like to feature, leave a comment, and we will add it. We have a similar post for projects in Python.

Text Generation

• ChatMLX: ChatMLX is a modern, open-source, high-performance chat application for MacOS based on large language models.
• mlx-swift-chat: A multi-platform SwiftUI frontend for running local LLMs with Apple's MLX framework.
• swift-mlx-server A Swift-based server application designed to provide an OpenAI-compatible text completion API.
• MLXTinyGPT: MLX Swift implementation of Andrej Karpathy's Let's build GPT video
• mlx-chat-app: Chat with MLX is a high-performance macOS application that connects your local documents to a personalized large language model (LLM).
• fullmoon-ios: Chat with private and local large language models.
• Pico AI Server for MLX LLM VLM: Lightning fast AI server for home and office. Built on MLX, powered by the latest R1 models.

Image Generation

• flux.swift: A Swift implementation of Flux.1 using MLX Swift.
• flux.swift.cli: A CLI tool for text to image generation using the FLUX.1 model.
• flux.1.app: An app for text to image generation using the FLUX.1 model.

Audio

• f5-tts-swift: Implementation of F5-TTS in Swift using MLX.
• kokoro-ios: Kokoro TTS for iOS and macOS

[allenv0]

👋 https://github.com/mainframecomputer/fullmoon-ios

[awni]

Cool!

[ronaldmannak]

👀 https://apps.apple.com/us/app/pico-ai-server-for-mlx-llm-vlm/id6738607769?mt=12

[petrukha-ivan]

I’ve created mlx-swift-structured, a Swift library for structured output generation using constrained decoding. It ensures your model produces exactly the output you need 🚀

[N1k1tung]

iOS/macOS app supporting distributed inference for Qwen3, Llama, GLM4, OSS, LFM2: https://github.com/N1k1tung/infer-ring

[petrukha-ivan]

I'm happy to share mlx-swift-vision, a Swift library for running computer vision models. It supports various tasks and even allows running SAM 3 model on an iPhone 🙂

[davidkoski]

@petrukha-ivan looks cool! This might be of interest:

• https://github.com/ml-explore/mlx-swift/blob/main/Tests/MLXTests/MLXArray%2BInitTests.swift#L271

You can feed it directly with an IOSurface, e.g. from a video stream/camera.

[petrukha-ivan]

Thank you! This looks like a great fit for my use case. I’ll definitely try it 👍

[bstnxbt]

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

[davidkoski]

I wonder if this should be at the mlx or mlx-lm repository? It looks like this is pure python.

[bstnxbt]

my bad

[trgysvc]

PheronAgent (https://www.pheronagent.com) — a native macOS agent, entirely on MLX Swift, routing between a hardware-adaptive catalog of local models and giving the model dozens of tools to call. Closed source / commercial, so I'll keep this to one specific thing: an MLX-specific bug that took longer to track down than it should have, in case it saves someone else the time.

A vision_config gotcha that cost me a crash before I found the actual fallback logic

We wanted to add mlx-community/Qwen3.5-9B-4bit as a plain text model. Its config.json ships a full vision_config block — it's a multimodal-looking config — but the actual checkpoint has no vision tower weights at all. It's genuinely text-only; the metadata just doesn't say so.

ModelFactoryRegistry tries MLXVLM before falling back to MLXLLM. I assumed that would just fail cleanly and fall through, since there's no vision encoder to load. It doesn't. MLXVLM's Qwen35Configuration declares visionConfiguration as a non-optional property mapped to vision_config. Since the key is present in the raw config, decoding succeeds — there's nothing to catch at that stage. So MLXVLM proceeds to actually load the model as a VLM, and it crashes later, inside WiredMemoryUtils.tune(), because getRopeIndex() expects real vision-encoder dimensions to compute against, and there are none. Not a clean decode error I could catch and handle — a runtime crash several layers past config parsing, in the RoPE indexing math.

The fix ended up being config-level surgery before the model ever reaches the factory: strip vision_config (and image_token_id / video_token_id) out of the JSON first. With the key genuinely absent, Qwen35Configuration's decode now throws DecodingError.keyNotFound as intended, MLXVLM fails cleanly at the right stage, and ModelFactoryRegistry falls through to MLXLLM, whose Qwen35Model reads its params from the nested text_config and strips language_model.* prefixes on load — the correct text-only path. The one-line lesson: the fallback logic only works if the failure happens at decode time. A key that's technically present but semantically empty skips the safety net entirely and fails much further downstream, in a much less legible place.

That same lesson came back a few weeks later from the opposite direction. Evaluating a different, newly released Qwen VL checkpoint, I didn't trust vision_config's presence at all this time — I went and opened model.safetensors.index.json directly and counted actual vision_tower.* tensor names. That one had 333 of them across 27 layers; the Qwen3.5 model above has zero. Config metadata saying "this is multimodal" and a checkpoint actually being multimodal turned out to be two independent facts, and only one of them is checkable without reading the tensor index yourself.

Curious whether this specific vision_config-present-but-empty pattern shows up in other mlx-community conversions, or whether there's a more canonical way people are detecting real vision-capable checkpoints that I should be using instead of an index-file tensor scan.

[ngutech21]

I’d like to share Sumika, an open-source, local-first AI assistant and coding agent for macOS, built with SwiftUI and MLX Swift.

Sumika downloads and runs MLX models directly inside the app, without requiring Ollama, LM Studio, an API key, or a separate inference server. It can:

• chat, write, translate, summarize, and research;
• analyze local documents and images;
• write code and work with files in a selected workspace;
• run approval-aware terminal and browser tools;
• connect to local apps and services through MCP;
• transcribe speech locally and read responses aloud.
• use reusable agent skills from SKILL.md files;

Model inference, conversations, document analysis, and speech transcription stay on the Mac. Network and tool access remain explicit user choices.

Signed and notarized builds are available from the GitHub Releases page.

[pratikgx]

mlx.fast (https://mlx.fast, leaderboard at https://www.yukon.org/mlxfast)

An open benchmark arena for inference speed on Apple Silicon. Posting it here because the harness is entirely Swift and Metal: it vendors mlx-swift and mlx-swift-lm, and solvers optimize against them directly.

The current task is faster prefill and serial decode for Qwen 3.8 Flash Next with speculative decoding, scored as a single composite (prefill_gain^0.25 × decode_gain^0.75) against a sealed baseline, so a purely serial run is 1.0. Every promoted submission lands as a commit on the harness repo with a required public write-up, so the accepted Swift and Metal optimizations are all readable rather than just the scores. As of today there are 40 promoted submissions from 12 solvers, with the best run at +85.5% composite.

The harness is open source. Clone it, run locally, submit: https://github.com/Layr-Labs/mlxfast-qwen38-125b-a6b-engine

Suggested entry, with Text Generation being the closest existing category, though a benchmarks or tools group may fit better:

• mlx.fast: Faster open-model inference on Apple Silicon. An open leaderboard where you optimize prefill and decode for a fixed model and submit reproducible runs. Built on Yukon by Eigen Labs.

Also posted on the MLX Community Projects thread, so happy for it to live in just one place if you would prefer that.

[faraday]

SpeechLens: native macOS menu bar app and CLI (Swift/MLX/Metal) for universal speech enhancement with NVIDIA's RE-USE model.

You can enhance speech locally on your Mac, with practical performance (similar to NVIDIA's PyTorch reference on an L4 GPU).

Custom Metal kernels (selective scan, causal conv) run inside the MLX graph, faster than realtime on an M1 Max at 16/44.1/48 kHz. Preserves sample rate, frame count and channel layout.

Download (app + CLI): https://github.com/faraday/SpeechLens/releases/latest
MLX weights (NVIDIA non-commercial license): https://huggingface.co/faraday/re-use-mlx

[LearnedVector]

I'd like to suggest Orca One for the Audio projects list. It's a Mac app for private, on-device AI dictation and meeting transcription. Its Qwen3-ASR and Cohere transcription paths use MLX Swift; it also offers a local Parakeet/Core ML path. Requires Apple silicon and macOS 15 or later.

Disclosure: I work on Orca One.

[851026]

I'd like to suggest MLX Node (https://github.com/MLXapp/mac, Apache-2.0), a SwiftUI menu bar app for macOS that runs language-model jobs with mlx-swift-lm (MLXLLM / MLXLMCommon) when you start it or after an idle time you choose. It decodes greedily and reports a hash of the generated token ids, so the same job can be compared across different Macs. It runs in the App Sandbox with network access only.

Suggested entry, with Text Generation as the closest category: MLX Node: menu bar app that runs mlx-swift-lm jobs in a Mac's spare time for MLX Network.

Disclosure: I work on MLX Network; MLX Node earns MLX tokens, a crypto asset (risks: https://mlx.app/risks).