VM Sandboxes

Daytona provides VM sandboxes for workloads that require a full virtual machine with a dedicated Linux or Windows operating system.

VM sandboxes are distinct from container sandboxes and support VM-only capabilities such as pause/resume sandboxes and hot/cold snapshots. All other sandbox features and functionality are the same as for container sandboxes.

Limitations

VM sandboxes can currently only be created from existing VM snapshots. Dynamic builds through the declarative builder are supported for container sandboxes only.

Create Linux Sandboxes

Daytona provides methods to create Linux VM sandboxes.

1. Navigate to Daytona Sandboxes ↗

2. Click Create Sandbox

3. Select a Linux VM snapshot:

   • daytona-vm-small
   • daytona-vm-medium
   • daytona-vm-large

4. Click Create

Python

from daytona import Daytona, CreateSandboxFromSnapshotParams

daytona = Daytona()
sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="daytona-vm-small"))

TypeScript

import { Daytona } from '@daytona/sdk'

const daytona = new Daytona()
const sandbox = await daytona.create({ snapshot: 'daytona-vm-small' })

Ruby

require 'daytona'

daytona = Daytona::Daytona.new
sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'daytona-vm-small'
  )
)

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-vm-small",
  }
  _, _ = 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-vm-small");
            Sandbox sandbox = daytona.create(params);
        }
    }
}

CLI

daytona create --snapshot daytona-vm-small

API

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

Create Custom Linux Sandboxes

Daytona provides methods to create custom Linux VM sandboxes.

1. Create a snapshot from a base image
2. Set sandbox class to LINUX_VM
3. Create a Linux VM sandbox from the snapshot

Python

from daytona import (
    Daytona,
    CreateSnapshotParams,
    CreateSandboxFromSnapshotParams,
    SandboxClass,
)

daytona = Daytona()

# 1. Create a VM snapshot (linux-vm class)
daytona.snapshot.create(
    CreateSnapshotParams(
        name="my-vm-snapshot",
        image="ubuntu:22.04",
        sandbox_class=SandboxClass.LINUX_VM,
    )
)

# 2. Create a VM sandbox from the snapshot
sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="my-vm-snapshot"))

TypeScript

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

const daytona = new Daytona();

// 1. Create a VM snapshot (linux-vm class)
await daytona.snapshot.create({
  name: "my-vm-snapshot",
  image: "ubuntu:22.04",
  sandboxClass: SandboxClass.LINUX_VM,
});

// 2. Create a VM sandbox from the snapshot
const sandbox = await daytona.create({ snapshot: "my-vm-snapshot" });

Ruby

require 'daytona'

daytona = Daytona::Daytona.new

# 1. Create a VM snapshot (linux-vm class)
daytona.snapshot.create(
  Daytona::CreateSnapshotParams.new(
    name: 'my-vm-snapshot',
    image: 'ubuntu:22.04',
    sandbox_class: DaytonaApiClient::SandboxClass::LINUX_VM
  )
)

# 2. Create a VM sandbox from the snapshot
sandbox = daytona.create(Daytona::CreateSandboxFromSnapshotParams.new(snapshot: 'my-vm-snapshot'))

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()

  // 1. Create a VM snapshot (linux-vm class)
  sandboxClass := types.SandboxClassLinuxVM
  _, logCh, _ := client.Snapshot.Create(ctx, &types.CreateSnapshotParams{
    Name:         "my-vm-snapshot",
    Image:        "ubuntu:22.04",
    SandboxClass: &sandboxClass,
  })
  for range logCh {
  }

  // 2. Create a VM sandbox from the snapshot
  _, _ = client.Create(ctx, types.SnapshotParams{
    Snapshot: "my-vm-snapshot",
  })
}

Java

import io.daytona.sdk.Daytona;
import io.daytona.sdk.Sandbox;
import io.daytona.api.client.model.SandboxClass;
import io.daytona.sdk.model.CreateSandboxFromSnapshotParams;

public class App {
    public static void main(String[] args) {
        try (Daytona daytona = new Daytona()) {
            // 1. Create a VM snapshot (linux-vm class)
            daytona.snapshot().create("my-vm-snapshot", "ubuntu:22.04", SandboxClass.LINUX_VM);

            // 2. Create a VM sandbox from the snapshot
            CreateSandboxFromSnapshotParams params = new CreateSandboxFromSnapshotParams();
            params.setSnapshot("my-vm-snapshot");
            Sandbox sandbox = daytona.create(params);
        }
    }
}

CLI

# 1. Create a VM snapshot (linux-vm class)
daytona snapshot create my-vm-snapshot --image ubuntu:22.04 --sandbox-class linux-vm

# 2. Create a VM sandbox from the snapshot
daytona create --snapshot my-vm-snapshot

API

# 1. Create a VM snapshot (linux-vm class)
curl https://app.daytona.io/api/snapshots \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{
    "name": "my-vm-snapshot",
    "imageName": "ubuntu:22.04",
    "sandboxClass": "linux-vm"
  }'

