# VM Sandboxes

Daytona provides **VM sandboxes** for workloads that require a full virtual machine with a dedicated [Linux](#create-linux-sandboxes) or [Windows](#create-windows-sandboxes) operating system.

VM sandboxes are distinct from container sandboxes and support VM-only capabilities such as [pause/resume sandboxes](#pause--resume-vm-sandboxes) and [hot/cold snapshots](#create-snapshot-from-vm-sandbox). All other sandbox features and functionality are the same as for container sandboxes.

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


```bash
daytona create --snapshot daytona-vm-small
```


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


```bash
# 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
```


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


```bash
daytona create --snapshot windows-small
```


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


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


```bash
daytona pause [SANDBOX_ID] | [SANDBOX_NAME]
```


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