Skip to main content

Merlina✧

YOUR MODEL, A LITTLE MAGIC

CREATE

EXPLORE

WORKSPACE

API documentation
Workspace/Model
✧ Training studio

01 / THE FOUNDATION

Model studio

Every great model starts with a little curiosity. Let’s find your starting point.

A SMALL START. SOMETHING WONDERFUL.

A little magic.
A model of your own.

Choose a base model, add your data, and let’s bring your ideas to life.

Text & visionImage LoRAMade by you
✦✧✧your friendly training companion
◇

Your base model

A familiar foundation for something new.

Required
Use a HuggingFace model ID or a local folder, such as ./models/my-model.
Models from the HuggingFace cache and ./models — no internet needed
Auto-detect is a good starting point. Choose Vision-Language for image understanding, or Diffusion for image generation.
Access & authentication Optional
Required for gated models like Llama
✓ Model Ready
⌘Compute settingsAuto-detect GPUs · customize hardware⌄
Refresh to discover the GPUs available for your training run.
Hold Ctrl/Cmd to select multiple GPUs. Leave empty for auto-selection.
DDP: Each GPU processes different data batches in parallel — faster training, halves step count. Single: Spreads model layers across GPUs — for models too large for one GPU.
Your ideas, one step at a time.

02 / THE INGREDIENTS

Shape your dataset

Bring your data together, check the format, and give your model something good to learn.

Determines which columns your dataset needs.

Datasets

Add one or more datasets. Each has its own source and column mapping. All datasets are concatenated, formatted, and split together.
✨ Messages Format Detected!
One or more datasets use the common "messages" format. Enable auto-convert to transform into standard format (prompt, chosen, system).
When enabled: user → prompt, assistant → chosen, system → system

System Prompt Override (Optional)

Inject a system prompt across all datasets.
"Fill empty" sets the system prompt only for rows without one. "Replace all" overwrites every row's system prompt.

Dataset Format

How to format conversations for the model
When enabled, the model can use <think> tags to show its reasoning process before responding. When disabled, adds empty <think></think> tags to prevent thinking output.
Detect <think> per row: render with thinking enabled when the row has a reasoning column or embedded <think>…</think> in prompt/response, and disabled when it doesn't. This bakes the empty <think></think> wrapper into the prompt prefix on non-reasoning rows so the model never trains on emitting a closing </think> itself. Recommended for hybrid thinking/non-thinking corpora.
Use {system} and {prompt} as placeholders

Dataset Preview

Raw Dataset 


                        

                        

                            
                        

                    


                    
                    

                        

                            Formatted for Training
                            
                        

                        

                            

                                
Prompt:

                                

                            

                            

                                

                                    
✓ Chosen Response:

                                    

                                

                                

                                    
✗ Rejected Response:

                                    

                                

                            

                            

                                📝 Format Type: 
                            

                        

                        

                            
                        

                    

                


                
                

                    
Dataset Statistics

                    
                    

                        

                            
                        

                    

                


                
                

                    
Advanced Options

                    

                        

                            
                            
                            Fraction of data for evaluation
                        

                        

                            
                            
                            Limit dataset size for testing
                        

                    

                    

                        

                            
                            Streams rows in batches instead of loading all at once. Recommended for 100k+ row HuggingFace datasets.
                        

                        

                            
                            Removes duplicates before training. Useful when combining multiple datasets.
                        

                        

                            
                            
                        

                    

                



            


            
            

                
03 / THE RECIPE
Make it your own
A few thoughtful settings turn your model and dataset into something uniquely yours.


                
                

                    
Configuration Management


                    

                        
                        
                        
                        
                        
                        
                    

                    

                    
                        Save your current settings or load from a previous job
                    
                


                

                    
                    

                        
What are you training?

                        
                            Choose a training method — this also determines which dataset columns are required.
                        
                        

                            
                            
                            
                        

                        
                        

                    


                    
                    

                        
