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

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

{
  "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) provides interactive management of DUD entries. The interface strings are defined in 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 file:

{
  "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 processes this input and writes the configuration to the backend:

$("#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 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 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).
• 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}