# Ventoy User Guide

Ventoy is an open-source tool to create bootable USB drives with a fundamentally different approach: install Ventoy to a USB drive once, then simply copy ISO, WIM, IMG, VHD, VHDX, EFI, and other image files directly onto the drive. Boot from any of them without extracting, reformatting, or reflashing. Ventoy supports 900+ tested ISO images across Linux, Windows, BSD, ChromeOS, and other operating systems.

This guide covers everything you need to go from a blank USB drive to a fully configured multi-boot environment with persistence, themes, automated installations, and more.

---

## 1. Quick Start

Get a bootable USB drive in under five minutes.

**What you need:**

| Requirement | Details |
|---|---|
| USB drive | 4 GB minimum (larger for multiple ISOs) |
| Operating system | Windows 7+ or Linux (x86_64, i386, aarch64, mips64el) |
| ISO files | Any bootable `.iso`, `.wim`, `.img`, `.vhd`, `.vhdx`, or `.efi` file |
| Permissions | Administrator (Windows) or root (Linux) |

**Three steps:**

1. **Install Ventoy** to your USB drive (one-time operation)
2. **Copy image files** onto the USB's data partition (drag and drop)
3. **Boot** from the USB — Ventoy presents a menu of all images found

> [!TIP]
> Ventoy does not touch your image files. They remain intact on the USB drive, and you can add, remove, or replace them at any time without reinstalling Ventoy. This is what makes Ventoy fundamentally different from tools like Rufus or Etcher.

**Windows quick path:**

```text
1. Download and extract the Ventoy release zip
2. Run Ventoy2Disk.exe
3. Select your USB drive → click Install
4. Copy your .iso files to the "Ventoy" partition
5. Reboot and select the USB in your BIOS boot menu
```

**Linux quick path:**

```bash
# Extract the release tarball
tar -xzf ventoy-*-linux.tar.gz
cd ventoy-*

# Install to /dev/sdX (replace with your USB device)
sudo bash Ventoy2Disk.sh -i /dev/sdX

# Mount the Ventoy partition and copy ISOs
mount /dev/sdX1 /mnt
cp ~/Downloads/*.iso /mnt/
umount /mnt
```

---

## 2. Supported Image Formats

Ventoy supports booting from the following file formats. Simply copy any of these onto the USB data partition.

| Format | Extension | Use Case |
|---|---|---|
| ISO 9660 | `.iso` | Linux distros, Windows installers, live CDs, rescue disks |
| Windows Imaging | `.wim` | Windows PE, Windows deployment images |
| Raw Disk Image | `.img` | Disk images, embedded Linux, Raspberry Pi images |
| Virtual Hard Disk | `.vhd` | Hyper-V images, Windows VHD boot |
| Virtual Hard Disk v2 | `.vhdx` | Newer Hyper-V format images |
| EFI Executable | `.efi` | UEFI shell, firmware utilities, EFI applications |
| Ventoy Auto | `.vtoy` | Ventoy-specific auto-install packages |
| Persistence Data | `.dat` | Persistence overlay files (used alongside ISOs) |

> [!IMPORTANT]
> Image files can be placed in any directory on the USB data partition, including subdirectories. Ventoy recursively scans the entire partition. You can organize your ISOs however you like — by distro, by purpose, or in a flat layout.

**Ventoy Link files** (`.vlnk.*`) provide an additional layer of flexibility. A vlnk file is a small pointer that references a full image stored elsewhere. Supported vlnk extensions: `.vlnk.iso`, `.vlnk.img`, `.vlnk.wim`, `.vlnk.vhd`, `.vlnk.vhdx`, `.vlnk.efi`, `.vlnk.vtoy`, `.vlnk.dat`. See the Ventoy Link (Vlnk) section for details.

---

## 3. Installation

### 3.1 Windows Installation (GUI)

The Windows installer is a standalone GUI application. No installation to your PC is required.

**Step-by-step:**

1. Download the latest Ventoy release from the official GitHub releases page
2. Extract the zip archive to any folder
3. Run `Ventoy2Disk.exe` (for 32-bit systems) or use the 64-bit variant from the `altexe/` folder:

| Executable | Architecture |
|---|---|
| `Ventoy2Disk.exe` | x86 (32-bit, runs on all Windows) |
| `altexe/Ventoy2Disk_X64.exe` | x86_64 (64-bit native) |
| `altexe/Ventoy2Disk_ARM64.exe` | ARM64 (Surface Pro X, etc.) |

4. In the GUI:
   - Select your USB drive from the device dropdown
   - Choose partition style: **MBR** (default, best compatibility) or **GPT** (required for drives over 2 TB)
   - Choose whether to enable **Secure Boot** support
   - Click **Install** for a fresh install, or **Update** to upgrade Ventoy while preserving your files

> [!WARNING]
> Installing Ventoy to a USB drive will **erase all existing data** on that drive. Back up any important files first. The Update operation preserves your data partition and only replaces the Ventoy boot files.

> [!IMPORTANT]
> Some antivirus software may flag Ventoy as suspicious because it writes directly to disk boot sectors. This is a false positive. Ventoy is open source with verifiable code. If your AV blocks the installer, add an exception for `Ventoy2Disk.exe`. See the Troubleshooting section for more details on antivirus false positives.

5. After installation completes, the USB drive appears with two partitions:
   - **Ventoy** (exFAT) — your data partition, where you copy ISO files
   - **VTOYEFI** (FAT16, 32 MB) — Ventoy's boot partition (do not modify unless enrolling Secure Boot keys)

6. Copy your ISO/WIM/IMG/VHD files to the Ventoy partition
7. Safely eject the USB drive

### 3.2 Linux Installation (CLI)

The primary Linux installation method is the `Ventoy2Disk.sh` shell script, which must be run as root.

```bash
# Extract the release
tar -xzf ventoy-*-linux.tar.gz
cd ventoy-*

# View usage
sudo bash Ventoy2Disk.sh
```

**Full command reference:**

```text
Usage:  Ventoy2Disk.sh CMD [ OPTION ] /dev/sdX

  CMD (exactly one required):
    -i   Install Ventoy to sdX (fails if Ventoy is already installed)
    -I   Force install Ventoy to sdX (overwrites even if already installed)
    -u   Update Ventoy in sdX (preserves data partition)
    -l   List Ventoy information in sdX (non-destructive, read-only)

  OPTION (all optional):
    -r SIZE_MiB   Preserve space at bottom of disk (install only)
    -s            Enable secure boot support (default: enabled)
    -S            Disable secure boot support
    -g            Use GPT partition style (default: MBR, install only)
    -L LABEL      Set label of the data partition (default: "Ventoy")
    -n            Try non-destructive installation (install only)
```

**Common installation examples:**

```bash
# Standard MBR install with secure boot
sudo bash Ventoy2Disk.sh -i /dev/sdb

# GPT install for a 4TB drive
sudo bash Ventoy2Disk.sh -i -g /dev/sdb

# Install preserving 32GB at end for a secondary partition
sudo bash Ventoy2Disk.sh -i -r 32768 /dev/sdb

# Non-destructive install attempt (preserves existing data if possible)
sudo bash Ventoy2Disk.sh -i -n /dev/sdb

# Force reinstall (when -i refuses because Ventoy is already present)
sudo bash Ventoy2Disk.sh -I /dev/sdb

# Update Ventoy (keeps all your ISOs)
sudo bash Ventoy2Disk.sh -u /dev/sdb

# Check what's on the drive
sudo bash Ventoy2Disk.sh -l /dev/sdb

# Install with custom partition label
sudo bash Ventoy2Disk.sh -i -L "BOOTUSB" /dev/sdb

# Install without secure boot
sudo bash Ventoy2Disk.sh -i -S /dev/sdb
```

> [!WARNING]
> Always double-check the device name (`/dev/sdX`) before running install commands. Installing to the wrong device will destroy data on that device. Use `lsblk` or `fdisk -l` to identify the correct USB drive.

**Identifying your USB device:**

```bash
# List all block devices with sizes and mount points
lsblk -o NAME,SIZE,TYPE,MOUNTPOINT

# Or use fdisk for more detail
sudo fdisk -l
```

### 3.3 Linux Installation (Web UI)

For users who prefer a graphical interface on Linux, Ventoy provides a local web-based UI.

```bash
# Launch the web UI server
sudo bash VentoyWeb.sh

# Opens browser to http://127.0.0.1:24680 automatically
```

**VentoyWeb.sh options:**

| Option | Default | Description |
|---|---|---|
| `-H x.x.x.x` | `127.0.0.1` | Bind address (use `0.0.0.0` for network access) |
| `-p PORT` | `24680` | HTTP port number |

```bash
# Bind to all interfaces on port 8080
sudo bash VentoyWeb.sh -H 0.0.0.0 -p 8080
```

The web UI provides the same functionality as the CLI: install, update, and list, with a visual device selector and partition style options.

### 3.4 Linux Installation (Native GUI)

Platform-native GUI applications are available for multiple architectures:

| Binary | Architecture |
|---|---|
| `VentoyGUI.x86_64` | 64-bit Intel/AMD |
| `VentoyGUI.i386` | 32-bit Intel/AMD |
| `VentoyGUI.aarch64` | 64-bit ARM (Raspberry Pi 4, etc.) |
| `VentoyGUI.mips64el` | 64-bit MIPS little-endian |

GTK2, GTK3, and QT5 toolkit variants are included. The launcher auto-detects the best toolkit for your desktop environment.

```bash
# Run the native GUI (must be root)
sudo ./VentoyGUI.x86_64
```

### 3.5 LiveCD Installation

Ventoy is available as a LiveCD ISO image. Boot it from any existing bootable media (including another Ventoy USB) to install Ventoy to a different USB drive. This is useful when you lack a running operating system or want to install Ventoy from a machine with no OS installed.

### 3.6 Non-Destructive Installation

