> ## Documentation Index
> Fetch the complete documentation index at: https://docs.boxlite.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Installation

> Install BoxLite on your system and set up the SDK for your language.

## System requirements

BoxLite runs lightweight micro-VMs and requires hardware virtualization support.

| Platform       | Architecture  | Requirements                        |
| -------------- | ------------- | ----------------------------------- |
| macOS          | Apple Silicon | macOS 12+ (Monterey or later)       |
| Linux          | x86\_64       | KVM enabled (`/dev/kvm` accessible) |
| Linux          | ARM64         | KVM enabled (`/dev/kvm` accessible) |
| Windows (WSL2) | x86\_64       | WSL2 with KVM support               |

<Warning>
  macOS Intel (x86\_64) is **not supported** due to Hypervisor.framework stability issues.
</Warning>

### Verify virtualization support

<Tabs>
  <Tab title="macOS">
    ```bash theme={null}
    # Check macOS version (should be 12+)
    sw_vers

    # Check architecture (should be arm64)
    uname -m
    ```
  </Tab>

  <Tab title="Linux">
    ```bash theme={null}
    # Check if CPU supports virtualization (should show vmx or svm)
    grep -E 'vmx|svm' /proc/cpuinfo

    # Check if KVM is available (should exist and be accessible)
    ls -l /dev/kvm

    # If /dev/kvm doesn't exist, load KVM module
    sudo modprobe kvm
    sudo modprobe kvm_intel  # For Intel CPUs
    sudo modprobe kvm_amd    # For AMD CPUs

    # Add user to kvm group (may require logout/login)
    sudo usermod -aG kvm $USER
    ```
  </Tab>

  <Tab title="Windows (WSL2)">
    ```bash theme={null}
    # Verify you're running WSL2 (should show "2")
    wsl.exe -l -v

    # Check if KVM is available
    ls -l /dev/kvm

    # Add user to kvm group
    sudo usermod -aG kvm $USER

    # Apply the new group membership (pick one):
    newgrp kvm
    # OR restart WSL from Windows PowerShell:
    # wsl.exe --shutdown

    # Verify group membership
    id -nG | tr ' ' '\n' | grep -x kvm

    # Verify KVM access
    python3 -c "open('/dev/kvm','rb').close(); print('kvm ok')"
    ```

    <Note>
      If you see "Timeout waiting for guest ready (30s)" errors, it's likely a KVM permission issue. Ensure your user is in the `kvm` group and restart WSL with `wsl.exe --shutdown`.
    </Note>
  </Tab>
</Tabs>

## Install an SDK

<Tabs>
  <Tab title="Python">
    ```bash theme={null}
    pip install boxlite
    ```

    **Requirements:** Python 3.10+, pip 20.0+

    **Verify:**

    ```bash theme={null}
    python3 -c "import boxlite; print(boxlite.__version__)"
    ```
  </Tab>

  <Tab title="Node.js">
    ```bash theme={null}
    npm install @boxlite-ai/boxlite
    ```

    **Requirements:** Node.js 18+

    **Verify:**

    ```bash theme={null}
    node -e "const b = require('@boxlite-ai/boxlite'); console.log('boxlite loaded')"
    ```
  </Tab>

  <Tab title="Rust">
    Add to your `Cargo.toml`:

    ```toml theme={null}
    [dependencies]
    boxlite = { git = "https://github.com/boxlite-ai/boxlite" }
    tokio = { version = "1", features = ["full"] }
    futures = "0.3"
    ```

    Then run:

    ```bash theme={null}
    cargo build
    ```
  </Tab>

  <Tab title="C">
    The C SDK is built from source:

    ```bash theme={null}
    git clone https://github.com/boxlite-ai/boxlite.git
    cd boxlite
    make build:c
    ```

    **Requirements:** GCC or Clang, CMake 3.15+. On macOS, install Xcode Command Line Tools (`xcode-select --install`).
  </Tab>
</Tabs>

## Next steps

<CardGroup cols={2}>
  <Card title="Python quickstart" icon="python" href="/getting-started/quickstart-python">
    Create your first sandbox, execute code, and explore BoxLite's Python API.
  </Card>

  <Card title="Node.js quickstart" icon="node-js" href="/getting-started/quickstart-nodejs">
    Run commands in isolated VMs with the Node.js SDK and TypeScript support.
  </Card>

  <Card title="Rust quickstart" icon="gear" href="/getting-started/quickstart-rust">
    Use the native Rust crate for performance-critical sandbox workloads.
  </Card>

  <Card title="C quickstart" icon="c" href="/getting-started/quickstart-c">
    Integrate BoxLite into C/C++ applications via the native C API.
  </Card>
</CardGroup>