GPU Sandboxes

Daytona provides GPU sandboxes for workloads that require NVIDIA GPU acceleration, such as model inference, fine-tuning, and CUDA-accelerated compute.

GPU sandboxes are ephemeral and support up to 16 vCPUs, 192GB RAM, and 512GB disk.

• NVIDIA H100
• NVIDIA H200
• NVIDIA RTX Pro 6000
• NVIDIA RTX 4090
• NVIDIA RTX 5090

Create GPU Sandboxes

Daytona provides methods to create GPU sandboxes.

1. Navigate to Daytona Sandboxes ↗

2. Click Create Sandbox

3. Select a GPU snapshot:

   • daytona-gpu

4. Select ephemeral or set auto-delete interval to 0

5. Click Create

Python

from daytona import Daytona, CreateSandboxFromSnapshotParams

daytona = Daytona()
sandbox = daytona.create(
        CreateSandboxFromSnapshotParams(
            snapshot="daytona-gpu",
            auto_delete_interval=0
        ),
)

TypeScript

import { Daytona } from "@daytona/sdk";

const daytona = new Daytona()
const sandbox = await daytona.create({
  snapshot: "daytona-gpu",
  ephemeral: true,
});

Ruby

require 'daytona'

daytona = Daytona::Daytona.new
sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'daytona-gpu',
    ephemeral: true
  )
)

Go

package main

import (
  "context"
  "github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"
  "github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
)

func main() {
  client, _ := daytona.NewClient()
  ctx := context.Background()
  params := types.SnapshotParams{
    Snapshot: "daytona-gpu",
    SandboxBaseParams: types.SandboxBaseParams{
      Ephemeral: true,
    },
  }
  _, _ = client.Create(ctx, params)
}

Java

import io.daytona.sdk.Daytona;
import io.daytona.sdk.Sandbox;
import io.daytona.sdk.model.CreateSandboxFromSnapshotParams;

public class App {
    public static void main(String[] args) {
        try (Daytona daytona = new Daytona()) {
            CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams();
            params.setSnapshot("daytona-gpu");
            params.setAutoDeleteInterval(0);
            Sandbox sandbox = daytona.create(params);
        }
    }
}

CLI

daytona create --snapshot daytona-gpu --auto-delete 0

API

curl 'https://app.daytona.io/api/sandbox' \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{
  "snapshot": "daytona-gpu",
  "autoDeleteInterval": 0
}'

Create Custom GPU Sandboxes

Daytona provides methods to create GPU sandboxes with custom GPU count and types.

1. Create a sandbox from an image

2. Set the auto-delete interval to 0 (ephemeral)

3. Set the GPU count to the number of GPUs you want

4. Specify the GPU type(s):

   The GPU type field accepts a single value or an ordered list of preferred types.

   Daytona uses the first available type in the order you provide. This lets you fall back from a preferred GPU to an alternative when the first choice is not available.

   • H100
   • H200
   • RTX-PRO-6000
   • RTX-4090
   • RTX-5090

Python

from daytona import Daytona, CreateSandboxFromImageParams, Image, Resources, GpuType

daytona = Daytona()
sandbox = daytona.create(
    CreateSandboxFromImageParams(
        image=Image.debian_slim("3.12"),
        auto_delete_interval=0,
        resources=Resources(
            gpu=1,
            gpu_type=[GpuType.H100, GpuType.RTX_PRO_6000],
        ),
    )
)

TypeScript

import { Daytona, GpuType, Image } from "@daytona/sdk";

const daytona = new Daytona()
const sandbox = await daytona.create({
  image: Image.debianSlim("3.12"),
  autoDeleteInterval: 0,
  resources: {
    gpu: 1,
    gpuType: [GpuType.H100, GpuType.RTX_PRO_6000],
  },
});

Ruby

require 'daytona'

daytona = Daytona::Daytona.new
sandbox = daytona.create(
  Daytona::CreateSandboxFromImageParams.new(
    image: Daytona::Image.debian_slim('3.12'),
    auto_delete_interval: 0,
    resources: Daytona::Resources.new(
      gpu: 1,
      gpu_type: [Daytona::GpuType::H100, Daytona::GpuType::RTX_PRO_6000]
    )
  )
)

Go

package main

import (
  "context"
  "github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"
  "github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
)

func main() {
  client, _ := daytona.NewClient()
  ctx := context.Background()
  autoDelete := 0
  _, _ = client.Create(ctx, types.ImageParams{
    Image: "python:3.12",
    SandboxBaseParams: types.SandboxBaseParams{
      AutoDeleteInterval: &autoDelete,
    },
    Resources: &types.Resources{
      GPU:     1,
      GpuType: []types.GpuType{types.GpuTypeH100, types.GpuTypeRtxPro6000},
    },
  })
}

Java

import io.daytona.sdk.Daytona;
import io.daytona.sdk.Sandbox;
import io.daytona.sdk.model.CreateSandboxFromImageParams;
import io.daytona.sdk.model.Resources;
import io.daytona.api.client.model.GpuType;
import java.util.List;

final class CreateGpuSandbox {
    public static void main(String[] args) {
        try (Daytona daytona = new Daytona()) {
            CreateSandboxFromImageParams params = new CreateSandboxFromImageParams();
            params.setImage("python:3.12");
            params.setAutoDeleteInterval(0);
            Resources resources = new Resources();
            resources.setGpu(1);
            resources.setGpuType(List.of(GpuType.H100, GpuType.RTX_PRO_6000));
            params.setResources(resources);
            Sandbox sandbox = daytona.create(params);
        }
    }
}

API

curl 'https://app.daytona.io/api/sandbox' \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{
  "image": "python:3.12",
  "autoDeleteInterval": 0,
  "gpu": 1,
  "gpuType": ["H100", "RTX-PRO-6000"]
}'