The `-n` flag attempts to install Ventoy without erasing the existing data on the USB drive. This works by shrinking the existing partition and creating the Ventoy boot partition in the freed space.

```bash
sudo bash Ventoy2Disk.sh -i -n /dev/sdb
```

**Requirements for non-destructive install:**

- The USB must have a single partition
- Sufficient free space must exist at the end of the partition to create the 32 MB VTOYEFI partition
- The existing filesystem must support online shrinking

> [!NOTE]
> Non-destructive installation does not always succeed. If the filesystem cannot be safely shrunk, Ventoy will report an error without modifying the drive. Always have a backup of important data regardless.

### 3.7 Partition Layout

After installation, Ventoy creates this disk layout:

```text
+------------------------------------------------------------------+
| USB Drive                                                        |
| +---------------------------------------------+  +-----------+  |
| | Partition 1: Data (exFAT)                    |  | Part 2:   |  |
| | Label: "Ventoy" (default)                    |  | VTOYEFI   |  |
| | Contains: your ISO/WIM/IMG/VHD files         |  | 32MB FAT16|  |
| | + optional ventoy/ config directory           |  | Boot files|  |
| +---------------------------------------------+  +-----------+  |
+------------------------------------------------------------------+
```

| Detail | Value |
|---|---|
| Partition 1 filesystem | exFAT (default) |
| Partition 1 label | "Ventoy" (customizable with `-L`) |
| Partition 2 filesystem | FAT16 |
| Partition 2 size | 32 MB |
| Partition 2 label | VTOYEFI |
| Default partition style | MBR |
| Cluster size (drives > 32 GB) | 128 KB |
| Cluster size (drives <= 32 GB) | 32 KB |

> [!CAUTION]
> Disks larger than 2 TB **must** use GPT partition style (`-g` flag). MBR cannot address beyond 2 TB. Additionally, USB drives with 4K native sectors are **not supported** — Ventoy requires 512-byte or 512e sector drives.

### 3.8 Updating Ventoy

Updates preserve your data partition completely. Only the Ventoy boot files on the VTOYEFI partition are replaced.

**Windows:** Click the **Update** button in Ventoy2Disk.exe.

**Linux:**

```bash
sudo bash Ventoy2Disk.sh -u /dev/sdb
```

Your ISO files, configuration directory, persistence images, and all other data on the Ventoy partition remain untouched.

---

## 4. Basic Usage

### 4.1 Adding Boot Images

After installing Ventoy, mount the USB data partition (labeled "Ventoy") and copy any supported image files onto it.

**Windows:** The Ventoy partition appears as a regular drive letter in File Explorer. Drag and drop files.

**Linux:**

```bash
# Mount the data partition
sudo mount /dev/sdb1 /mnt

# Copy ISOs
cp ~/Downloads/ubuntu-24.04-desktop-amd64.iso /mnt/
cp ~/Downloads/Win11_24H2_English_x64.iso /mnt/
cp ~/Downloads/archlinux-2024.12.01-x86_64.iso /mnt/

# Unmount safely
sudo umount /mnt
```

> [!TIP]
> Organize images into subdirectories for cleaner menus. Ventoy scans recursively, so a structure like `Linux/Ubuntu/`, `Linux/Fedora/`, `Windows/` works perfectly. The boot menu reflects the directory structure with a tree-view browser.

### 4.2 Booting

1. Insert the USB drive into the target computer
2. Enter the BIOS/UEFI boot menu (typically F2, F12, Del, or Esc during POST)
3. Select the USB drive as the boot device
4. Ventoy's GRUB2 menu appears listing all detected images
5. Select an image and press Enter to boot

**Boot modes:**

| Mode | Mechanism | Supported |
|---|---|---|
| Legacy BIOS (CSM) | GRUB2 | Yes |
| UEFI | EDK2 + GRUB2 | Yes |
| UEFI Secure Boot | EDK2 + MOK enrollment | Yes (see Secure Boot section) |
| iPXE (network) | iPXE chainload | Yes |

### 4.3 Boot Menu Navigation

| Key | Action |
|---|---|
| Arrow keys | Navigate menu entries |
| Enter | Boot selected image |
| F5 | Tools menu (language, resolution, etc.) |
| `/` or `Ctrl+F` | Search/filter by filename |
| Tab | Switch between directory browsing and flat list |

> [!TIP]
> Press F5 to access Ventoy's tools menu. From there you can change the display language, switch between list and tree view mode, and configure display resolution for the boot menu.

### 4.4 Removing or Replacing Images

Simply delete or overwrite files on the Ventoy data partition. No reconfiguration is needed. The next boot will reflect whatever images are currently on the drive.

```bash
# Remove an image
rm /mnt/old-distro.iso

# Replace with a newer version
cp ~/Downloads/ubuntu-25.04-desktop-amd64.iso /mnt/
```

### 4.5 Multi-Boot Setup

Ventoy inherently supports multi-boot. Every image file on the data partition appears in the boot menu. There is no practical limit beyond available disk space.

**Example setup on a 128 GB USB drive:**

```text
Ventoy (USB Data Partition)
├── Linux/
│   ├── ubuntu-24.04-desktop-amd64.iso         (4.7 GB)
│   ├── fedora-workstation-41-x86_64.iso       (2.1 GB)
│   ├── archlinux-2024.12.01-x86_64.iso        (850 MB)
│   ├── debian-12.8-amd64-netinst.iso          (630 MB)
│   └── linuxmint-22-cinnamon-64bit.iso        (2.8 GB)
├── Windows/
│   ├── Win11_24H2_English_x64.iso             (5.3 GB)
│   └── Win10_22H2_English_x64.iso             (4.8 GB)
├── Rescue/
│   ├── systemrescue-11.02-amd64.iso           (780 MB)
│   ├── clonezilla-live-3.1.3-11-amd64.iso     (350 MB)
│   └── gparted-live-1.6.0-1-amd64.iso         (510 MB)
├── persistence.dat                             (4 GB)
└── ventoy/
    └── ventoy.json                            (config file)
```

---

## 5. Persistence

Persistence allows you to save changes made during a live session so they survive reboots. Without persistence, a live Linux session starts fresh every time.

### 5.1 Creating a Persistence Image

Ventoy includes `CreatePersistentImg.sh` for creating persistence overlay files.

```text
Usage:  sudo ./CreatePersistentImg.sh [ -s size ] [ -t fstype ] [ -l LABEL ] [ -c CFG ] [ -o FILE ] [ -e ]

Options:
  -s SIZE     Size in MB (default: 1024)
  -t FSTYPE   Filesystem type: ext2, ext3, ext4, xfs (default: ext4)
  -l LABEL    Filesystem label (default: casper-rw)
  -c CFG      Config filename inside the image (content: "/ union")
  -o FILE     Output filename (default: persistence.dat)
  -e          Enable encryption (LUKS — limited distro support)
```

**Common examples:**

```bash
# Default 1 GB ext4 persistence image
sudo bash CreatePersistentImg.sh

# 4 GB persistence for Ubuntu
sudo bash CreatePersistentImg.sh -s 4096 -l casper-rw

# 8 GB persistence for Debian/Kali (uses "persistence" label)
sudo bash CreatePersistentImg.sh -s 8192 -l persistence -c persistence.conf

# 2 GB XFS persistence (minimum 16 MB for XFS)
sudo bash CreatePersistentImg.sh -s 2048 -t xfs

# Encrypted persistence
sudo bash CreatePersistentImg.sh -s 4096 -e

# Custom output filename
sudo bash CreatePersistentImg.sh -s 4096 -o ubuntu_persist.dat
```

> [!IMPORTANT]
> XFS filesystems have a minimum size of 16 MB. Creating a persistence image smaller than 16 MB with `-t xfs` will fail.

### 5.2 Configuring Persistence

After creating the persistence image, copy it to your Ventoy USB drive. Then configure `ventoy/ventoy.json` to associate it with a specific ISO.

Create or edit `ventoy/ventoy.json` on the USB data partition:

```json
{
    "persistence": [
        {
            "image": "/Linux/ubuntu-24.04-desktop-amd64.iso",
            "backend": "/persistence.dat"
        },
        {
            "image": "/Linux/linuxmint-22-cinnamon-64bit.iso",
            "backend": "/mint_persistence.dat"
        }
    ]
}
```

**Persistence label requirements by distro:**

| Distribution | Expected Label | Config File |
|---|---|---|
| Ubuntu / Linux Mint | `casper-rw` | None needed |
| Debian / Kali | `persistence` | `persistence.conf` (content: `/ union`) |
| Fedora | `overlay-LIVE` | None needed |
| MX Linux | `MX-rundir` | None needed |
| openSUSE | `persistence` | None needed |

### 5.3 Resizing Persistence Images

Use `ExtendPersistentImg.sh` to grow or shrink existing persistence images.

```text
Usage:  ExtendPersistentImg.sh file size

  file   Persistent .dat file
  size   Size change in MB (positive to grow, negative to shrink)
```

```bash
# Grow by 2 GB
sudo bash ExtendPersistentImg.sh persistence.dat 2048

# Shrink by 1 GB
sudo bash ExtendPersistentImg.sh persistence.dat -1024
```

> [!WARNING]
> XFS filesystems do **not** support shrinking. Attempting to shrink an XFS persistence image will fail. Only ext2/ext3/ext4 images can be shrunk.

### 5.4 Encrypted Persistence

The `-e` flag creates a LUKS-encrypted persistence image. On boot, the live system prompts for a passphrase before mounting the persistence overlay.

```bash
sudo bash CreatePersistentImg.sh -s 4096 -e -l casper-rw
```

> [!NOTE]
> Encrypted persistence is only supported by distros whose initramfs includes LUKS/cryptsetup support. Ubuntu and Debian derivatives generally work. Some minimal or specialized distros do not.

---

## 6. Plugin Configuration (VentoyPlugson)