Diffusion Settings


                        
                        

                            
                            

                                
                                

                                    
🪄✨

                                    

                                        Drop your images here
                                    

                                    

                                        ...or click to pick a folder. PNG / JPG / WebP all work.
                                    

                                

                            

                            
                                Captions default to the filename — edit each one inline below, or leave blank to let the trainer infer from the image.
                            
                        


                        
                        

                            

                                0 images selected
                                

                                    
                                    
                                

                            

                            

                            

                        


                        

                            ⚙️ Advanced: paste a JSONL path or HF dataset name instead
                            

                                
                                

                                    
                                    
                                

                                JSONL with {prompt, image} (or {prompt, chosen, rejected}) rows. ⚠️ This is a path on the machine running Merlina, not your computer — if the server is remote, use the drag-drop upload above (which sets this automatically) or an HF dataset name below. Click Preview to inspect + inline-edit captions before training.
                            


                            
                            

                                

                                    Loading…
                                    

                                        
                                        
                                        
                                    

                                

                                

                                

                            

                            

                                
                                
                                Alternative to upload / JSONL. Dataset must have an `image` + `prompt` (or `caption`) column.
                            

                        


                        

                            
                            
                            Square crop at this size for both VAE encoding + training. 1024 is Qwen-Image native.
                        

                        

                            
                            
                            32 is a safe default for diffusion. Higher rank = more capacity but more overfit risk on small datasets.
                        

                        

                            
                            
                            Attention modules. Default targets attention only; add ff.net.0.proj / ff.net.2 for higher-capacity finetunes.
                        

                        

                            
                            Decomposes the LoRA update into magnitude + direction. ~5-10% slower step, meaningfully better quality on small aesthetic datasets where vanilla LoRA underfits the target style.
                        

                        

                            
                            Generate preview images on every checkpoint, not just at the end. Watch the LoRA converge in near-real-time. Pauses training briefly while sampling (~30-60s per checkpoint). Untick for fastest wall-clock.
                        

                    


                    
                    

                        

                            
                            
                        

                        
                        Name for your fine-tuned model
                    


                    
                    

                        
LoRA adaptation


                        
                        

                            
                            
                                When enabled, trains only LoRA adapters (faster, less VRAM). When disabled, trains the full model.
                            
                        


                        

                            

                                

                                    
                                    
                                

                                

                                    
                                    
                                

                                

                                    
                                    
                                

                            


                            
                            

                                

                                
                                

                                
                                

                                    

                                        
                                        Detecting layers...
                                    

                                


                                
                                

                                    

                                        

                                            ▼
                                            🎯
                                            Attention Layers
                                            
                                        

                                        

                                    

                                    

                                        

                                            ▼
                                            ⚡
                                            MLP Layers
                                            
                                        

                                        

                                    

                                    

                                        

                                            ▼
                                            📚
                                            Embedding Layers
                                            
                                        

                                        

                                    

                                    

                                        

                                            ▼
                                            📦
                                            Other Layers
                                            
                                        

                                        

                                    


                                    
                                    

                                        7 layers selected
                                        

                                            
                                            
                                            
                                        

                                    

                                


                                
                                

                                    
                                    Enter a model name above and click "Detect Layers" to see available layers, or enter comma-separated layer names manually.
                                

                                

                                    
                                    
                                    Modules to fully fine-tune (not LoRA-adapted) and save with adapter
                                

                                

                                    
                                    
                                    Most models use CAUSAL_LM. Only change this if you know your model architecture requires a different task type.
                                

                            

                        

                    


                    
                    

                        
