Open-source app lets you grow a mini LLM from scratch on a MacBook

According to the repo description, the app is still in beta. It states "LabLLM is beta software," noting that while it can train and fine-tune real models, it isn't a finished product yet. As of publication, the repo has 22 stars and 40 commits.

How to try it

Where to start — Download the GitHub repository (Greninja9257/LabLLM) and build it with Swift Package Manager on macOS 14 or later, on an Apple Silicon M1 or newer machine. The repo recommends Xcode 15 or later.

Step-by-step usage

1. Build the source with the swift build command in Terminal. This may take time on first run, since it needs to download MLX libraries.
2. Run swift run LabLLM to launch the app, which opens to a welcome screen with an animated background and a tutorial overlay.
3. In the model builder, choose one of the tiny, small, medium, or large presets, or manually adjust layers and dimensions. Parameter count and estimated memory/disk usage are displayed in real time at this stage.
4. In the data browser, search Hugging Face datasets to preview and import them, or directly import local TXT, JSON, JSONL, CSV files, or iMessage chat logs.
5. Choose a tokenizer method among character-level, byte-level, or trained BPE. In Simple mode, this is configured automatically.
6. Start pretraining from the training dashboard, where a blue training loss curve, orange validation loss curve, throughput, and live sample outputs are displayed together. Training can be paused, resumed, or stopped mid-run.
7. Save a checkpoint, then load it to rename or quantize it, and continue fine-tuning with LoRA or DPO.
8. Inspect the finished model's internals with the X-Ray token inspector, or expose it via a local server with an OpenAI-format endpoint to connect it to other tools.

Who can use it — macOS 14 or later and an M1 or newer Apple Silicon Mac are required. It reportedly does not run on Intel Macs, Windows, or Linux. It's free to use with no account signup or subscription fee, and is distributed under the MIT license.

What you can try — For example, feeding in personal iMessage chat logs to fine-tune a small model could produce a locally-run chatbot that mimics your own speaking style. Alternatively, running pretraining from scratch on domain-specific text pulled from Hugging Face lets you get hands-on with how large models actually go through the process of learning "language."

Feature overview at a glance

Area	Supported features
Model design	GPT-style decoder presets, validation, parameter/memory estimation
Data	Hugging Face browsing, local import, dataset mixing, row count/ratio adjustment
Training	Pretraining, SFT, LoRA, DPO, live metrics, checkpoints, pause/resume
Execution	Sampling, chat, token inspection, embeddings, local server, quantized export

Background: where MLX and on-device training meet

MLX is an open-source framework Apple built to run deep learning computations fast on its own silicon chips. Training large language models has typically been seen as a task requiring massive GPU clusters in the cloud, but MLX has opened a path to locally training relatively small models on Apple Silicon's unified memory architecture. LabLLM is a case of putting a graphical interface on top of MLX, letting users handle model design, data preparation, training, evaluation, and deployment all in one screen without writing code directly.

Editor's take

The way people work with LLMs has split into roughly two camps over the past few years. One is renting giant models built by companies like OpenAI or Anthropic through an API; the other is downloading open-weight models like Llama or Qwen and running them on your own servers. LabLLM presents a third option that fits neither camp. It lets you watch the entire process of a model learning, starting from randomly initialized weights, all on your personal laptop. This is less a practical production alternative and more of a learning lab — and indeed, "Lab" is right there in the project's name.

Plenty of people have called a large model through an API, but few have actually watched a transformer "learn language" in real time as its loss curve moves. That's largely due to the cost and setup burden of renting cloud GPU clusters. Training a tiny-sized model from scratch on a single MacBook with something like LabLLM lets you feel firsthand how sharply memory requirements spike as parameter count grows, and how erratically the loss curve behaves when data quality is poor. Without that hands-on feel, numbers like "token count" or "parameter count" stay just words in an article.

Teams preparing AI education programs or in-house workshops in Korea may want to keep an eye on tools like this. It lets you demonstrate what "a model learning" actually means using a single laptop, with no server costs and no GPU cluster approval process required. That said, it's worth being clear that this is beta-stage software, and that tiny or small-sized models are unlikely to have language capabilities good enough for real work. It's too early to expect to plug the resulting output directly into a product — this is a learning tool, not a deployment tool.

More open-source projects in this vein — local training labs — are likely to appear in the coming weeks, as Apple continues refining MLX and the scope of what can be done on-device keeps expanding each quarter. The next thing to watch is whether such tools grow beyond tiny-model exercises to the point where they can locally fine-tune models large enough to actually be useful.