VentoyPlugson is a web-based configuration UI for managing Ventoy's plugin system. It provides a graphical editor for `ventoy/ventoy.json` and other configuration files stored in the `ventoy/` directory on the USB data partition.

### 6.1 Launching VentoyPlugson

**Linux:**

```bash
sudo bash VentoyPlugson.sh /dev/sdb
```

| Option | Default | Description |
|---|---|---|
| `-H x.x.x.x` | `127.0.0.1` | Bind address |
| `-P PORT` | `24681` | HTTP port |

```bash
# Accessible from other machines on the network
sudo bash VentoyPlugson.sh -H 0.0.0.0 -P 9090 /dev/sdb
```

**Windows:**

Run `VentoyPlugson.exe` (or `VentoyPlugson_X64.exe` from `altexe/`). Select the USB drive letter and launch.

### 6.2 What Plugson Configures

VentoyPlugson provides a GUI for configuring these features (each corresponds to a section or file in the `ventoy/` directory):

| Feature | Config Location | Purpose |
|---|---|---|
| Theme | `ventoy/theme/` | GRUB2 boot menu themes |
| Auto Install | `ventoy/ventoy.json` | Unattended install scripts per ISO |
| Persistence | `ventoy/ventoy.json` | Persistence backends per ISO |
| Menu Alias | `ventoy/ventoy.json` | Custom display names for ISOs |
| Menu Class | `ventoy/ventoy.json` | Icon classes for ISOs |
| Menu Tip | `ventoy/ventoy.json` | Hover tooltip text |
| Menu Extension | `ventoy/ventoy.json` | Custom GRUB2 menu entries |
| Image List | `ventoy/ventoy.json` | Whitelist/blacklist of images |
| DUD (Driver Update Disk) | `ventoy/ventoy.json` | Driver disks for installers |
| Password | `ventoy/ventoy.json` | Boot menu or per-image passwords |
| Conf Replace | `ventoy/ventoy.json` | Replace GRUB config at boot |
| Injection | `ventoy/ventoy.json` | Inject files into ISO at boot |
| Auto Memdisk | `ventoy/ventoy.json` | Force memdisk boot for small ISOs |

### 6.3 Configuration File (ventoy.json)

All plugin configuration lives in `ventoy/ventoy.json` on the USB data partition. You can edit it manually or through VentoyPlugson. The file uses standard JSON.

**Minimal example:**

```json
{
    "control": [
        { "VTOY_DEFAULT_SEARCH_ROOT": "/Linux" },
        { "VTOY_MENU_TIMEOUT": "10" }
    ],
    "theme": {
        "file": "/ventoy/theme/blur/theme.txt",
        "gfxmode": "1920x1080"
    },
    "persistence": [
        {
            "image": "/Linux/ubuntu-24.04-desktop-amd64.iso",
            "backend": "/persistence.dat"
        }
    ],
    "menu_alias": [
        {
            "image": "/Linux/ubuntu-24.04-desktop-amd64.iso",
            "alias": "Ubuntu 24.04 LTS Desktop"
        }
    ]
}
```

> [!TIP]
> Use VentoyPlugson instead of hand-editing `ventoy.json` to avoid JSON syntax errors. If you do edit manually, validate the JSON with a tool like `jq . ventoy/ventoy.json` before rebooting.

---

## 7. Themes

Ventoy uses GRUB2's theming system to customize the boot menu appearance.

### 7.1 Installing a Theme

1. Download a GRUB2 theme (many are available on gnome-look.org or GitHub)
2. Create the directory `ventoy/theme/` on the USB data partition
3. Extract the theme files there
4. Configure the theme in `ventoy/ventoy.json`:

```json
{
    "theme": {
        "file": "/ventoy/theme/mytheme/theme.txt",
        "gfxmode": "1920x1080",
        "ventoy_left": "5%",
        "ventoy_top": "20%",
        "ventoy_color": "#ffffff"
    }
}
```

### 7.2 Theme Configuration Options

| Key | Description | Example |
|---|---|---|
| `file` | Path to theme.txt on the USB | `/ventoy/theme/blur/theme.txt` |
| `gfxmode` | Screen resolution | `1920x1080`, `1024x768`, `auto` |
| `ventoy_left` | Menu horizontal position | `5%`, `100` |
| `ventoy_top` | Menu vertical position | `20%`, `200` |
| `ventoy_color` | Menu text color | `#ffffff`, `#000000` |
| `fonts` | Custom fonts for the theme | Array of font file paths |

### 7.3 Boot Menu Background

For a simpler customization without a full theme, place a background image:

```text
ventoy/background.png     (or .jpg, .jpeg)
```

Supported resolutions depend on your display. Common choices: 1920x1080, 1280x720.

---

## 8. Auto Installation

Ventoy can pass unattended installation answer files to ISOs, enabling fully automated OS installations.

### 8.1 Supported Auto Install Formats

| OS / Installer | Answer File Format |
|---|---|
| Ubuntu / Debian | Preseed (`preseed.cfg`) or Cloud-Init (`autoinstall`) |
| RHEL / Fedora / CentOS | Kickstart (`.ks` or `.cfg`) |
| SUSE / openSUSE | AutoYaST (`.xml`) |
| Windows | `autounattend.xml` |
| Arch Linux | Archinstall config or custom scripts |
| Alpine | `setup-alpine` answer file |

### 8.2 Configuring Auto Install

1. Place your answer file on the USB data partition (anywhere you like)
2. Map it to a specific ISO in `ventoy/ventoy.json`:

```json
{
    "auto_install": [
        {
            "image": "/Windows/Win11_24H2_English_x64.iso",
            "template": "/ventoy/autoinstall/autounattend.xml"
        },
        {
            "image": "/Linux/ubuntu-24.04-live-server-amd64.iso",
            "template": "/ventoy/autoinstall/ubuntu-autoinstall.yaml"
        },
        {
            "image": "/Linux/fedora-server-41-x86_64.iso",
            "template": "/ventoy/autoinstall/fedora-ks.cfg"
        }
    ]
}
```

3. When you boot the mapped ISO, Ventoy injects the answer file so the installer picks it up automatically

### 8.3 Multiple Auto Install Templates

You can provide multiple templates for a single ISO. At boot time, Ventoy presents a selection menu so you can choose which template to use:

```json
{
    "auto_install": [
        {
            "image": "/Windows/Win11_24H2_English_x64.iso",
            "template": [
                "/ventoy/autoinstall/win11_standard.xml",
                "/ventoy/autoinstall/win11_minimal.xml",
                "/ventoy/autoinstall/win11_developer.xml"
            ]
        }
    ]
}
```

> [!TIP]
> For Windows automated installations, place the `autounattend.xml` file via the auto_install configuration rather than directly in the ISO root. This keeps your ISO files pristine and lets you swap answer files without modifying the ISO.

---

## 9. Ventoy Link (Vlnk)

Ventoy Link (vlnk) files are small pointer files that reference full images stored elsewhere — on a different partition, a network share, or a different path. This is useful when your ISOs are too large for the USB or when you want to reference images on a local hard drive.

### 9.1 Creating Vlnk Files

**Linux:**

```bash
# Create a vlnk pointing to a local ISO
sudo sh VentoyVlnk.sh -c /path/to/large-image.iso

# This creates large-image.vlnk.iso in the current directory
```

**Windows:**

Run `VentoyVlnk.exe` and browse to select the target file.

### 9.2 Vlnk Command Reference

```text
Usage:  sudo sh VentoyVlnk.sh CMD FILE

  -c FILE    Create a vlnk file pointing to FILE
  -l VLNK    Parse and display info about a vlnk file
  -v         Print verbose information
```

### 9.3 Supported Vlnk Formats

| Vlnk Extension | Points To |
|---|---|
| `.vlnk.iso` | ISO images |
| `.vlnk.img` | Raw disk images |
| `.vlnk.wim` | Windows imaging files |
| `.vlnk.vhd` | Virtual hard disks |
| `.vlnk.vhdx` | Virtual hard disks v2 |
| `.vlnk.efi` | EFI executables |
| `.vlnk.vtoy` | Ventoy packages |
| `.vlnk.dat` | Persistence data files |

Copy the generated `.vlnk.*` file onto your Ventoy USB drive. It appears in the boot menu like a normal image but takes up only a few bytes of space on the USB.

---

## 10. Secure Boot

Ventoy supports UEFI Secure Boot through MOK (Machine Owner Key) enrollment.

### 10.1 How Ventoy Secure Boot Works

When Secure Boot is enabled in UEFI firmware, only signed bootloaders are allowed to execute. Ventoy ships with a shim bootloader that is signed by a Microsoft-recognized CA, but Ventoy's own GRUB modules require enrolling Ventoy's MOK key.

### 10.2 Enrolling the MOK Key (First Boot)

On the first boot with Secure Boot enabled:

1. The system boots into the MOK Manager (a blue screen interface)
2. Select **Enroll Key from Disk**
3. Navigate to the VTOYEFI partition
4. Select `ENROLL_THIS_KEY_IN_MOKMANAGER.cer`
5. Confirm enrollment
6. Reboot

After enrollment, Ventoy boots normally with Secure Boot enabled on that machine. The key enrollment is a one-time process per machine.

### 10.3 Enabling/Disabling Secure Boot Support

**During installation:**

```bash
# Enable secure boot (default)
sudo bash Ventoy2Disk.sh -i -s /dev/sdb

# Disable secure boot
sudo bash Ventoy2Disk.sh -i -S /dev/sdb
```

**After installation:** Use the Windows GUI or VentoyWeb.sh to toggle Secure Boot support.

> [!NOTE]
> Disabling Secure Boot support in Ventoy means the USB will not boot on machines that require Secure Boot. If your target machine has Secure Boot mandatory (like many corporate-managed PCs), keep it enabled.

---

## 11. Reserved Space