Training parameters

                        

                            

                                
                                
                            

                            

                                
                                
                            

                            

                                
                                
                            

                        

                        

                            

                                
                                
                            

                            

                                
                                
                            

                            

                                
                                
                                Controls preference optimization strength
                            

                            

                                
                                
                                Target margin between chosen and rejected rewards
                            

                            

                                
                                
                                Smoothing coefficient for preference loss
                            

                        

                        

                            

                                
                                
                                For reproducibility
                            

                            

                                
                                
                                Gradient clipping threshold
                            

                        


                        
                        

                            

                                

                                    
                                    
                                    Blank = auto (max length minus the response). Long prompts keep their end.
                                

                                

                                    
                                    
                                    Fail if more than this share of prompts would be cut (1 = never fail)
                                

                                

                                    
                                    
                                    Learning rate warmup proportion
                                

                                

                                    
                                    
                                    How often to evaluate (0-1)
                                

                                

                                    
                                    
                                    Checkpoint cadence. Blank = follow eval steps; 0 = final model only (use on unified-memory boards); <1 = ratio; ≥1 = steps
                                

                            

                            

                                

                                    
                                    
                                    L2 regularization strength
                                

                                

                                    
                                    
                                    Learning rate schedule
                                

                                

                                    
                                    
                                    Log metrics every N steps
                                

                            

                            

                                

                                    
                                    Randomize training data order
                                

                                

                                    
                                    Save VRAM (slower training)
                                

                            

                        

                    


                    
                    

                        Optimizer configurationAlgorithm, weight decay, and optimizer parameters⌄
                        

                            
                            
                            
                                Paged optimizers swap memory to CPU when GPU is full. 8-bit uses less memory but may be slightly less precise. Muon applies orthogonalized updates to weight matrices — great for LoRA.
                            
                        


                        
                        

                            

                                

                                    
                                    
                                    First moment decay (momentum)
                                

                                

                                    
                                    
                                    Second moment decay (variance)
                                

                                

                                    
                                    
                                    Numerical stability (1e-8)
                                

                            

                        


                        
                        

                            

                                

                                    
                                    Use time-dependent LR instead of explicit learning rate
                                

                                

                                    
                                    Scale LR by root-mean-square of parameter tensor
                                

                                

                                    
                                    Time-dependent warmup (requires Relative Step)
                                

                            

                            

                                

                                    
                                    
                                    Running average decay for squared gradients
                                

                                

                                    
                                    
                                    Leave empty to disable momentum
                                

                                

                                    
                                    
                                    Root-mean-square gradient clipping
                                

                            

                        

                    


                    
                    

                        Performance optimizationsMemory efficiency, compilation, and kernel options⌄
                        

                            

                                
                                
                                    Patch model with fused Triton kernels (RMSNorm, RoPE, SwiGLU). Faster training, lower VRAM.
                                
                            

                            

                                
                                
                                    Wrap model with torch.compile for fused kernels (PyTorch 2.x). May add startup overhead.
                                
                            

                        

                        

                            

                                
                                
                                Embedding noise scale for regularization (try 5.0). Leave empty to disable.
                            

                            

                                
                                
                                    Run a baseline eval before training begins.
                                
                            

                        

                        

                            

                                💡 Liger Kernel: Best on Llama, Mistral, Qwen, Gemma, and Phi family models. Requires pip install liger-kernel.
                            

                        

                    


                    
                    

                        Attention implementationChoose the attention backend for your hardware⌄
                        

                            
                            
                            
                                Auto mode: Uses Flash Attention 2 on Ampere+ GPUs (RTX 30/40 series, A100, H100), falls back to SDPA or Eager for older GPUs.
                            
                        

                        

                            

                                💡 Performance Guide:

                                • Flash Attention 2: Up to 2-3x faster, lowest memory usage

                                • SDPA: Good balance, works on most modern GPUs

                                • Eager: Slower but most compatible, use for debugging
                            

                        

                    


                    
                    

                        
Output & integrations

                        

                            
                        


                        

                            
                        


                        

                            
                            
                                Pushes the model to models/<output name> in your object storage
                                (merged first, like a Hub upload), loadable as store:<name>.
                            
                        


                        
                        

                            

                                
