Top 8 Platforms to Fine-Tune Open Source LLMs in 2026

TL;DR: Start with Unsloth if you have one GPU and want the cheapest run, or Together AI if you want no infrastructure at all, from $0.34 per million training tokens on models up to 9B. Hugging Face, Axolotl and LLaMA-Factory are the free open-source stacks most teams build on, and Modal and SageMaker rent you the GPUs, with Modal's H100 at $3.95 an hour against about $7.91 per GPU on SageMaker.

Fine-tuning a 9B model on 10 million tokens for three epochs now costs about $10 on Together AI's list price, which I checked with every other price here on October 7, 2026.

The hard part has moved from paying for compute to choosing a stack: the three biggest open-source trainers all support LoRA, QLoRA, full fine-tuning and DPO, and they differ mostly in how much of the pipeline they hide from you.

Quick Comparison: LLM Fine-Tuning Platforms

1. Hugging Face

Hugging Face is for teams that want the standard tooling every other platform on this list builds on.

The Hugging Face Hub listed 3,127,796 models on October 7, and its TRL library now ships trainers for supervised fine-tuning, DPO, GRPO, KTO and reward modeling under one API.

The newer piece is Jobs, which runs a training script on Hugging Face hardware without you setting up a cloud account. Billing is per minute: an L4 is $0.80 an hour, an 80GB A100 $2.50, an H200 $5.00, and eight H200s $40.00.

Jobs default to a 30-minute timeout, so set a longer one before a real training run or it stops mid-epoch. Credits from a $9 PRO account or a $20-per-seat Team plan count toward Jobs.

When training ends, the adapter or full model goes back to the Hub as a versioned repo, and Inference Endpoints can serve it on a dedicated GPU from $0.50 an hour for a T4 up to $9.25 for a B200.

• Best for: Teams that want TRL, the Hub and a GPU from one vendor.
• Where it struggles: You still write the training script; nothing is configured for you.
• Price: Libraries free; Jobs from $0.40 an hour (T4) to $40 an hour (8x H200).

2. Unsloth

Unsloth is for developers training on one GPU, including gaming cards. Its GitHub README claims models train "2x faster with 70% less VRAM", through custom kernels that replace the slowest steps of a standard training loop.

It has grown well past QLoRA.

The open-source package now covers full fine-tuning, pretraining, DPO, GRPO reinforcement learning and FP8 training, on NVIDIA, AMD and Intel GPUs, with day-one support for new open models such as Qwen3.8, DeepSeek-V4 and Gemma 4.

The newest addition is Unsloth Desktop, a free, open-source app that runs and trains models locally from a desktop interface.

The core library is Apache 2.0; the Studio interface is AGPL-3.0, which matters if you plan to ship it inside a product.

The paid tiers are about speed, not features. Unsloth says Pro adds "2.5x faster training + 20% less VRAM" on top of the free version, and Enterprise promises "30x faster training + multi-node support".

Neither has a public price, so treat them as a conversation once a single GPU stops being enough.

• Best for: The cheapest possible run on hardware you already own.
• Where it struggles: Multi-node training is reserved for the paid Enterprise tier.
• Price: Free. Pro and Enterprise plans are quote-only; the pricing page lists no figure.

3. Together AI

Together AI is for teams that want a fine-tuned model without touching a GPU. You upload a JSONL or Parquet file, pick a base model, and Together AI runs the job and hosts the result.

LoRA is the default; full fine-tuning is available when the base model's behavior needs to change a lot.

The supported list runs from 4B to 397B parameters, including DeepSeek V4 Flash, Qwen 3.5 to 3.8, Llama 4 Scout and Maverick, and Gemma 4 31B, with up to 131,072 tokens of context for SFT.

Read the deployment note before training: some models can be fine-tuned but not deployed as dedicated endpoints, so check the endpoint list first.

Full fine-tuning bills a little higher than LoRA on the same model: Qwen3.5 27B is $1.16 per million tokens for full SFT against $1.05 with LoRA.

Context limits are generous, with Qwen3.8 27B taking 131,072 tokens per example for SFT and 65,536 for DPO.

• Best for: Product teams that want a hosted model next week.
• Where it struggles: Little control over the training loop, and you pay per token on every epoch.
• Price: SFT from $0.34 per million tokens; minimum $4 to $60 per job depending on model size.

4. Axolotl

Axolotl is for ML engineers who want every training setting in a file they can version.

Axolotl drives the whole pipeline, from dataset preprocessing through training, evaluation, quantisation and inference, from a single YAML config, so a run can be repeated exactly or reviewed in a pull request.

Its method list is the widest here: full fine-tuning, LoRA, QLoRA, GPTQ, quantisation-aware training down to FP8 and NVFP4, preference tuning with DPO, IPO, KTO and ORPO, and GRPO reinforcement learning.

It scales from one card to many nodes through FSDP2, DeepSpeed and sequence parallelism, and it trains vision-language models such as Qwen2-VL and InternVL alongside Llama 4, Qwen3 and Gemma.

The project now lives under the axolotl-ai-cloud organization on GitHub and is Apache 2.0.

Throughput features are where it earns its place on big jobs.

Multipacking fills each batch with several short examples instead of padding, and you can switch between Flash Attention 2, 3 and 4 or SageAttention from the same config, loading datasets from local disk, the Hugging Face Hub or cloud storage.