The `-r` flag during installation reserves space at the end of the USB drive, after the Ventoy data partition. This reserved space can be used for a third partition that you manage independently.

### 11.1 Creating Reserved Space

```bash
# Reserve 32 GB at the end
sudo bash Ventoy2Disk.sh -i -r 32768 /dev/sdb
```

### 11.2 Use Cases

- **Encrypted volume:** Create a LUKS-encrypted partition in the reserved space for sensitive files
- **Swap partition:** Useful for live Linux sessions on machines with limited RAM
- **Secondary data:** Regular ext4/NTFS partition for non-boot files

After Ventoy installation, use `fdisk`, `parted`, or `gparted` to create a partition in the free space:

```bash
# Create a partition in the reserved space
sudo fdisk /dev/sdb
# Use 'n' to create a new partition in the unallocated space

# Format it
sudo mkfs.ext4 /dev/sdb3
```

---

## 12. Menu Customization

### 12.1 Menu Aliases

Give your images human-friendly names instead of displaying raw filenames:

```json
{
    "menu_alias": [
        {
            "image": "/Linux/ubuntu-24.04-desktop-amd64.iso",
            "alias": "Ubuntu 24.04 LTS Desktop"
        },
        {
            "image": "/Windows/Win11_24H2_English_x64.iso",
            "alias": "Windows 11 (24H2)"
        },
        {
            "image": "/Rescue/systemrescue-11.02-amd64.iso",
            "alias": "System Rescue Toolkit"
        }
    ]
}
```

### 12.2 Menu Tips

Add tooltip text that appears when hovering over or selecting a menu entry:

```json
{
    "menu_tip": [
        {
            "image": "/Linux/ubuntu-24.04-desktop-amd64.iso",
            "tip": "Full Ubuntu desktop experience. Use persistence for saved changes."
        }
    ]
}
```

### 12.3 Menu Classes (Icons)

Assign icon classes to menu entries. Theme icons are matched by class name:

```json
{
    "menu_class": [
        {
            "image": "/Linux/ubuntu-24.04-desktop-amd64.iso",
            "class": "ubuntu"
        },
        {
            "image": "/Linux/fedora-workstation-41-x86_64.iso",
            "class": "fedora"
        },
        {
            "image": "/Windows/Win11_24H2_English_x64.iso",
            "class": "windows"
        }
    ]
}
```

### 12.4 Image Whitelist and Blacklist

Control which images appear in the boot menu:

```json
{
    "image_list": [
        {
            "type": "white",
            "list": [
                "/Linux/ubuntu-24.04-desktop-amd64.iso",
                "/Windows/Win11_24H2_English_x64.iso"
            ]
        }
    ]
}
```

- `"type": "white"` — only listed images appear
- `"type": "black"` — listed images are hidden

### 12.5 Default Search Root

Restrict Ventoy to only scan a specific directory instead of the entire partition:

```json
{
    "control": [
        { "VTOY_DEFAULT_SEARCH_ROOT": "/Linux" }
    ]
}
```

### 12.6 Boot Menu Timeout

Set automatic boot after a timeout:

```json
{
    "control": [
        { "VTOY_MENU_TIMEOUT": "30" }
    ]
}
```

The value is in seconds. After the timeout, the first (or default) entry boots automatically.

### 12.7 Default Boot Entry

```json
{
    "control": [
        { "VTOY_DEFAULT_IMAGE": "/Linux/ubuntu-24.04-desktop-amd64.iso" }
    ]
}
```

---

## 13. Multi-Language Support

Ventoy's boot menu supports multiple languages through the GRUB2 localization system.

### 13.1 Changing Language at Boot

Press **F5** during the boot menu to access the tools menu, then select language. The menu text, help messages, and navigation labels change to the selected language.

### 13.2 Setting Default Language

Place a `languages.json` configuration or set the language via VentoyPlugson. The language preference persists across reboots.

---

## 14. Advanced Boot Options

### 14.1 Memdisk Mode

For small ISOs or ISOs that have compatibility issues, Ventoy can load the entire image into RAM before booting (memdisk mode). This is slower for large images but resolves compatibility issues with some ISOs that cannot read from a Ventoy-mounted USB.

Configure automatic memdisk for specific ISOs:

```json
{
    "auto_memdisk": [
        "/Rescue/small-rescue-tool.iso"
    ]
}
```

Or use the interactive boot menu: highlight an image, press Enter, and select "memdisk" mode from the submenu.

### 14.2 File Injection

Inject additional files into an ISO at boot time without modifying the original image:

```json
{
    "injection": [
        {
            "image": "/Linux/archlinux-2024.12.01-x86_64.iso",
            "archive": "/ventoy/inject/arch_drivers.zip"
        }
    ]
}
```

The archive contents are overlaid onto the ISO's filesystem at boot.

### 14.3 GRUB Configuration Replacement

Replace the ISO's built-in GRUB configuration with a custom one:

```json
{
    "conf_replace": [
        {
            "image": "/Linux/custom-distro.iso",
            "org": "/EFI/BOOT/grub.cfg",
            "new": "/ventoy/grubcfg/custom-grub.cfg"
        }
    ]
}
```

### 14.4 Driver Update Disk (DUD)

Inject driver update disks during Linux installations:

```json
{
    "dud": [
        {
            "image": "/Linux/sles-15-sp5-x86_64.iso",
            "dud": "/ventoy/dud/storage-driver.iso"
        }
    ]
}
```

### 14.5 Password Protection

Protect the entire boot menu or specific images with a password:

**Global password (protects the boot menu itself):**

```json
{
    "password": {
        "bootpwd": "your-password-here"
    }
}
```

**Per-image password:**

```json
{
    "password": {
        "isopwd": [
            {
                "image": "/Windows/Win11_24H2_English_x64.iso",
                "pwd": "admin-password"
            }
        ]
    }
}
```

> [!CAUTION]
> Passwords in `ventoy.json` are stored in plain text on the USB's data partition, which is an unencrypted exFAT volume. Anyone with physical access to the USB can read the configuration file and extract passwords. This feature protects against casual unauthorized boot, not against determined attackers.

### 14.6 VHD Boot

Ventoy supports booting VHD and VHDX files directly. This is particularly useful for Windows-to-Go environments:

1. Create a VHD/VHDX file with a Windows installation
2. Copy it to the Ventoy USB data partition
3. Boot from the Ventoy menu — select the VHD file

The VHD file appears in the Ventoy boot menu alongside ISOs. Windows boots natively from the VHD using Hyper-V's VHD boot mechanism.

### 14.7 WIM Boot

Windows WIM files are booted using wimboot. This is useful for Windows PE environments, Windows recovery, and deployment scenarios.

1. Copy the `.wim` file to the Ventoy USB
2. Select it from the boot menu
3. Ventoy uses wimboot to load the Windows PE environment

### 14.8 iPXE Network Boot

Ventoy includes iPXE for network boot scenarios. From the Ventoy boot menu, you can chainload into iPXE to boot from a network server. This is useful for PXE environments where the USB serves as a fallback or bootstrap device.

---

## 15. Control Variables

Ventoy supports a set of control variables that modify behavior. Set them in the `control` array of `ventoy.json`:

| Variable | Values | Description |
|---|---|---|
| `VTOY_DEFAULT_SEARCH_ROOT` | Directory path | Only scan this directory for images |
| `VTOY_MENU_TIMEOUT` | Seconds | Auto-boot timeout |
| `VTOY_DEFAULT_IMAGE` | Image path | Default image to boot |
| `VTOY_DEFAULT_KBD_LAYOUT` | Layout code | Keyboard layout for GRUB menu |
| `VTOY_WIN11_BYPASS_CHECK` | `1` / `0` | Bypass Windows 11 TPM/RAM/Secure Boot checks |
| `VTOY_WIN11_BYPASS_NRO` | `1` / `0` | Bypass Windows 11 network requirement (OOBE) |
| `VTOY_LINUX_REMOUNT` | `1` / `0` | Remount Ventoy partition in Linux live session |
| `VTOY_FILE_FLT_EFI` | `1` / `0` | Filter EFI files from menu |
| `VTOY_SORT_CASE_SENSITIVE` | `1` / `0` | Case-sensitive menu sorting |
| `VTOY_MAX_SEARCH_LEVEL` | Number | Maximum directory recursion depth |
| `VTOY_TREE_VIEW_MENU_STYLE` | `1` / `0` | Default to tree view layout |

**Example — Windows 11 bypass:**

```json
{
    "control": [
        { "VTOY_WIN11_BYPASS_CHECK": "1" },
        { "VTOY_WIN11_BYPASS_NRO": "1" }
    ]
}
```

> [!TIP]
> The Windows 11 bypass variables are among the most commonly used. `VTOY_WIN11_BYPASS_CHECK` skips TPM 2.0, Secure Boot, and RAM requirement checks during installation. `VTOY_WIN11_BYPASS_NRO` skips the mandatory Microsoft account / network connection during the out-of-box experience (OOBE).

---

## 16. Workflows and Recipes

### 16.1 IT Technician Multi-Tool USB

Build a single USB drive for any situation:

```bash
# Use a 256GB USB with GPT for future-proofing
sudo bash Ventoy2Disk.sh -i -g /dev/sdb
```

```text
Ventoy USB Layout:
├── Windows/
│   ├── Win11_24H2_English_x64.iso
│   ├── Win10_22H2_English_x64.iso
│   └── WinPE_amd64.wim
├── Linux/
│   ├── ubuntu-24.04-desktop-amd64.iso
│   ├── fedora-workstation-41-x86_64.iso
│   └── debian-12.8-amd64-netinst.iso
├── Rescue/
│   ├── systemrescue-11.02-amd64.iso
│   ├── clonezilla-live-3.1.3-11-amd64.iso
│   ├── memtest86plus.iso
│   └── gparted-live-1.6.0-1-amd64.iso
├── Network/
│   └── ipxe.efi
└── ventoy/
    └── ventoy.json
```