HuggingFace Hub Configuration


                                
                                

                                    
                                    
                                    Required to push models. Get your token from huggingface.co/settings/tokens
                                


                                
                                

                                    
                                    

                                        
                                        
                                    

                                    Click "Check Orgs" to list the organizations your token can publish to.
                                


                                
                                
                                
                                    Private repositories are only visible to you. Uncheck to make your model public.
                                

                                
                                

                                    
                                    
                                        When checked, uploads full merged model (larger). When unchecked, uploads only LoRA adapter (much smaller, requires base model to use).
                                    
                                


                                
                                
                                
                                    Embeds the (secret-stripped) training config in the model's README so others can reproduce your run with one click. Uncheck to keep your hyperparameters private.
                                

                                
                                
                                
                                    Uploads a merlina_config.png — a scannable QR code that also carries the full (secret-stripped) config in its metadata. Others can reproduce your run by scanning it or loading it via Load Config → From Image, without the giant JSON block. Works with or without the README option above.
                                
                            

                        


                        

                        

                            
                        


                        
                        

                            

                                
Weights & Biases Configuration


                                
                                

                                    
                                    
                                    Get your API key from wandb.ai/authorize
                                


                                

                                    

                                        
                                        
                                        W&B project to organize runs
                                    

                                    

                                        
                                        
                                        Leave empty for auto-naming
                                    

                                

                                

                                    
                                    
                                    Organize runs with tags
                                

                                

                                    
                                    
                                    Describe the purpose of this run
                                

                                

                                    💡 Auto-naming format: [model]-[lr]-[batch]-[epochs]ep-[optimizer]-[attention]

                                    Example: llama3-8b-5e-6LR-256B-2ep-adamw8bit-flash2-4bit
                                

                            

                        


                        
                        
                    


                    
                

            


            
            

                

                    
EXPLORE / JOBS
Magic in the making
Your training runs, from first step to finished model.

                    
                

                

            


            
            

                
EXPLORE / PLAYGROUND
Meet your creation
Start a conversation or conjure an image. See what your model has learned.


                
                

                    

                        
                        
                        Pick chat for any text model, or diffusion to render images from a trained image LoRA.
                    

                


                
                


                
                

                    
Load a Model


                    

                        
                        
                    


                    
                    

                        
                        
                        
                    


                    
                    

                        
                        
                        HuggingFace model ID or absolute path to local model directory
                    


                    

                        
                        
                    


                    

                        
                        
                    


                    

                        
                        
                    


                    

                


                
                

                    
Generation Settings

                    

                        

                            
                            
                        

                        

                            
                            
                        

                        

                            
                            
                        

                        

                            
                            
                        

                        

                            
                            
                        

                        

                            

                                
                                
                            

                        

                    


                    

                        
                        
                    

                


                
                

                    
Chat


                    


                    

                        
                        

                            
                            
                        

                    


                    

                        
                        
                    

                


                


                
                

                    

                        Pick a base diffusion model + one of your trained LoRAs, type a prompt, hit conjure. Runs in a fresh subprocess so it won't fight live training jobs for VRAM.
                    


                    

                        
Conjure


                        

                            
                            
                            HF repo id or local path. Defaults to Qwen-Image.
                        


                        

                            
                            
                            Match the family the LoRA was trained against.
                        


                        

                            
                            
                            Picked from ./models/. Refresh after training new ones.
                            
                        


                        

                            
                            
                        


                        

                            

                                
                                
                            

                            

                                
                                
                            

                            

                                
                                
                            

                        


                        

                        


                        

                            
Result

                            generated
                            

                        

                    

                

            


            
            
            
            

                

                    
EXPLORE / REMOTE GPUS
Borrow a bigger cauldron
Serve a model on a rented GPU behind an OpenAI-compatible endpoint, try it, and send it home.

                    
                


                

                    
New session

                    

                        What to serve
                        
                        
                        
                    


                    

                        

                            
                            
                        

                        

                            
                            
                        

                    

                    

                        

                            
                            
                            
                        

                    

                    

                        

                            
                            
                        

                        

                            
                            
                        

                    


                    

                        

                            
                            
                        

                        

                            
                            
                        

                    


                    
