# 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 ↗](https://app.daytona.io/dashboard/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);
        }
    }
}
```


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


```bash
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);
        }
    }
}
```


```bash
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"]
}'
```