```json
{
    "control": [
        { "VTOY_WIN11_BYPASS_CHECK": "1" },
        { "VTOY_WIN11_BYPASS_NRO": "1" },
        { "VTOY_MENU_TIMEOUT": "30" }
    ],
    "menu_alias": [
        { "image": "/Windows/Win11_24H2_English_x64.iso", "alias": "Windows 11 Installer" },
        { "image": "/Rescue/systemrescue-11.02-amd64.iso", "alias": "System Rescue" },
        { "image": "/Rescue/clonezilla-live-3.1.3-11-amd64.iso", "alias": "Clonezilla (Backup/Restore)" }
    ]
}
```

### 16.2 Distro Hopper Setup

For testing many Linux distributions:

```bash
# Large USB, standard MBR install
sudo bash Ventoy2Disk.sh -i /dev/sdb

# Create persistence for your main distro
sudo bash CreatePersistentImg.sh -s 8192 -l casper-rw -o ubuntu_persist.dat
cp ubuntu_persist.dat /mnt/
```

```json
{
    "persistence": [
        {
            "image": "/ubuntu-24.04-desktop-amd64.iso",
            "backend": "/ubuntu_persist.dat"
        }
    ],
    "control": [
        { "VTOY_TREE_VIEW_MENU_STYLE": "1" }
    ]
}
```

### 16.3 Automated Windows Deployment

Deploy Windows 11 to multiple PCs with identical configuration:

1. Prepare your `autounattend.xml` with desired settings
2. Copy it to `ventoy/autoinstall/` on the USB
3. Configure the mapping:

```json
{
    "control": [
        { "VTOY_WIN11_BYPASS_CHECK": "1" },
        { "VTOY_WIN11_BYPASS_NRO": "1" }
    ],
    "auto_install": [
        {
            "image": "/Windows/Win11_24H2_English_x64.iso",
            "template": "/ventoy/autoinstall/autounattend.xml"
        }
    ]
}
```

### 16.4 Kiosk/Demo USB

Create a USB that auto-boots a specific image after a timeout:

```json
{
    "control": [
        { "VTOY_DEFAULT_IMAGE": "/demo/demo-os.iso" },
        { "VTOY_MENU_TIMEOUT": "5" }
    ],
    "password": {
        "bootpwd": "admin-access"
    }
}
```

### 16.5 Separate Data Partition Setup

Use reserved space to keep personal data separate from boot images:

```bash
# Install Ventoy, reserving 64GB for data
sudo bash Ventoy2Disk.sh -i -r 65536 /dev/sdb

# Create an ext4 data partition in the reserved space
sudo parted /dev/sdb mkpart primary ext4 -- -65536MiB 100%
sudo mkfs.ext4 -L DATA /dev/sdb3
```

### 16.6 Secure Boot Corporate Environment

For machines with mandatory Secure Boot:

```bash
# Install with secure boot enabled (default)
sudo bash Ventoy2Disk.sh -i -s /dev/sdb
```

On first boot at each new machine:
1. Boot from USB, and the MOK Manager appears
2. Select "Enroll key from disk"
3. Navigate to VTOYEFI and select `ENROLL_THIS_KEY_IN_MOKMANAGER.cer`
4. Reboot, and the Ventoy menu appears normally

### 16.7 Persistent Kali Linux for Pentesting

```bash
# Create encrypted 16GB persistence
sudo bash CreatePersistentImg.sh -s 16384 -e -l persistence -c persistence.conf

cp persistence.dat /mnt/ventoy_usb/
```

```json
{
    "persistence": [
        {
            "image": "/kali-linux-2024.4-live-amd64.iso",
            "backend": "/persistence.dat"
        }
    ]
}
```

### 16.8 Vlnk for Large Image Libraries

When your image library exceeds USB capacity, use vlnk to reference ISOs on a local drive:

```bash
# Create vlnk files for ISOs on your hard drive
sudo sh VentoyVlnk.sh -c /data/isos/windows-server-2025.iso
sudo sh VentoyVlnk.sh -c /data/isos/rhel-9.4-x86_64.iso

# Copy the tiny vlnk files to the USB
cp *.vlnk.iso /mnt/ventoy_usb/
```

The vlnk file is only a few bytes, but the boot menu shows it as a full image. When selected, Ventoy reads the actual image from the referenced path.

### 16.9 Multiple Auto-Install Profiles

For IT environments with different hardware configurations:

```json
{
    "auto_install": [
        {
            "image": "/Windows/Win11_24H2_English_x64.iso",
            "template": [
                "/ventoy/autoinstall/win11_desktop_standard.xml",
                "/ventoy/autoinstall/win11_desktop_developer.xml",
                "/ventoy/autoinstall/win11_laptop_standard.xml",
                "/ventoy/autoinstall/win11_laptop_developer.xml"
            ]
        },
        {
            "image": "/Linux/ubuntu-24.04-live-server-amd64.iso",
            "template": [
                "/ventoy/autoinstall/ubuntu_webserver.yaml",
                "/ventoy/autoinstall/ubuntu_dbserver.yaml",
                "/ventoy/autoinstall/ubuntu_devbox.yaml"
            ]
        }
    ]
}
```

When booting, Ventoy presents a numbered menu to select which profile to apply.

### 16.10 Rescue and Recovery Kit

```text
Ventoy USB:
├── rescue/
│   ├── systemrescue-11.02-amd64.iso    # Full rescue environment
│   ├── clonezilla-live-3.1.3-11-amd64.iso  # Disk cloning
│   ├── gparted-live-1.6.0-1-amd64.iso  # Partition management
│   ├── memtest86plus.iso                # Memory diagnostics
│   └── hiren-boot-pe.iso               # Windows PE rescue
├── installers/
│   └── ubuntu-24.04-desktop-amd64.iso   # Fresh install option
└── ventoy/
    └── ventoy.json
```

### 16.11 Windows-to-Go via VHD

Run a full Windows installation from the USB:

1. Create a VHD in Windows Disk Management or Hyper-V Manager
2. Install Windows to the VHD
3. Copy the VHD to the Ventoy USB
4. Boot it directly from the Ventoy menu

### 16.12 Custom GRUB Configuration Overlay

When a distro's ISO has a broken or incompatible GRUB config:

```json
{
    "conf_replace": [
        {
            "image": "/Linux/custom-distro.iso",
            "org": "/boot/grub/grub.cfg",
            "new": "/ventoy/grubcfg/fixed-grub.cfg"
        }
    ]
}
```

### 16.13 Minimal USB with Whitelist

Only show specific approved images to end users:

```json
{
    "image_list": [
        {
            "type": "white",
            "list": [
                "/approved/ubuntu-24.04-desktop-amd64.iso",
                "/approved/Win11_24H2_English_x64.iso"
            ]
        }
    ],
    "password": {
        "bootpwd": "unlock-menu"
    }
}
```

### 16.14 Dual-Architecture USB

Support both x86 and ARM machines:

```text
Ventoy USB:
├── x86/
│   ├── ubuntu-24.04-desktop-amd64.iso
│   └── Win11_24H2_English_x64.iso
├── arm64/
│   ├── ubuntu-24.04-desktop-arm64.iso
│   └── fedora-workstation-41-aarch64.iso
└── ventoy/
    └── ventoy.json
```

The correct images boot on the correct architecture. x86 machines see x86 ISOs, ARM machines see ARM ISOs (assuming the ISO contains the right bootloader).

### 16.15 Server Deployment with DUD

Install a server OS with a custom storage driver:

```json
{
    "auto_install": [
        {
            "image": "/Server/sles-15-sp5-x86_64.iso",
            "template": "/ventoy/autoinstall/sles-autoyast.xml"
        }
    ],
    "dud": [
        {
            "image": "/Server/sles-15-sp5-x86_64.iso",
            "dud": "/ventoy/dud/megaraid-driver.iso"
        }
    ]
}
```

### 16.16 Chromebook Recovery USB

Create a multi-purpose USB that includes ChromeOS recovery alongside Linux and Windows installers:

```text
Ventoy USB:
├── ChromeOS/
│   └── chromeos_recovery.bin.img
├── Linux/
│   └── ubuntu-24.04-desktop-amd64.iso
└── Windows/
    └── Win11_24H2_English_x64.iso
```

### 16.17 Education Lab USB

Deploy a consistent environment across student workstations:

```json
{
    "control": [
        { "VTOY_DEFAULT_IMAGE": "/lab/ubuntu-lab-custom.iso" },
        { "VTOY_MENU_TIMEOUT": "10" }
    ],
    "persistence": [
        {
            "image": "/lab/ubuntu-lab-custom.iso",
            "backend": "/lab/student_persistence.dat"
        }
    ],
    "image_list": [
        {
            "type": "white",
            "list": [
                "/lab/ubuntu-lab-custom.iso"
            ]
        }
    ],
    "password": {
        "bootpwd": "instructor-only"
    }
}
```

### 16.18 Network Installer Fallback

Combine PXE network boot with local USB fallback:

```text
Ventoy USB:
├── netboot/
│   └── ipxe-custom.efi
├── local/
│   ├── ubuntu-24.04-live-server-amd64.iso
│   └── Win11_24H2_English_x64.iso
└── ventoy/
    └── ventoy.json
```

Boot iPXE for network installation when available; fall back to local ISOs when the network is down.

### 16.19 Forensics and Data Recovery USB

```text
Ventoy USB:
├── forensics/
│   ├── caine-13.0.iso              # CAINE forensic distro
│   ├── deft-zero.iso               # DEFT Zero
│   └── paladin-edge.iso            # PALADIN forensic suite
├── recovery/
│   ├── systemrescue-11.02-amd64.iso
│   ├── testdisk-live.iso
│   └── photorec-live.iso
└── ventoy/
    └── ventoy.json
```

### 16.20 Hypervisor Installer USB

Deploy bare-metal hypervisors:

```json
{
    "auto_install": [
        {
            "image": "/hypervisor/VMware-VMvisor-Installer-8.0.iso",
            "template": "/ventoy/autoinstall/esxi-kickstart.cfg"
        }
    ],
    "menu_alias": [
        { "image": "/hypervisor/VMware-VMvisor-Installer-8.0.iso", "alias": "VMware ESXi 8.0" },
        { "image": "/hypervisor/proxmox-ve_8.3-1.iso", "alias": "Proxmox VE 8.3" }
    ]
}
```

---

## 17. Troubleshooting

### 17.1 Ventoy USB Not Appearing in Boot Menu

**Error:** BIOS/UEFI does not list the USB drive as a boot option.

**Cause:** USB boot is disabled in BIOS/UEFI settings, or the boot mode (Legacy/UEFI) does not match the Ventoy installation.

**Solution:**
1. Enter BIOS/UEFI setup (typically F2, Del, or Esc during POST)
2. Enable USB boot in boot options
3. If using UEFI, ensure Secure Boot is either disabled or that you have enrolled the Ventoy MOK key
4. Try a different USB port (some BIOS only boot from USB 2.0 ports)

**Prevention:** Always verify BIOS settings support USB boot before deploying. Use the `-s` flag during installation to ensure Secure Boot compatibility.

### 17.2 "Ventoy Is Already Installed" Error

**Error:** `Ventoy2Disk.sh -i` refuses to install because Ventoy is already present.

**Cause:** The `-i` flag is strictly for first-time installation.

**Solution:** Use `-I` (capital I) to force install, or use `-u` to update:

```bash
# Force reinstall (destroys data partition)
sudo bash Ventoy2Disk.sh -I /dev/sdb

# Update (preserves data)
sudo bash Ventoy2Disk.sh -u /dev/sdb
```

**Prevention:** Use `-u` for upgrades and `-I` only when a fresh install is needed.

### 17.3 Windows Installer Error 0x80070001

**Error:** Windows 11 24H2 installation fails with error code 0x80070001.

**Cause:** The Windows installer struggles with certain USB configurations when the install.wim exceeds 4 GB, or the USB has compatibility issues with the installer's file copy phase.

**Solution:**
1. Use memdisk mode: select the Windows ISO in the Ventoy menu, then choose "memdisk" boot mode to load the entire ISO into RAM
2. Ensure the USB drive uses USB 3.0 on a USB 3.0 port
3. Try a different USB drive — some USB controllers have firmware incompatibilities

**Prevention:** For Windows installations, USB 3.0 drives on USB 3.0 ports provide the most reliable experience. Keep memdisk mode as a fallback.

### 17.4 "Out of Memory" Error or Blue Screen During Linux Install

**Error:** System runs out of memory or crashes with a blue/black screen when booting a Linux ISO.

**Cause:** Some Linux ISOs (particularly Nobara, some Fedora spins) require more RAM than available, especially when Ventoy loads them into memory.

**Solution:**
1. Ensure the target machine has sufficient RAM (4 GB minimum for most desktop distros, 2 GB for server/minimal)
2. Avoid memdisk mode for large ISOs on low-RAM systems
3. Try normal boot mode instead of memdisk

**Prevention:** Check the distro's minimum RAM requirements before booting.

### 17.5 ISO Boots to Black Screen

**Error:** Selecting an ISO from the Ventoy menu results in a black screen with no output.

**Cause:** Graphics driver compatibility issue between the live environment and the target hardware, or a corrupted ISO.

**Solution:**
1. Verify the ISO by checking its SHA256 checksum against the official value
2. Try booting in a different mode (Legacy vs. UEFI)
3. For Linux ISOs, add `nomodeset` to the kernel command line (press `e` in GRUB to edit boot parameters)
4. Try memdisk mode

**Prevention:** Always verify ISO checksums after download.

### 17.6 Fedora CoreOS Boot Failure

**Error:** Fedora CoreOS 39+ fails to boot from Ventoy.

**Cause:** CoreOS uses a specific boot mechanism (Ignition) that expects a particular disk layout. Ventoy's virtual disk presentation can conflict with Ignition's disk discovery.

**Solution:**
1. Use a dedicated USB for CoreOS rather than multi-booting it alongside other ISOs
2. Try GRUB configuration replacement with a custom grub.cfg that sets the correct root parameters
3. Use memdisk mode

**Prevention:** CoreOS is designed for automated provisioning, not live booting. Consider using the official CoreOS installer for production deployments.

### 17.7 USB Drive Shows as Read-Only

**Error:** USB drive becomes read-only after Ventoy installation. Cannot copy files or remove Ventoy.

**Cause:** The USB drive's internal controller has entered a write-protect state due to flash wear, firmware issues, or a physical write-protect switch.

**Solution:**
1. Check for a physical write-protect switch on the USB drive
2. On Windows, check `diskpart` for read-only state:
   ```text
   diskpart
   list disk
   select disk X
   attributes disk clear readonly
   ```
3. On Linux:
   ```bash
   sudo hdparm -r0 /dev/sdb
   ```
4. If the above fail, the flash controller may be permanently in read-only mode (end of life). Replace the drive.

**Prevention:** Use quality USB drives from reputable manufacturers. Flash memory has limited write cycles.

### 17.8 Antivirus Flags Ventoy as Malware

**Error:** VirusTotal or local antivirus reports Ventoy executables as trojan/malware.

**Cause:** Ventoy directly manipulates disk boot sectors and partition tables — behavior that overlaps with what bootkits do. Heuristic detection flags this as suspicious.

**Solution:**
1. Ventoy is open source — verify the source code matches the binaries
2. Add an exception in your antivirus for the Ventoy directory
3. Download only from the official GitHub releases page
4. Verify the release signature/checksum

**Prevention:** Accept that disk-writing tools will trigger heuristic AV scanners. Use exception rules.

### 17.9 VentoyGUI Not Working on Wayland (Hyprland, Sway, etc.)

**Error:** `VentoyGUI.x86_64` crashes or shows a blank window on Wayland compositors.

**Cause:** The native GUI uses GTK2/GTK3/QT5, which may not fully support Wayland without XWayland.

**Solution:**
1. Ensure XWayland is installed and enabled
2. Force X11 backend:
   ```bash
   GDK_BACKEND=x11 sudo ./VentoyGUI.x86_64
   ```
3. Use the Web UI instead:
   ```bash
   sudo bash VentoyWeb.sh
   ```
4. Use the CLI (`Ventoy2Disk.sh`) which has no GUI dependency

**Prevention:** On Wayland desktops, prefer the Web UI or CLI.

### 17.10 Secure Boot Fails After MOK Enrollment

**Error:** MOK key was enrolled but Ventoy still does not boot with Secure Boot.

**Cause:** Some UEFI implementations reset MOK keys on BIOS update, or the enrollment did not complete properly.

**Solution:**
1. Re-enroll the key by booting with Secure Boot and selecting the VTOYEFI partition again
2. If re-enrollment fails, disable Secure Boot in BIOS, boot to a Linux live environment, and use `mokutil` to enroll the key manually:
   ```bash
   sudo mokutil --import /path/to/ENROLL_THIS_KEY_IN_MOKMANAGER.cer
   ```
3. Reboot and confirm enrollment when prompted

**Prevention:** After BIOS updates, verify MOK keys are still enrolled.

### 17.11 ventoy.json Syntax Error

**Error:** Plugins do not take effect, or the boot menu behaves unexpectedly after editing `ventoy.json`.

**Cause:** Invalid JSON syntax (missing comma, unclosed bracket, trailing comma).

**Solution:**
1. Validate the JSON file:
   ```bash
   # On Linux
   jq . ventoy/ventoy.json

   # On Windows (PowerShell)
   Get-Content ventoy/ventoy.json | ConvertFrom-Json
   ```
2. Use VentoyPlugson instead of manual editing
3. Common mistakes: trailing comma after last array element, single quotes instead of double quotes, unescaped backslashes in Windows paths

**Prevention:** Always validate JSON after manual edits. Use VentoyPlugson for complex configurations.

### 17.12 Non-Destructive Install Fails

**Error:** `Ventoy2Disk.sh -i -n` fails with an error about insufficient space or unsupported filesystem.

**Cause:** The existing partition cannot be safely shrunk, or the filesystem does not support online resize.

**Solution:**
1. Back up your data
2. Use the standard install (`-i`) which formats the drive
3. Restore your files to the new Ventoy data partition

**Prevention:** Non-destructive install works best on drives with a single NTFS or ext4 partition with ample free space. It may not work on FAT32, exFAT, or heavily fragmented filesystems.

### 17.13 Persistence Not Working

**Error:** Changes made in a live session are lost after reboot despite configuring persistence.

**Cause:** Incorrect label on the persistence image, wrong path in `ventoy.json`, or the distro does not support the persistence mechanism.

**Solution:**
1. Verify the persistence image label matches what the distro expects (see the persistence label table in Section 5.2)
2. Verify the image path in `ventoy.json` exactly matches the file location on the USB
3. Verify `ventoy.json` is valid JSON
4. Check that the distro actually supports persistence (not all do)

**Prevention:** Use `CreatePersistentImg.sh` with the correct `-l` label for your target distro. Test with a small persistence image first.

### 17.14 Haiku OS Boot Failure

**Error:** Haiku OS 64-bit fails to boot from Ventoy.

**Cause:** Haiku uses a non-standard boot mechanism that is incompatible with Ventoy's virtual disk presentation.

**Solution:**
1. Try booting in Legacy BIOS mode instead of UEFI
2. Use memdisk mode
3. If the ISO still fails, Haiku may need to be written directly to a USB drive using a tool like `dd` or Rufus

**Prevention:** Some niche operating systems have boot mechanisms that are incompatible with Ventoy. Check the Ventoy compatibility list.

### 17.15 Vlnk and GPT Issues

