Who marin is for#
Research teams training foundation models from scratch
Marin provides the full pipeline from raw data to trained checkpoint with provenance tracking at every step. Teams can reproduce any prior Marin experiment, build on the published Delphi scaling suite, and publish their own results in the same documented format.
Skip if:
Your goal is fine-tuning or adapting an existing model. Marin's strength is pretraining from scratch; PEFT, LoRA, or instruction-tuning workflows are not its focus.
Researchers testing new architectures or training algorithms
The Marin speedrun competition provides a structured format for testing novel approaches at a chosen compute budget, with free compute offered to top performers. The experiment preregistration system (GitHub issue, pull request, WandB report) makes it straightforward to document and publish results.
Skip if:
You need production-grade infrastructure with SLAs. Marin is a research framework that prioritizes experiment flexibility over operational stability.
Labs publishing models with full process transparency
Marin's provenance graph ties code, data, experiments, and results together. Publishing a model trained with Marin means the full trail is already documented: reviewers and collaborators can trace every decision back to the original data and training configuration.
Skip if:
You are building a proprietary model you do not intend to share. Marin's value is in its open development model; using it for a closed project captures the framework benefits but not the community or reproducibility benefits.
Developers extending Marin to non-language modalities
Marin has been used as a library to train audio-text models, DNA models, and protein models beyond standard language models. The modular experiment definition makes it possible to swap out the data source or model architecture while keeping the training infrastructure intact.
Skip if:
Your domain requires specialized hardware or software stacks not supported by Marin's defaults. Review the documentation before committing to the framework for highly specialized modeling tasks.
The problem it solves#
Training foundation models from scratch requires months of compute, careful data curation, and iterative experimentation. The harder problem is less visible: most of what gets learned along the way never gets published. Which datasets fail, which optimizer settings hurt, how architecture choices interact with data quality: that process knowledge stays locked inside institutional memory. Research teams at smaller institutions end up repeating the same mistakes that frontier labs already solved privately, because open-weight releases share the artifact but not the process.
The result is that open-weight models exist, but open-process models do not. A team starting a new pretraining run has checkpoints to study but no documented pipeline to adapt. Data curation decisions, filtering choices, and training recipes are either undisclosed or scattered across disconnected papers and blog posts with no reproducible code.
How it solves it#
End-to-end training pipeline
Covers data curation, transformation, filtering, tokenization, pretraining, posttraining, and evaluation in a single framework. Each stage is implemented as a dependency step, so the output of one step feeds directly into the next and the full pipeline is reproducible from raw data to final checkpoint.
Dependency-graph experiment definition
Experiments are defined as sets of steps with explicit dependencies, similar to a Makefile. Steps execute in topological order: tokenization finishes before training starts, training finishes before evaluation. This structure makes partial re-runs possible when only one step changes and makes the provenance of each result fully traceable.
Open development process documentation
Every experiment is preregistered as a GitHub issue with hypotheses and goals, tracked through a pull request, and summarized in a WandB report. Failed experiments are part of the record, not filtered out. The provenance graph ties raw data, code, training config, and evaluation results into a single auditable trail.
Delphi scaling suite
Delphi is Marin's open scaling suite that maps compute budgets to model configurations and validates scaling laws from 3e18 to 1e23 FLOPs. Smaller Delphi models predict the behavior of larger ones. Checkpoints, training mixture pipelines, and recipe code are released on Hugging Face at marin-community/delphi.
Speedrun competition for architecture research
The Marin speedrun competition invites researchers to find the fastest method to train a model to a target quality at a chosen compute budget, inspired by the nanogpt speedrun. Top performers receive free compute to scale up their methods. This provides a structured venue for testing novel architectures and training algorithms.
Strengths and trade-offs#
Strengths
- Full process transparency, not just weightsMarin publishes the code, data pipelines, experiments, and failures behind each model, not just the final checkpoint. This is a direct contrast to most foundation model releases, including commercial ones, which share weights without the training process. Researchers can study or reproduce any decision in the pipeline.
- Validated at 8B and 32B parameter scaleThe team has trained Marin-8B-Base, which outperforms Llama 3.1 8B base on 14 of 19 standard benchmarks, and Marin-32B-Base, which beats OLMo 2 32B Base on 14 of 19 benchmarks. These are working examples of what the framework produces, not design claims.
- Apache-2.0 license with no usage restrictionsThe Apache-2.0 license allows commercial use, modification, and distribution without restriction. Researchers can fork Marin, adapt it for internal lab infrastructure, and publish derived models without license complications that AGPL or custom research licenses introduce.
- Backed by Stanford CRFM and active compute partnershipsCore contributors come from Stanford CRFM and Open Athena. The project is supported by Google TPU Research Cloud for accelerator access, the Siegel Family Endowment, and Schmidt Sciences. This institutional backing is reflected in an active codebase: 2,109 stars, 192 forks, and a last push dated 2026-08-26.
Trade-offs
- -Not a fine-tuning or inference frameworkMarin is built for pretraining from scratch. Teams looking to fine-tune an existing model for a downstream task, or to serve a model in production, need separate tooling. The framework does not include inference serving, quantization, or RLHF fine-tuning pipelines as first-class features.
- -High compute requirements for meaningful pretrainingTutorial experiments run on a CPU, but any meaningful pretraining run requires significant GPU or TPU allocation. The 32B model required Google TPU Research Cloud access. Teams without cloud compute budgets or TPU program access may find the largest experiments out of reach.
- -575 open issues on a fast-moving research codebaseWith 575 open GitHub issues, the codebase reflects the pace of active research: APIs change, documentation lags experiments, and things break as the team explores new architectures. Teams expecting a stable production framework should budget for debugging and keeping up with upstream changes.
marin vs alternatives#
Marin vs Amazon SageMaker
Amazon SageMaker is a managed ML platform for training, tuning, and deploying models at scale across general ML workloads. Marin is a research framework specifically for pretraining foundation models from scratch with open process documentation.
| Feature | Marin | Amazon SageMaker |
|---|---|---|
| License | Apache-2.0 | Proprietary |
| Self-hosting | Yes | No (AWS-only) |
| Focus | Foundation model research | General ML workloads |
| Experiment tracking | GitHub issues + WandB | SageMaker Experiments |
| Process transparency | Full (code, data, failures published) | None |
| Cost model | Compute only | Managed service fees on top of compute |
SageMaker is the better choice when you need a production-grade MLOps platform with managed infrastructure, deployment pipelines, and monitoring. It covers fine-tuning, feature engineering, and model serving under one roof. Marin is the better choice when the goal is foundation model research with full reproducibility and open publication: the framework is built around the assumption that the training process should be inspectable and shareable, which SageMaker does not support.
Marin vs Databricks
Databricks provides a managed data and ML platform built around Apache Spark and MLflow. Like SageMaker, it targets broad ML workloads across data engineering, feature stores, model training, and deployment.
| Feature | Marin | Databricks |
|---|---|---|
| License | Apache-2.0 | Proprietary (platform) |
| Self-hosting | Yes | Databricks-managed cloud |
| Focus | Foundation model pretraining | General data and ML workflows |
| Transparency | Full open development | Internal to workspace |
| Pricing | Compute only | Per-DBU pricing on top of compute |
Databricks is the better fit for data engineering teams who also need ML capabilities, or for organizations already standardized on the Databricks ecosystem. Marin is the better fit for research teams whose primary goal is pretraining foundation models with a documented, reproducible, and openly published process. Teams using Marin typically integrate directly with WandB for experiment tracking and Hugging Face for checkpoint publication, both of which are part of the standard Marin workflow.
What it's built on#
- Languages
- PythonRustTypeScript
- Frameworks
- Vue
FAQ#
What is Marin and how does it differ from other LLM frameworks?
Marin is an open research framework for training large language models from scratch, built around full process transparency: every experiment, dataset decision, and training failure is documented in real time. Unlike fine-tuning frameworks or inference libraries, Marin targets teams who want to build foundation models and publish the full training process alongside the weights.
What models has Marin been used to train?
The Marin team has trained Marin-8B-Base (outperforms Llama 3.1 8B base on 14 of 19 standard benchmarks), Marin-8B-Instruct (available on Together AI), and Marin-32B-Base (beats OLMo 2 32B Base on 14 of 19 benchmarks). The team is currently pretraining a 500B+ parameter mixture-of-experts model. All training code and checkpoints are published openly.
Is Marin free to use commercially?
Yes. Marin is licensed under Apache-2.0, which permits commercial use, modification, and distribution without restriction. You can run it on your own infrastructure, fork it for internal lab use, or build commercial products on top of it.
Can Marin be used for fine-tuning or serving models?
Marin is designed for pretraining from scratch, not fine-tuning or inference serving. If your goal is adapting an existing model with LoRA or PEFT, or deploying a trained model behind an API, you need separate tooling for those stages. Marin handles data-to-checkpoint; what comes after is outside its scope.
What compute does Marin require?
Tutorial experiments run on a CPU. Meaningful pretraining runs require GPU or TPU access, and the published 32B model was trained on Google TPU Research Cloud hardware. Marin supports single-GPU, multi-GPU, and multi-slice TPU configurations and scales to very large pod sizes.
Similar open-source tools#
open-notebook
Self-host private AI research notebooks
LLM Foundry
Apache 2.0 LLM fine-tuning toolkit for Llama and Mistral on GPU
Ollama
Run large language models locally on Mac, Linux, or Windows
Unsloth
Train LLMs locally without code using a browser-based interface
Ploomber
Build reproducible Python data pipelines with DAG orchestration
GPT‑NeoX
EleutherAI's framework for training LLMs at research scale