I built a native macOS app for training small language models

Greninja9257 — Sun, 16 Aug 2026 03:08:53 +0000

I've been building LabLLM, a free native macOS app for training small Transformer/LLM models from scratch using your own datasets.

The idea is simple:

What if experimenting with language models felt more like using a creative tool than setting up an ML project?

Training a language model shouldn't require duct-taping together scripts, notebooks, dashboards, checkpoint folders, and a terminal window you're afraid to close.

LabLLM gives you a visual workspace for the entire training loop:

Build a GPT-style model from random initialization
Import your own text or instruction data
Train locally using Apple Silicon + MLX
Watch training and validation loss in real time
Save and resume checkpoints
Fine-tune model behavior
Generate samples while the model trains
Chat with the model you actually trained

GitHub: https://github.com/Greninja9257/LabLLM

Releases: https://github.com/Greninja9257/LabLLM/releases

Discussions: https://github.com/Greninja9257/LabLLM/discussions

Why I made it

Most LLM tooling is designed for people who are already comfortable living in Python scripts, configuration files, terminals, and infrastructure.

That's powerful. But it makes the first experiment surprisingly expensive.

If you're curious about language models and want to answer a question like:

"What happens if I train a tiny language model on this dataset?"

you should be able to find out without first building half a research platform.

That's what LabLLM is for.

I want it to feel more like a workshop:

Bring a dataset → build a model → train it → watch it learn → inspect the result → try another idea.

It's not intended to replace production ML infrastructure. It's designed for learning, experimentation, local model development, fine-tuning, and making the training process visible.

What LabLLM can do

The app can currently:

Create GPT-style decoder models
Train models from scratch
Fine-tune on instruction and conversation data
Run LoRA fine-tuning
Run DPO preference training
Browse and import datasets
Mix datasets by row count or percentage
Monitor live training metrics
Track validation loss separately
Generate samples during training
Save and load checkpoints
Resume training
Export model cards
Chat with local models
Serve a local OpenAI-compatible HTTP endpoint
Export quantized models
Browse and manage datasets

The part I'm focusing on now: trustworthy training

At this point, I'm less interested in adding another flashy feature and more interested in making the training itself trustworthy.

A training application shouldn't just draw a nice loss curve.

If the curve goes down, you should be able to trust what that curve actually represents.

So I've been focusing on things like:

Deterministic dataset sampling
Fixed validation sets
Correct dataset windowing
Masked padding loss
Safer DPO truncation
Checkpoint metadata
Real optimizer-state resume
Tests around core ML behavior

These details aren't particularly flashy.

They're important anyway.

The goal is for LabLLM to be a tool where you can run an experiment, change one variable, run it again, and have confidence that you're actually comparing the things you think you're comparing.

Why contributors would be genuinely useful

You don't need to be an ML researcher to contribute.

There are plenty of useful areas across the project:

Swift / macOS

SwiftUI polish
Accessibility
Better onboarding
UX improvements
Crash investigation

ML / training

MLX training correctness tests
Tokenizer edge cases
LoRA and DPO invariants
Dataset processing
Checkpointing and resume behavior

Documentation

Tutorials
Starter recipes
Example datasets
Beginner-friendly explanations
Reproduction cases

If you're interested in Swift, ML tooling, local-first software, or making machine learning easier to understand, I'd love to have you involved.

Contributing guide:

https://github.com/Greninja9257/LabLLM/blob/master/CONTRIBUTING.md

The kind of app I want LabLLM to become

I want LabLLM to be the app you open when you want to learn how language models work by actually training one.

Not just reading about loss curves.

Watching one.

Not just looking at a Transformer diagram.

Building a small Transformer and experimenting with it.

Not just downloading a model.

Training something small enough to understand and personal enough to care about.

That's the experience I'm trying to build.

It's still beta

LabLLM is early software.

It can train and fine-tune real models, but it's not a polished, production-grade ML platform yet. Expect rough edges, bugs, and fairly rapid changes.

If you try it, keep backups of anything important and please report anything confusing or broken.

Those reports are incredibly valuable at this stage.

Try it, break it, improve it

If this sounds interesting:

Try the latest beta
Star the repository if you want to help more people discover it
Open an issue when something breaks
Join Discussions with ideas or questions
Send a focused pull request if you want to help build it

GitHub: https://github.com/Greninja9257/LabLLM

Latest releases: https://github.com/Greninja9257/LabLLM/releases

Contributing: https://github.com/Greninja9257/LabLLM/blob/master/CONTRIBUTING.md

Discussions: https://github.com/Greninja9257/LabLLM/discussions

If you care about making ML tools feel understandable, trustworthy, and fun to explore, I'd especially love your help.

Train a tiny model. See what happens.

DEV Community: Greninja9257