Fine-tune LLMs on your Mac.
Local. Private. Native.

MLX LoRA Studio turns model fine-tuning into a normal Mac app. Pick a model, choose an algorithm, watch the loss fall — all on-device, with no cloud, no Jupyter, no mystery.

MLX LoRA Studio
MLX LoRA Studio — Train tab with a live fine-tuning run
Built on
Apple MLX
Hugging Face
SwiftUI · AppKit
mlx-lm-lora
Python

Features

Everything you need to fine-tune, watch, and ship.

Nine algorithms, four adapter types, live metrics, synthetic data, and a one-click path to the Hugging Face Hub — all in one window.

🧠

9 training algorithms

SFT, DPO, CPO, ORPO, GRPO, Online DPO, XPO, RLHF Reinforce, and PPO. Pick by use case, not by which one happens to be wired up.

🧩

Every adapter type

LoRA, DoRA, QLoRA at 4/6/8-bit, full fine-tuning, and Quantization-Aware Training (QAT) for SFT, DPO, and ORPO.

📊

Live observability

Loss, learning rate, gradient norm, throughput, and a scrolling log — all streaming from the trainer, step by step.

🧪

Synthetic data

Generate prompts, SFT pairs, and DPO triples from local models, preview them in-app, and feed them straight into a training run.

🚀

One-click HF upload

Push a finished adapter to the Hub with a model card, license, and tags. No scripts, no token juggling.

🛡

ResourceGuard

Watches the OS memory pressure signals and refuses to start a job the system can't fit — with a clear human-readable reason.

🐍

Python, handled

Studio finds an existing venv that has the trainer installed, or provisions one for you. No “I forgot to install the deps” loop.

📚

Built-in algorithm guide

A reference for every supported algorithm — what it is, when to use it, and the failure modes to watch for.

🗂

Runs archive

Every run, its YAML, and its adapter are kept locally — re-run, resume, or upload them in a click from the Runs tab.

A guided tour

Seven screens. One workflow.

The app is organised around a sidebar — each section maps to a single screen in the detail pane. The whole loop lives in one window.

Train tab with a fine-tuning run in progress

01 · Train

The heart of the app.

Model & data, adapter shape, optimization, algorithm-specific fields, and resume/output — all in one form, with a live memory estimate at the bottom.

  • Pick a base model + dataset from your HF cache
  • Switch between LoRA, DoRA, QLoRA, full, QAT
  • See the projected memory cost change as you tune
Live metrics panel showing loss and learning rate

02 · Live Metrics

Watch it learn.

A second-by-second view of what the runner is doing — loss / reward / KL over the last N steps, tokens per second, and a scrolling console for when something looks off.

  • Refreshable loss / LR / grad-norm plot
  • Throughput + elapsed time at a glance
  • Pause, resume, or stop from the toolbar
Synthetic data generation screen

03 · Synthetic Data

Bootstrap your dataset with local models.

Three sub-modes, all driven by models on your Mac: prompt generation, SFT pair generation, and DPO preference generation. Preview in-app, export to JSONL, and feed it back into Train.

  • Prompts · SFT pairs · DPO triples
  • Teacher / judge models from your HF cache
  • JSONL output that any training tab accepts
Hugging Face upload screen

04 · Upload to HF

One click to the Hub.

A guided form for pushing a finished adapter to the Hugging Face Hub — repository name, visibility, license, model card fields, and token source. One Push button.

  • Public or private, with a real model card
  • Token from env, keychain, or paste
  • Step-by-step progress feed + final URL
Algorithm guide reference screen

05 · Algorithm Guide

The whole field, in plain words.

A built-in reference for all 9 supported algorithms. Each entry covers what it is, when to use it, the key hyperparameters, and the failure modes to watch for.

  • “SFT first, then DPO” ladder explained
  • What goes wrong when β is too high or group size too small
  • How QAT differs from QLoRA
Runs archive table

06 · Runs

Every run, on file.

A table of every run Studio has ever done, sorted by recency. Status, algorithm, base model, dataset, last loss, duration. Open it back into the form, resume from the adapter, upload to HF, or reveal in Finder.

  • Full YAML config for every run
  • Resume a new run from any saved adapter
  • Kept under ~/Library/Application Support/MLXLoRAStudio/runs/

Supported training methods

The whole ladder, from SFT to PPO.

All combinations are exposed in the Train tab's adapter section. Mirrored from the underlying mlx-lm-lora trainer.

Supervised fine-tuning

  • SFT Supervised fine-tuning on prompt/completion pairs

Preference

  • DPO Direct Preference Optimization
  • CPO Contrastive Preference Optimization
  • ORPO Odds Ratio Preference Optimization

RL & online

  • GRPO Grouped Reinforcement Preference Optimization
  • Online DPO Online preference updates
  • XPO Exploratory Preference Optimization
  • RLHF Reinforce REINFORCE-style reward modelling
  • PPO Proximal Policy Optimization

Adapter types

  • LoRA Low-rank adapters with configurable rank/alpha
  • DoRA Weight-decomposed LoRA
  • QLoRA Quantized base (4 / 6 / 8-bit) + LoRA
  • Full FT Train all parameters
  • QAT Quantization-Aware Training (SFT / DPO / ORPO)

Under the hood

What runs when you press Run.

A small Swift side, a small Python side, and the same trainer you can run from the CLI. They talk over a line-delimited JSON protocol — no polling, no magic.

  1. 1

    SwiftUI app

    The form is a view over a YAML config. The same config can be exported and re-run on the CLI.

  2. 2

    PythonJobRunner

    A subprocess wrapper that streams stdout line by line back to the Swift side, plus live memory monitoring.

  3. 3

    mlx-lm-lora

    The actual trainer — vendored at vendor/mlx-lm-lora/, the same code the CLI uses. MLX-native, fused-metal on Apple Silicon.

Requirements

Made for Apple Silicon Macs.

MLX LoRA Studio depends on Apple's MLX framework, which is Apple Silicon–only.

  • OS macOS 14 (Sonoma) or later
  • Chip Apple Silicon — M1 / M2 / M3 / M4 family
  • RAM 16 GB minimum · 24 GB+ recommended for ≥13B models
  • Disk ~5 GB for the app + a per-model HF cache
  • Python Bundled — system Python not required

Memory expectations

Approximate, batch_size 2, 2048-token sequences.

Base model LoRA r=16 QLoRA 4-bit Full FT
1B–3B8 GB5 GB12 GB
7B–8B14 GB7 GB32 GB
13B22 GB10 GB56 GB
70B110 GB38 GB

Install

Up and running in 60 seconds.

Option 1 — Download a release

  1. Click the Download button above — the DMG downloads directly from this site.
  2. Open the downloaded MLX-LoRA-Studio.dmg.
  3. Drag MLX LoRA Studio to /Applications.
  4. Launch it from /Applications or Spotlight.
  5. On first launch, allow the bundled Python helper in System Settings → Privacy & Security (Gatekeeper).

The first time you start a run, Studio will discover or provision a Python environment with the right dependencies — no terminal needed.

Option 2 — Build it yourself

Requires the Xcode command-line tools (Swift 5.9+, macOS 14+ SDK).

# Clone the repo
git clone https://github.com/Goekdeniz-Guelmez/MLX-LoRA-Studio.git
cd MLX-LoRA-Studio

# Build + run the app
./script/build_and_run.sh

# Build a release .dmg
./script/build_and_run.sh --package

The output .app is fully self-contained — you can copy it to another Mac and it will still run.

Fine-tune on your Mac tonight.

Open source, MIT-licensed, and built for the chip in front of you.