# 2. Create a VM sandbox from the snapshot
curl 'https://app.daytona.io/api/sandbox' \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{
    "snapshot": "my-vm-snapshot"
  }'

Create Windows Sandboxes

Daytona provides methods to create Windows VM sandboxes.

1. Navigate to Daytona Sandboxes ↗

2. Click Create Sandbox

3. Select a Windows snapshot:

   • windows-small
   • windows-medium
   • windows-large

4. Click Create

Python

from daytona import Daytona, CreateSandboxFromSnapshotParams

daytona = Daytona()
sandbox = daytona.create(
    CreateSandboxFromSnapshotParams(
        snapshot="windows-small",
    )
)

TypeScript

import { Daytona } from '@daytona/sdk'

const daytona = new Daytona()
const sandbox = await daytona.create({
  snapshot: 'windows-small',
})

Ruby

require 'daytona'

daytona = Daytona::Daytona.new
sandbox = daytona.create(
  Daytona::CreateSandboxFromSnapshotParams.new(
    snapshot: 'windows-small'
  )
)

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: "windows-small",
  }
  _, _ = 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("windows-small");
            Sandbox sandbox = daytona.create(params);
        }
    }
}

CLI

daytona create --snapshot windows-small

API

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

Create Snapshot from VM Sandbox

Daytona provides methods to create a VM snapshot from an existing Linux or Windows VM sandbox.

A snapshot captures a point-in-time copy of a sandbox that you can use as a base to create new sandboxes. The resulting snapshot inherits the source sandbox’s class and can only create sandboxes of that same class.

VM sandboxes support cold and hot snapshots through the includeMemory parameter:

• Cold snapshot (includeMemory: false, default): captures filesystem state only. The sandbox must be stopped.
• Hot snapshot (includeMemory: true): captures filesystem and memory state. The sandbox must be started. Running applications are preserved and instantly available on any new sandbox created from the snapshot.

Include memory	Snapshot type	Snapshot contents	Required sandbox state
false (default)	Cold	Filesystem only	Stopped
true	Hot	Filesystem and memory	Started

Python

# Cold snapshot (filesystem only, sandbox stopped)
sandbox._experimental_create_snapshot("my-vm-snapshot")

# Hot snapshot (filesystem and memory, sandbox running)
sandbox._experimental_create_snapshot("my-vm-snapshot", include_memory=True)

TypeScript

// Cold snapshot (filesystem only, sandbox stopped)
await sandbox._experimental_createSnapshot('my-vm-snapshot')

// Hot snapshot (filesystem and memory, sandbox running)
await sandbox._experimental_createSnapshot('my-vm-snapshot', 60, true)

Ruby

# Cold snapshot (filesystem only, sandbox stopped)
sandbox.experimental_create_snapshot(name: 'my-vm-snapshot')

# Hot snapshot (filesystem and memory, sandbox running)
sandbox.experimental_create_snapshot(name: 'my-vm-snapshot', include_memory: true)

Go

// Cold snapshot (filesystem only, sandbox stopped)
err := sandbox.ExperimentalCreateSnapshot(ctx, "my-vm-snapshot")
if err != nil {
    return err
}

// Hot snapshot (filesystem and memory, sandbox running)
err = sandbox.ExperimentalCreateSnapshotWithMemory(ctx, "my-vm-snapshot", 60*time.Second)
if err != nil {
    return err
}

Java

// Cold snapshot (filesystem only, sandbox stopped)
sandbox.experimentalCreateSnapshot("my-vm-snapshot");

// Hot snapshot (filesystem and memory, sandbox running)
sandbox.experimentalCreateSnapshot("my-vm-snapshot", 60, true);

API

# Cold snapshot (filesystem only, sandbox stopped)
curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/snapshot' \
  --request POST \
  --header 'X-Daytona-Organization-ID: YOUR_ORGANIZATION_ID' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{
  "name": "my-vm-snapshot",
  "includeMemory": false
}'

# Hot snapshot (filesystem and memory, sandbox running)
curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/snapshot' \
  --request POST \
  --header 'X-Daytona-Organization-ID: YOUR_ORGANIZATION_ID' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{
  "name": "my-vm-snapshot",
  "includeMemory": true
}'

Pause / Resume VM Sandboxes

Daytona provides methods to pause and resume VM sandboxes.

Pausing a VM sandbox preserves its filesystem and memory state, and does not consume CPU. To resume a paused sandbox, start it again; processes continue from where they were paused.

Python

sandbox.pause()

TypeScript

await sandbox.pause()

Ruby

sandbox.pause

Go

sandbox.Pause(ctx)

Java

sandbox.pause();

CLI

daytona pause [SANDBOX_ID] | [SANDBOX_NAME]

API

curl 'https://app.daytona.io/api/sandbox/{sandboxIdOrName}/pause' \
  --request POST \
  --header 'Authorization: Bearer YOUR_API_KEY'