**Error:** Vlnk files do not work correctly on GPT-formatted Ventoy drives.

**Cause:** Vlnk path resolution can have issues with certain GPT configurations.

**Solution:**
1. Ensure vlnk files point to paths accessible from the Ventoy boot environment
2. Recreate the vlnk file using the latest version of `VentoyVlnk.sh`
3. Verify with: `sudo sh VentoyVlnk.sh -l your_file.vlnk.iso`

**Prevention:** After updating Ventoy, recreate vlnk files to ensure compatibility.

### 17.16 Archlinux vtoyboot Timeout

**Error:** Archlinux installation from Ventoy times out waiting for a device.

**Cause:** The Arch ISO's initramfs expects a specific device configuration that Ventoy's virtual disk does not match perfectly, causing a timeout in the device discovery phase.

**Solution:**
1. At the GRUB menu for Arch, press `e` and add `cow_spacesize=1G` to the kernel command line
2. Try booting in a different mode (Legacy vs. UEFI)
3. Use memdisk mode for the Arch ISO

**Prevention:** Use the latest Arch ISO, as newer versions improve compatibility with Ventoy.

### 17.17 MX-Linux Encrypted Persistence Error

**Error:** MX-Linux encrypted persistence image fails to mount or produces errors.

**Cause:** MX-Linux has specific requirements for encrypted persistence that differ from standard LUKS setup.

**Solution:**
1. Use MX-Linux's own persistence tool instead of Ventoy's `CreatePersistentImg.sh`
2. If using Ventoy's tool, ensure the label is `MX-rundir`
3. Do not use the `-e` (encryption) flag — instead, set up encryption within MX-Linux after the persistence image is working

**Prevention:** For MX-Linux encrypted persistence, consult the MX-Linux documentation for their specific persistence format.

### 17.18 Windows 11 TPM/Secure Boot Check Failure

**Error:** Windows 11 installer refuses to proceed due to TPM 2.0, Secure Boot, or RAM requirements.

**Cause:** The target hardware does not meet Windows 11's minimum requirements.

**Solution:** Enable bypass variables in `ventoy.json`:

```json
{
    "control": [
        { "VTOY_WIN11_BYPASS_CHECK": "1" },
        { "VTOY_WIN11_BYPASS_NRO": "1" }
    ]
}
```

**Prevention:** Always include these bypass variables in your `ventoy.json` when deploying Windows 11.

### 17.19 USB Drive Detected But Wrong Size

**Error:** After Ventoy installation, the USB shows a much smaller capacity than expected.

**Cause:** The partition table was not written correctly, or the USB drive has a hidden HPA (Host Protected Area).

**Solution:**
1. Reinstall Ventoy with force install: `sudo bash Ventoy2Disk.sh -I /dev/sdb`
2. If the issue persists, recreate the partition table manually:
   ```bash
   sudo parted /dev/sdb mklabel msdos   # or gpt
   ```
   Then install Ventoy fresh

**Prevention:** Use quality USB drives. Avoid drives previously used with certain forensic or security tools that may have set an HPA.

### 17.20 VirtualBox Boot Failure

**Error:** Ventoy USB does not boot correctly in VirtualBox.

**Cause:** VirtualBox's USB passthrough and virtual BIOS/UEFI implementation has limitations compared to real hardware.

**Solution:**
1. Create a VMDK pointing to the physical USB:
   ```bash
   VBoxManage createmedium disk --filename ventoy.vmdk --format=VMDK \
     --variant RawDisk --property RawDrive=/dev/sdb
   ```
2. Enable EFI in VirtualBox VM settings if needed
3. Allocate sufficient RAM (at least 2 GB)

**Prevention:** Test Ventoy on real hardware when possible. Virtual machine USB boot testing is inherently less reliable.

### 17.21 "Initialization Constraints" Error

**Error:** Ventoy reports special constraints that hinder initialization.

**Cause:** The USB drive has unusual partition table characteristics, sector size issues, or firmware-level restrictions.

**Solution:**
1. Wipe the drive completely:
   ```bash
   sudo dd if=/dev/zero of=/dev/sdb bs=1M count=10
   sudo parted /dev/sdb mklabel msdos
   ```
2. Then install Ventoy fresh
3. If the drive has 4K native sectors, it is not supported — use a different drive

**Prevention:** Use standard USB flash drives with 512-byte sectors. Avoid drives with unusual firmware or sector configurations.

### 17.22 Multiple Ventoy Partitions Confusing the System

**Error:** After reinstalling Ventoy multiple times, the operating system shows multiple Ventoy-related partitions or mount points.

**Cause:** Previous partition tables were not fully cleaned before reinstall.

**Solution:**
1. Remove all partitions:
   ```bash
   sudo wipefs -a /dev/sdb
   sudo parted /dev/sdb mklabel msdos
   ```
2. Install Ventoy fresh

**Prevention:** Use `-I` (force install) which handles the partition cleanup automatically.

### 17.23 Slow Boot Menu Loading

**Error:** Ventoy boot menu takes a very long time to appear.

**Cause:** Hundreds of images on the USB, or a very slow USB drive.

**Solution:**
1. Reduce the number of images, or use `VTOY_DEFAULT_SEARCH_ROOT` to limit scanning
2. Use `VTOY_MAX_SEARCH_LEVEL` to limit directory recursion depth
3. Use a USB 3.0 drive on a USB 3.0 port

**Prevention:** Organize ISOs into focused directories and use search root limitations.

### 17.24 exFAT Partition Not Recognized on Older Linux

**Error:** The Ventoy data partition (exFAT) does not mount on older Linux systems.

**Cause:** Linux kernel versions before 5.4 do not have native exFAT support. Older systems need the FUSE-based exfat driver.

**Solution:**

```bash
# Install exFAT support (Ubuntu/Debian)
sudo apt install exfat-fuse exfat-utils

# Install exFAT support (Fedora/RHEL)
sudo dnf install exfatprogs
```

**Prevention:** Use a Linux kernel 5.4+ or install exFAT utilities before attempting to mount the Ventoy partition.

### 17.25 Permission Denied Running Ventoy2Disk.sh

**Error:** `bash: Ventoy2Disk.sh: Permission denied` or operations fail with access errors.

**Cause:** The script is not executable or was not run with root privileges.

**Solution:**

```bash
# Ensure you run as root
sudo bash Ventoy2Disk.sh -i /dev/sdb

# If the script lacks execute permission
chmod +x Ventoy2Disk.sh
sudo ./Ventoy2Disk.sh -i /dev/sdb
```

**Prevention:** Always use `sudo bash` to run Ventoy scripts.

### 17.26 BLOBs and License Concerns

**Error/Concern:** Ventoy contains binary blobs (BLOBs) for GRUB2, EDK2, iPXE, and other components. Users question whether these are safe.

**Cause:** Ventoy includes pre-compiled bootloaders to ensure compatibility. The source code for all these components is included in the repository.

**Solution:** The `GRUB2/MOD_SRC/`, `EDK2/`, `IPXE/ipxe_mod_code/`, and `wimboot/` directories in the Ventoy source repository contain the full modified source code for all binary components. Users can rebuild from source if desired.

**Prevention:** Review the source and build process if binary blobs are a concern for your use case.

### 17.27 ISO File Larger Than 4 GB on FAT32

**Error:** Cannot copy a large ISO to the Ventoy partition because the file exceeds the 4 GB FAT32 limit.

**Cause:** Ventoy defaults to exFAT which supports files up to 16 EB, but if the USB was reformatted to FAT32, the 4 GB limit applies.

**Solution:**
1. Use exFAT (the Ventoy default) — it has no practical file size limit
2. If you must use FAT32, split the ISO or use vlnk to reference the file from another location
3. Reinstall Ventoy (it creates an exFAT partition by default)

**Prevention:** Do not reformat the Ventoy data partition to FAT32. Keep it as exFAT.

### 17.28 Ventoy Update Fails with Version Mismatch

**Error:** Running `-u` to update Ventoy fails claiming version incompatibility or corruption.

**Cause:** The VTOYEFI partition boot files are corrupted or from a very old version that does not support in-place update.

**Solution:**
1. Use force install (`-I`) instead of update (`-u`), after backing up your data partition
2. Copy your ISOs and `ventoy/` directory back after reinstalling

**Prevention:** Update Ventoy regularly rather than skipping many versions. Major version jumps may require a clean install.

### 17.29 Boot Hangs at "Loading Ventoy..." Message

**Error:** The system displays "Loading Ventoy..." and hangs indefinitely.

**Cause:** The VTOYEFI partition is corrupted, the USB drive has bad sectors, or there is a firmware incompatibility.

**Solution:**
1. Reinstall Ventoy with `-I` (force install)
2. Try a different USB port
3. Test the USB drive for bad sectors:
   ```bash
   sudo badblocks -v /dev/sdb
   ```
4. Try a different USB drive

**Prevention:** Use reliable USB drives and avoid hot-unplugging during write operations.

### 17.30 Dual-Boot ISO Shows Wrong Menu Entries

**Error:** An ISO that offers both "Install" and "Live" modes shows incorrect or missing boot menu entries through Ventoy.

**Cause:** Ventoy passes through the ISO's native GRUB/ISOLINUX menu. Some ISOs structure their boot menus in ways that conflict with Ventoy's virtual environment.

**Solution:**
1. Use GRUB configuration replacement to provide a corrected `grub.cfg`
2. Try booting in the alternative mode (Legacy vs. UEFI) which may present a different menu
3. Use memdisk mode which bypasses Ventoy's virtual disk entirely

**Prevention:** Test ISOs individually after adding them to the Ventoy USB.

---

## 18. Frequently Asked Questions

**Does Ventoy support UEFI and Legacy BIOS boot?**
Yes. Ventoy supports both Legacy BIOS (via GRUB2) and UEFI (via EDK2 + GRUB2) on the same USB drive. The correct mode is selected automatically based on how the machine boots.