Hardware

                    

                        

                            
                            
                        

                        

                            
                            
                        

                        

                            
                            
                        

                        

                            
                            
                        

                    


                    
Caps

                    

                        

                            
                            
                        

                        

                            
                            
                        

                        

                            
                            
                        

                    


                    

                        vLLM settings
                        

                            

                                
                                
                            

                            

                                
                                
                            

                        

                        

                            
                            
                        

                        
                    


                    

                        
                    

                    

                


                

                    
Sessions

                    
Loading…

                

                

            


            

                
EXPLORE / EXPORT
Ready for the world
Package your model, publish to the Hub, and keep your artifacts together.

                

                    Quantize trained models to GGUF, publish to HuggingFace Hub, and manage artifacts — all against any model under ./models/.
                


                

                    
                    
                    
                


                
                

                    
                    
                    
                


                
                

                    

                        
GGUF Quantization

                        
                            Merlina will merge the LoRA (if any) and brew one GGUF per selected quant. Larger quants keep more quality; smaller quants run on weaker hardware.
                        

                        


                        

                            
                            

                                
                                
                                
                                
                                
                                
                                
                                
                                
                            

                        


                        

                        

                            
                            
                        


                        

                            
                        

                    

                


                
                

                    

                        
HuggingFace Hub Upload


                        


                        

                            
                            

                                
                                
                            

                            Click "Check Orgs" to list the organizations your token can publish to.
                        


                        

                            
                            
                            Defaults to the model folder name. Picking an organization above publishes it as org/model-name; an explicit org/name here wins.
                        


                        

                        

                            
                            

                                
                                
                                
                                
                            

                        


                        

                            
                            
                        


                        

                            Advanced metadata
                            

                                
                                
                            

                            

                                
                                
                            

                            

                                
                                
                            

                            

                                
                                
                            

                        


                        

                            
                            
                        

                    


                    

                


                
                

                    

                        
Artifacts

                        
                            Everything Merlina saved under ./models/{selected}/. Protected files (config, tokenizer) can't be deleted via the UI.
                        

                        

                        

                    

                

            


            
            

                

                    
WORKSPACE / STORAGE
Room for your next idea
A clear view of your checkpoints, models, and cached files.

                    
                

                

                    Old training runs leave behind full-size checkpoints. Keep the latest of each
                    finished run and reclaim the rest — active jobs are always left untouched.
                


                
                

                    
Disk Usage

                    

                        

                        —
                    

                    

                        

                            Results total
                            —
                        

                        

                            Reclaimable
                            —
                        

                        

                            Models total
                            —
                        

                    

                


                
                

                    
                    
                    
                    
                


                
                

                
                

                    
Prune Checkpoints

                    

                        

                            
                            
                        

                        

                            
                        

                    

                    

                        
                        
                    

                    

                


                
                

                    
Per-Job Breakdown

                    
Loading…

                

                


                
                

                    

                        ⚠️ This cache is shared across your whole machine.
                        

                            Other tools (ComfyUI, other trainers, scripts) pull models from this same cache.
                            Everything here is re-downloadable from the Hub, but deleting a model another tool
                            still needs will force a re-download. Only remove repos you're sure are unused.
                        

                    


                    

                        
Cached Repos

                        

                            

                                
                                
                            

                            
                            
                        

                        

                            

                                Cache total
                                —
                            

                            

                                Stale (reclaimable)
                                —
                            

                            

                                Selected
                                0 B
                            

                        

                        

                            
                        

                        

                        