• Best for: Multi-GPU runs where reproducibility matters.
• Where it struggles: No interface and no hosting; a bad config fails late.
• Price: Free. On Modal, an 80GB A100 to run it costs $2.50 an hour.

5. LLaMA-Factory

LLaMA-Factory is for teams that want to fine-tune from a browser form instead of a script.

LLaMA-Factory wraps training in LLaMA Board, a Gradio web interface where you pick the model, dataset and training method from menus instead of writing a script.

Under the menus it is not a toy. It supports full, freeze, LoRA, QLoRA and OFT tuning across pretraining, SFT, reward modeling, PPO, DPO, KTO, ORPO and SimPO, on NVIDIA GPUs, AMD ROCm and Huawei Ascend NPUs.

The repository, renamed LlamaFactory on GitHub, added training support for GLM-5.3-Flash in the week before this check, and the project's paper appeared at ACL 2024.

Free notebooks on Google Colab and trial credits on Alibaba's PAI-DSW let you try it without hardware.

Hosted copies also run on Hugging Face Spaces, ModelScope and Novita AI, and the documentation is published in English and Chinese.

That makes it the easiest of the open-source tools to hand to a developer who has never fine-tuned a model before.

• Best for: A first fine-tune by a developer who is not an ML specialist.
• Where it struggles: Large multi-node jobs, which are better handled by a config-driven tool.
• Price: Free under Apache 2.0; you pay only for GPUs.

6. Amazon SageMaker

SageMaker is for teams whose data, permissions and audit trail already live in AWS.

Amazon SageMaker runs training as managed jobs on instances you pick, and JumpStart adds ready-made fine-tuning recipes for popular open models at no extra charge beyond the instance hours.

On-demand training prices in US East, from AWS's own price list on October 7: ml.g5.xlarge with one A10G GPU is $1.41 an hour, ml.g6e.xlarge with one L40S is $2.61, ml.p4d.24xlarge with eight A100s is $25.25, and ml.p5.48xlarge with eight H100s is $63.30.

For long runs on large clusters, HyperPod adds automatic fault recovery and checkpointing. The pricing page also lists a newer model-customization option billed by tokens processed for SFT and DPO.

• Best for: Regulated teams that need training inside their AWS account.
• Where it struggles: Price per GPU is roughly double Modal's, and H100s come only in blocks of eight.
• Price: From $1.41 an hour; free tier covers 50 CPU training hours in the first two months.

7. Modal

Modal is for Python developers who want a GPU for exactly as long as the training script runs.

With Modal, you decorate a Python function with the GPU it needs, and Modal starts the container, runs the job and stops billing when it ends, so an Unsloth or Axolotl run pays for its own minutes only.

Its price sheet is the lowest per GPU of the hosted options here: a T4 is $0.59 an hour, an A10 $1.10, an L40S $1.95, an 80GB A100 $2.50, an H100 $3.95, an H200 $4.54 and a B200 $6.25, all charged by the second.

The Starter plan has no monthly fee and includes $30 of compute a month, which buys 12 hours on an 80GB A100; the Team plan is $250 a month plus compute, with $100 of credit.

Newer cards are on the list too: an RTX PRO 6000 works out to about $3.03 an hour and a B300 to about $7.10, both at the per-second rate. For a LoRA run on a 7B to 9B model, an L40S or an A100 is usually the cheaper choice than an H100.

• Best for: Bursty training runs scripted in Python.
• Where it struggles: No interface, and multi-day jobs need checkpointing you write yourself.
• Price: Per second, from $0.59 an hour (T4) to $6.25 (B200).

8. Databricks

Databricks is for enterprises whose training data already sits in a lakehouse and has to stay governed while it becomes a model.

Databricks Model Training, part of Mosaic AI, fine-tunes open-source LLMs or pretrains custom ones on the same platform that stores the data, so lineage, access rules and audit logs follow the dataset into the model.

The compute side is AI Runtime, Databricks' serverless GPU option, in Public Preview as of this check.

Its documentation says you can "attach your notebook to a GPU in seconds" and run LoRA or full fine-tuning with TRL, Unsloth or Axolotl, scaling to multi-GPU jobs with DDP, FSDP or DeepSpeed.

In practice that means the open-source tools earlier on this list run inside Databricks rather than competing with it.

Governance is the reason to pick it. Unity Catalog applies access controls and tracks lineage across every model, dataset and agent, and Unity Gateway sets rate limits and cost controls across models and providers.

Managed MLflow tracks experiments and registers the finished model.

• Best for: Regulated teams fine-tuning on private data that already lives in Databricks.
• Where it struggles: Heavy to adopt just for one fine-tune, and costs are harder to forecast than a flat GPU rate.
• Price: Pay-as-you-go in DBUs, billed per second; Databricks publishes no fixed training price and quotes through its calculator or sales.

Choosing the Right Platform

Hire Engineers Who Fine-Tune Models

The platforms make a training run cheap; a clean dataset and an honest evaluation are what make it worth doing. We place vetted AI developers and LLM engineers from Asia for fine-tuning, evaluation and deployment work.

Tell us what you are building to get a shortlist.

Frequently Asked Questions

LoRA or full fine-tuning?

Start with LoRA. It trains small adapter layers on top of frozen weights, so it needs far less GPU memory and is the default on Together AI. Move to full fine-tuning only if LoRA plateaus.

Can I use a fine-tuned model commercially?

It depends on the base model's license, not the platform. Check it before training: some open-weight licenses restrict commercial use or require attribution for derivatives.