Skip to content

About Tuneline Studio

Tuneline Studio is an open-source, visual workbench for fine-tuning, evaluating and deploying open large language models with your own accounts and keys.

Mission

Fine-tuning a small open model on your own examples is often the best way to get a model that makes the decisions you need, cheaply and privately. Doing it well still takes a lot of glue: data formatting, training scripts, GPU providers, evaluation against the base model, a check before anything ships, publishing, serving. Tuneline puts all of that on one canvas, so people who know their data and their task, not only ML engineers, can build a repeatable pipeline, run it where they like and see clearly whether the result is better than what they started with.

What Tuneline is

  • A pipeline builder: 24 blocks for data, models, training (SFT, DPO, ORPO, SimPO, KTO, GRPO, vision SFT), evaluation, quality gates, export and deployment, connected with typed links on a canvas.
  • A launcher for the compute you already have or can get for free: Kaggle, notebooks (Colab, Lightning, Jupyter), your own computer, Modal, RunPod and Hugging Face Jobs.
  • A run monitor: live step statuses, logs, metrics, evaluation reports and artifacts.
  • A model registry, deployment manager and playground for what your runs produce.

What Tuneline isn't

  • Not a GPU provider or a hosting service. Tuneline doesn't sell compute or serve models itself. Runs and endpoints use your provider accounts.
  • Not a training library. The training itself is done by established open-source libraries (Transformers, TRL, PEFT and others). See Ecosystem.
  • Not a model store. Your models live in your own Hugging Face account.
  • Not for training models from scratch. It is built for fine-tuning and evaluating existing open models.

Principles

Your keys, your bill. You add your own provider keys (Hugging Face, Kaggle, Modal, RunPod and others) in Settings → API keys. Every run and endpoint uses them, and providers bill you directly. The Run pipeline dialog shows the estimated cost first and lets you set a time and cost limit for each run.

Your models, your account. Fine-tuned adapters, merged models, GGUF files and cached intermediate results are pushed to your own Hugging Face account, as private repositories by default.

Secrets stay secret. Keys are stored encrypted in Supabase Vault. The web app only ever sees the last four characters of a key. A running job receives only the keys its pipeline needs, through a per-run token that stops working shortly after the run ends. Run tokens (tlr_...) and worker tokens (tlw_...) are stored only as hashes. Every table has row level security, so each person can only read and write their own data. See API keys and security.

Plain language. Screens and messages name things by what you recognize ("Add a computer", "Run on RunPod") and errors say what went wrong and how to fix it.

Evaluate before you ship. Templates compare the fine-tuned model with its base model and put a quality gate in front of publishing, so a model that isn't good enough stops there.

License

Tuneline Studio is released under the Apache License 2.0. The full text is in the LICENSE file of the repository.

The models you fine-tune keep the licenses of their base models, and gated models (for example Llama and Gemma) need you to accept their license on Hugging Face first. The Models page shows each model's license.

Project status

Tuneline Studio is at version 0.1.0, its first public release, and is still early. Expect rough edges, and check Release notes for what changed.

What has been checked:

  • The code is covered by automated tests: about 360 Python tests (including the API), about 190 web unit tests and end-to-end browser tests.
  • The runner's training code paths ran for real on a CPU with tiny test models: LoRA and full SFT, resume and cancel, DPO, ORPO, SimPO, KTO, GRPO, vision SFT with images, golden-set evaluation, adapter merges and GGUF conversion with llama.cpp.
  • The CPU smoke test template ran end to end on a local worker on 28 September 2026, with live status, logs, metrics and an evaluation report in the app.

What is not yet verified against real provider accounts:

  • Launching runs on Modal, RunPod, Hugging Face Jobs and Kaggle, and cancelling them.
  • Creating endpoints on RunPod Serverless, Hugging Face Inference Endpoints and Modal.
  • QLoRA on NVIDIA GPUs (with bitsandbytes), and memory use compared with the estimate.
  • Real lm-evaluation-harness benchmark runs, the LLM judge through real providers, and GGUF export for every model family.
  • Time and cost estimates against measured runs.

Some speed-ups currently fall back automatically: Unsloth (its current releases don't support TRL 1) and vLLM in training jobs (the job images use an older PyTorch). Runs still work, using TRL and Transformers instead. Known limitations are listed in the Release notes.

Technology

Part Built with
Web app React 19, TypeScript, Vite, Tailwind CSS, React Flow (@xyflow/react) for the canvas, TanStack Query, Recharts for charts, supabase-js
API (control plane) Python and FastAPI, running as a Vercel function; talks to Modal, RunPod, Hugging Face and Kaggle
Database, sign-in and storage Supabase: Postgres with row level security, Vault for keys, Storage for datasets, Realtime for live run updates, pg_cron for background checks
Runner The tuneline Python package: runs pipelines in jobs, notebooks and on workers, using PyTorch, Transformers, TRL, PEFT, Datasets, Accelerate, bitsandbytes and llama.cpp

The architecture is described in Architecture. To contribute, see Contributing.