**Can I use Ventoy with Secure Boot enabled?**
Yes. Install with the default `-s` flag (Secure Boot enabled), then enroll the MOK key on first boot at each machine. See Section 10 for the complete procedure.

**Does Ventoy modify my ISO files?**
No. Ventoy reads ISO files directly from the USB partition without extracting or modifying them. Your original files remain completely intact.

**What is the maximum number of ISOs I can put on one USB?**
There is no hard limit. The practical limit is your USB drive's storage capacity. Users regularly run 50+ ISOs on a single drive.

**Can I still use the USB drive for normal file storage?**
Yes. The Ventoy data partition is a standard exFAT filesystem. You can store any files alongside your ISOs — documents, tools, drivers, etc. Ventoy only scans for bootable image files.

**Which USB filesystem does Ventoy use?**
The data partition uses exFAT by default. The 32 MB VTOYEFI boot partition uses FAT16.

**Do I need to reinstall Ventoy when adding or removing ISOs?**
No. Simply copy, delete, or replace files on the data partition. Ventoy detects all image files at boot time.

**Can I update Ventoy without losing my ISOs?**
Yes. The update process (`-u` flag or Update button) only replaces boot files on the VTOYEFI partition. Your data partition, ISOs, configuration, and persistence images are preserved.

**Does Ventoy work with USB hard drives (USB HDD)?**
Yes, Ventoy works with USB HDDs and SSDs. The same installation procedure applies. For drives larger than 2 TB, use the `-g` (GPT) flag.

**Can I use Ventoy on an SD card?**
Yes, if the system BIOS supports booting from SD cards. The SD card needs to be fast enough for a reasonable boot experience (UHS-I or faster recommended).

**What happens if I accidentally install Ventoy to my system drive?**
Ventoy includes safeguards to prevent installation to non-removable drives in most cases. However, if installed to a system drive via force install, the drive's data and boot configuration will be overwritten. Always double-check the device name before installing.

**Can I boot Windows ISOs with Ventoy?**
Yes. Windows 7, 8, 8.1, 10, 11, Server 2016/2019/2022/2025, and Windows PE (WIM) are all supported. Use the `VTOY_WIN11_BYPASS_CHECK` control variable for Windows 11 on hardware that does not meet the official requirements.

**Does Ventoy support ARM-based computers?**
Ventoy's USB installer supports ARM64 architecture (VentoyGUI.aarch64). However, ARM boot compatibility depends on the specific machine's UEFI implementation and the ISOs having ARM bootloaders.

**Can I use Ventoy to install macOS?**
macOS uses a proprietary boot chain that is not compatible with Ventoy. Ventoy does not support booting macOS ISOs/DMGs.

**How do I check which version of Ventoy is on my USB?**
Use the list command:

```bash
sudo bash Ventoy2Disk.sh -l /dev/sdb
```

On Windows, the Ventoy2Disk GUI displays the currently installed version.

**Can I have multiple persistence files for the same ISO?**
Yes. Configure multiple backends in `ventoy.json` and Ventoy presents a selection menu at boot:

```json
{
    "persistence": [
        {
            "image": "/ubuntu.iso",
            "backend": ["/work_persist.dat", "/personal_persist.dat"]
        }
    ]
}
```

**Does Ventoy work in a virtual machine?**
Ventoy can boot in VirtualBox, VMware, and QEMU with USB passthrough. Results vary — VM USB passthrough is less reliable than real hardware. QEMU with direct disk access typically works best.

**Can I use NTFS instead of exFAT for the data partition?**
You can reformat the data partition to NTFS, and Ventoy will still work for UEFI-only boot. However, Legacy BIOS boot may have issues with NTFS. exFAT is recommended for best cross-platform compatibility.

**How much space does Ventoy itself use?**
Ventoy's boot partition (VTOYEFI) uses 32 MB. The rest of the USB is available for your images and files.

**Is Ventoy safe? My antivirus flags it.**
Ventoy manipulates disk boot sectors, which triggers heuristic antivirus detections. This is a false positive. Ventoy is open source, and the complete source code is available for audit. See Troubleshooting Section 17.8 for details.

**Can I customize the boot menu appearance?**
Yes. Ventoy supports GRUB2 themes, custom backgrounds, menu aliases, icon classes, and more. See Sections 7 and 12 for full customization options.

**What is the `ventoy/` directory on the USB?**
This is Ventoy's configuration directory. It contains `ventoy.json` (main config), themes, auto-install scripts, and other plugin files. Create this directory manually or use VentoyPlugson.

**Can I use Ventoy to network boot (PXE)?**
Ventoy includes iPXE for network boot chainloading. You can boot into iPXE from the Ventoy menu and then load images from a network server.

**What is a vlnk file?**
A Ventoy Link (vlnk) file is a small pointer file that references a full image stored elsewhere. It lets you boot ISOs that are not physically on the USB drive. See Section 9 for details.

**Can I install Ventoy to a USB drive from a live Linux session?**
Yes. Boot any Linux live environment (including from another Ventoy USB), then run `Ventoy2Disk.sh` on the target USB drive.

**Does Ventoy support booting from ISO files larger than 4 GB?**
Yes. The default exFAT filesystem supports files up to 16 EB. There is no practical file size limit.

**How do I completely remove Ventoy from a USB drive?**
Reformat the drive or recreate the partition table:

```bash
sudo parted /dev/sdb mklabel msdos
sudo mkfs.exfat /dev/sdb1
```

On Windows, use Disk Management to delete all partitions and create a new volume.

**Can Ventoy boot ISOs stored in subdirectories?**
Yes. Ventoy recursively scans the entire data partition. ISOs can be in any subdirectory at any depth. Use `VTOY_MAX_SEARCH_LEVEL` to limit the scan depth if needed.

**What is memdisk mode and when should I use it?**
Memdisk mode loads the entire ISO into RAM before booting. Use it when an ISO has compatibility issues with Ventoy's normal boot method, or when the ISO is small enough to fit in RAM comfortably. It is slower to start but can resolve many boot failures.

**Can I password-protect individual ISOs?**
Yes. Use the `password` section in `ventoy.json` with the `isopwd` array to set per-image passwords. See Section 14.5 for configuration details.

---

## 19. Platform and Architecture Reference

### 19.1 Supported Host Architectures

| Architecture | Linux CLI | Linux GUI | Linux Web UI | Windows GUI |
|---|---|---|---|---|
| x86_64 (64-bit Intel/AMD) | Yes | Yes | Yes | Yes |
| i386 (32-bit Intel/AMD) | Yes | Yes | Yes | Yes (default exe) |
| aarch64 (64-bit ARM) | Yes | Yes | Yes | Yes (ARM64 exe) |
| mips64el (64-bit MIPS LE) | Yes | Yes | Yes | No |

### 19.2 Supported Target Boot Architectures

| Architecture | Legacy BIOS | UEFI | Secure Boot |
|---|---|---|---|
| x86 / x86_64 | Yes | Yes | Yes |
| ARM64 | No (no Legacy BIOS on ARM) | Yes | Depends on firmware |
| MIPS | Platform-specific | Platform-specific | No |

### 19.3 Tested OS Families

Ventoy has been tested with 900+ ISO images including:

| OS Family | Examples |
|---|---|
| Debian-based | Ubuntu, Debian, Linux Mint, Kali, Pop!_OS, MX Linux |
| Red Hat-based | Fedora, RHEL, CentOS, Rocky Linux, AlmaLinux |
| Arch-based | Arch Linux, Manjaro, EndeavourOS |
| SUSE-based | openSUSE Tumbleweed, openSUSE Leap, SLES |
| Gentoo-based | Gentoo, Calculate Linux |
| Independent Linux | Void, NixOS, Solus, Puppy Linux |
| Windows | 7, 8, 8.1, 10, 11, Server 2016/2019/2022/2025 |
| BSD | FreeBSD, OpenBSD, NetBSD, GhostBSD |
| ChromeOS | ChromeOS Flex, Chromium OS |
| Other | VMware ESXi, Proxmox VE, TrueNAS |
| Rescue | SystemRescue, Clonezilla, GParted Live, Hiren's Boot PE |

---

## 20. Best Practices

### 20.1 USB Drive Selection

- Use USB 3.0 or faster drives for significantly better boot and file copy speeds
- Choose reputable brands with good flash controllers (Samsung, SanDisk, Kingston)
- For heavy multi-boot use, consider USB SSDs which have much better random I/O
- Avoid ultra-cheap drives — they may have unreliable flash that causes boot failures

### 20.2 Image Organization

- Use descriptive directory names: `Linux/`, `Windows/`, `Rescue/`, `Tools/`
- Include version numbers in filenames for clarity
- Remove outdated ISOs to keep the boot menu manageable
- Use `VTOY_DEFAULT_SEARCH_ROOT` if your boot menu gets too cluttered

### 20.3 Configuration Management

- Keep a backup of your `ventoy/ventoy.json` on your PC
- Use VentoyPlugson for complex configurations to avoid JSON syntax errors
- Test configuration changes with a single ISO before deploying broadly
- Document custom configurations for your team

### 20.4 Security Considerations

- Passwords in `ventoy.json` are stored in plain text — do not rely on them for strong security
- Encrypted persistence provides data protection for saved changes
- Secure Boot enrollment should be done on trusted machines
- Keep Ventoy updated to the latest version for security patches

### 20.5 Backup and Recovery

- The update process is safe — it preserves all data
- Before force reinstalling (`-I`), back up the USB data partition
- Keep a copy of your `ventoy/` configuration directory
- Consider the reserved space feature for a separate, non-Ventoy partition for critical files

---

_Generated May 2026 from ventoy/Ventoy at de3e6c6. AI-generated documentation. The library is checked by sampling (three repositories so far); this guide was not individually reviewed. Verify against the project before relying on it. Unofficial; not affiliated with or reviewed by the project._