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.
Top comments (0)