Click “Scan” to inspect the cache.

                    

                


                
                

                    

                        ⚠️ Deleting a saved model is permanent.
                        

                            These are your trained outputs under ./models/. Unlike the HuggingFace
                            cache, a model that was never pushed to the Hub cannot be recovered.
                            Models in use (an active job's output, or one loaded for inference) are locked 🔒.
                        

                    


                    

                        
Saved Models

                        

                            

                                Models total
                                —
                            

                            

                                Selected
                                0 B
                            

                        

                        

                            
                        

                        

                        
Loading…

                    

                


                
                

                    

                        

                            
GGUF Exports

                            always regenerable from the model
                        

                        

                            Quantized GGUF files produced for llama.cpp inference. Safe to delete — re-export
                            anytime from the model. One loaded for inference is locked 🔒.
                        

                        

                            

                                GGUF total
                                —
                            

                            

                                Selected
                                0 B
                            

                        

                        

                            
                        

                        

                        
Loading…

                    


                    

                        
Weights & Biases Logs

                        

                            Local mirrors of training run logs under wandb/. Metrics already live on
                            the W&B server; the active run is kept.
                        

                        

                            

                                Logs total
                                —
                            

                            

                                Runs
                                —
                            

                            

                                Clearable
                                —
                            

                        

                        
                        

                    

                

            


            
            

                

                    
WORKSPACE / OBJECT STORAGE
Everything in its place
Browse your storage tiers and move things between them.

                    
                

                

                    Browse every bucket your keys can see, preview files, and copy or move prefixes between
                    buckets and tiers. Every sync is previewed first. Private data from a private tier is
                    never copied to a shared tier; the preview lists anything the guard refuses.
                


                

                    
Tiers & buckets

                    
Loading…

                    

                


                

                    

                    

                    

                    
Loading…

                    

                    

                

            


            

            

                
✧
Your recipe
A little of this. A little of you.

                    
BASE MODEL
Choose your model
DATASETS ADDED
1 dataset
TRAINING METHOD
ORPO
ADAPTATION
LoRA fine-tuning

                    
✦
Start with a model you love. Merlina will check that it’s ready before training.

                

                
FROM IDEA TO CREATION
  1. 01Choose a model
  2. 02Add your dataset
  3. 03Make some magic
Then explore, export, and share.

            

        


        
        

            

                
                
Training progress

                

                    

                        

                        
                    


                    

                        

                            

                            0%
                        

                        

                    


                    

                        

                            Current Step
                            -
                        

                        

                            Loss
                            -
                        

                        

                            Status
                            -
                        

                        

                            GPU Memory
                            -
                        

                    


                    
                    

                        

                            
Training Loss

                            

                                
                                
                                
                            

                        

                        

                            
                        

                        
Waiting for training data...

                    


                    
                    

                        
GPU Monitoring

                        

                        
                    


                    
                    

                        
Sample Renders

                        

                            Test images generated by your freshly-trained LoRA on a default prompt set. (Override via sample_prompts in the API.)
                        

                        

                        

                            No sample images yet — they'll appear once training completes.
                        

                    


                    

                        
                            📊 View in W&B
                        
                        
                        
                        
                    

                    

                    

                        
                    

                    

                

            

        


        
        

            

                
                
📤 Upload Model to HuggingFace Hub

                
Push this job's trained model to HuggingFace Hub.

                

                    
                    
                    Optional if HF_TOKEN is set in the server's .env.
                

                

                    
                    

                        
                        
                    

                    Click "Check Orgs" to list the organizations your token can publish to.
                

                

                    
                    
                

                

                    
                    
                

                
            

        


        
        


        
        

            

                
                
Save Configuration

                

                    
                    
                

                

                    
                    
                

                

                    
                    
                

                

                    
                    
                

            

        


        
        

            

                
                
Load Configuration

                

                    
Loading configurations...

                

            

        


        
        

            

                
                
Load Configuration from Code

                

                    Paste the merlina-config-v1:… code from a Merlina model card
                    (the "Reproduce this training run" section). Raw config JSON works too.
                

                

                    
                    
                

                
            

        


        
        

            

                
                
Load Configuration from Previous Job

                
Click a job to load its training configuration into the form.

                

                    
Loading job history...

                

            

        


        
        

            

                
                
Manage Configurations

                

                    
Loading configurations...

                

            

        


        
        

            

                Loading version...
                

                Made with ❤️ by Schneewolf Labs