# How Ventoy's Driver Update Disk (DUD) Plugin Integrates Hardware Drivers

> Discover how Ventoy's Driver Update Disk plugin automatically integrates hardware drivers into booted OS by loading driver files from a separate disk image during early boot. Enhance your system compatibility effortlessly.

- Repository: [longpanda/Ventoy](https://github.com/ventoy/Ventoy)
- Tags: how-to-guide
- Published: 2026-03-01

---

**Ventoy's Driver Update Disk (DUD) plugin is a built-in extension that automatically injects third-party hardware drivers into booted operating systems by loading driver files from a separate disk image during the early boot sequence.**

The DUD plugin bridges the gap between static ISO images and evolving hardware requirements by eliminating the need to rebuild installation media when new drivers are needed. According to the `ventoy/Ventoy` source code, this plugin registers itself as `"dud"` and operates through a validated JSON configuration system that maps specific driver packages to individual ISO files.

## How the DUD Plugin Works (Architecture)

The plugin operates across three architectural layers that handle registration, data management, and runtime injection.

### Plugin Registration and Core Hooks

Ventoy maintains an internal table of built-in plugins where the DUD plugin registers with the identifier `"dud"`. The core implementation resides in [`GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_plugin.c`](https://github.com/ventoy/Ventoy/blob/main/GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_plugin.c) (lines 820‑864) and exposes two critical entry points:

- **`ventoy_plugin_dud_check()`** – Validates the JSON configuration for each ISO entry and discovers driver files matching the ISO path pattern.
- **`ventoy_plugin_dud_entry()`** – Constructs runtime data structures (`dud` and `dudfile`) that Ventoy uses during the boot process.

These functions populate the global `g_dud_head` linked list, which the early boot code traverses to locate applicable drivers.

### Data Structures for Driver Management

Driver metadata is stored in two structures defined in [`GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_def.h`](https://github.com/ventoy/Ventoy/blob/main/GRUB2/MOD_SRC/grub-2.04/grub-core/ventoy/ventoy_def.h) (lines 931‑447):

- **`struct dud`** – Represents one ISO's complete driver set, containing the ISO path, a pointer to the driver file list (`dudfile *files`), and a linked‑list pointer for chaining multiple DUD entries.
- **`struct dudfile`** – Holds the size and in‑memory buffer for each individual driver file.

During boot, Ventoy walks the `g_dud_head` list and copies each referenced driver file to a temporary location accessible to the OS installer, enabling injection into Windows `wim` images or Linux `.ko` module loading mechanisms.

## Configuring the Ventoy DUD Plugin

Users can configure driver mappings through JSON configuration files or the Plugson web interface.

### JSON Configuration Format

The DUD plugin parses a `"dud"` array within the per‑ISO JSON configuration file (typically located in the same directory as the ISO). Each object requires an `"image"` field specifying the ISO path and a `"path"` field pointing to the driver file.

```json
{
  "image": "/iso/Win10_1909.iso",
  "dud": [
    {
      "path": "/dud/Win10_1909/Intel_82599vf.inf",
      "type": "inf"
    },
    {
      "path": "/dud/Win10_1909/NVME_Driver.inf",
      "type": "inf"
    }
  ]
}

```

When `ventoy_plugin_dud_check()` parses this configuration, it validates the file paths and prepares the structures for `ventoy_plugin_dud_entry()` to load at runtime.

### Plugson Web Interface

For users preferring a graphical workflow, the Plugson web UI ([`Plugson/www/plugson_dud.html`](https://github.com/ventoy/Ventoy/blob/main/Plugson/www/plugson_dud.html)) provides interactive management of DUD entries. The interface strings are defined in [`Plugson/www/static/js/vtoy.js`](https://github.com/ventoy/Ventoy/blob/main/Plugson/www/static/js/vtoy.js) (e.g., `"STR_PLUG_DUD": "DUD Plugin"` at line 387), enabling users to add, edit, or remove driver associations without manually editing JSON files.

## Boot-Time Driver Injection Process

When the machine boots from a Ventoy-prepared USB drive, the early boot environment executes the following sequence:

1. **Path Matching** – The boot code compares the current ISO path against the `"image"` patterns registered in the `g_dud_head` list.
2. **File Loading** – For each matching DUD entry, Ventoy loads the specified driver files from the driver disk into memory buffers defined by `struct dudfile`.
3. **OS-Specific Injection** – The plugin transfers these files to OS-accessible temporary storage, allowing Windows Setup to load `.inf` drivers or Linux installers to insert `.ko` kernel modules before hardware detection occurs.

This process eliminates the "missing driver" errors commonly encountered when installing operating systems on newer hardware from older ISO images.

## Example: Adding Storage Drivers to a Windows ISO

To add NVMe storage drivers to a Windows 10 installation without modifying the original ISO, place the driver files in a `/dud/` directory on your Ventoy disk and create the following configuration in your [`ventoy.json`](https://github.com/ventoy/Ventoy/blob/main/ventoy.json) file:

```json
{
  "image": "/iso/Win10_1909.iso",
  "dud": [
    {
      "path": "/dud/Win10_1909/NVME_Driver.inf",
      "type": "inf"
    }
  ]
}

```

Alternatively, using the Plugson interface, you would select the ISO path, click **"Add DUD File"**, and specify the driver location. The JavaScript handler in [`vtoy.js`](https://github.com/ventoy/Ventoy/blob/main/vtoy.js) processes this input and writes the configuration to the backend:

```javascript
$("#id_btn_add_dud_file").on("click", function () {
    var isoPath = $("#id_input_iso_path").val();
    var driverPath = $("#id_input_driver_path").val();
    var dudEntry = { image: isoPath, path: driverPath, type: "inf" };
    $.post("/api/add_dud", dudEntry, reloadDudTable);
});

```

The next boot will automatically invoke `ventoy_plugin_dud_entry()` to load the specified NVMe driver before Windows Setup begins hardware detection.

## Summary

- **The DUD plugin** registers as `"dud"` in [`ventoy_plugin.c`](https://github.com/ventoy/Ventoy/blob/main/ventoy_plugin.c) and provides validation (`ventoy_plugin_dud_check`) and loading (`ventoy_plugin_dud_entry`) functions.
- **Data structures** `struct dud` and `struct dudfile` in [`ventoy_def.h`](https://github.com/ventoy/Ventoy/blob/main/ventoy_def.h) manage driver file metadata and memory buffers.
- **Configuration** occurs via JSON files specifying `"image"` to ISO mappings and `"path"` to driver files, or through the Plugson web UI ([`plugson_dud.html`](https://github.com/ventoy/Ventoy/blob/main/plugson_dud.html)).
- **Runtime injection** happens during early boot by walking the `g_dud_head` linked list and copying drivers to OS-accessible temporary storage.
- **Supported scenarios** include adding storage controllers, network adapters, or chipset drivers to Windows and Linux installers without ISO modification.

## Frequently Asked Questions

### What file types does the Ventoy DUD plugin support?

The plugin supports OS-specific driver formats: Windows `.inf` files for driver packages and Linux `.ko` kernel module files. The `"type"` field in the JSON configuration indicates the driver format to ensure proper handling during the injection process.

### Can I use the DUD plugin with Linux ISOs?

Yes, the DUD plugin works with both Windows and Linux installations. For Linux ISOs, specify `.ko` kernel module files in the `"path"` field, and Ventoy will stage these modules in the temporary filesystem where the Linux installer can load them during hardware initialization.

### How do I verify my DUD configuration is valid?

Ventoy validates DUD configurations through `ventoy_plugin_dud_check()` before the boot process begins. If you use the Plugson web interface, it performs real-time validation when saving entries. For manual JSON edits, check that the `"image"` path matches your ISO filename exactly and that driver files exist at the specified `"path"` locations on your driver disk.

### Where does Ventoy load the driver files during boot?

During the boot sequence, Ventoy loads driver files into memory buffers defined by `struct dudfile`, then copies them to a temporary location accessible to the operating system installer. For Windows, this allows integration into the `wim` image; for Linux, modules become available in the initramfs or temporary filesystem before hardware probing occurs.