Tell us about your PDF experience.

What's new in driver development for

Windows 11, version 24H2
Article • 09/18/2024

This section describes new features and updates for driver development in Windows 11,
version 24H2. To target this version of Windows, you can use WDK 10.0.26100.1
(released May 22, 2024).

WDK NuGet package support

The WDK NuGet package consists of essential libraries, headers, DLL, tools and
metadata used for building Windows drivers that can be shared and supported by
modern CI/CD pipelines. Users can access and consume the NuGet packages directly
from nuget.org within Visual Studio. Using NuGet with the WDK provides a convenient
solution for WDK acquisition and updates. It manages dependencies such as the SDK, to
help keep the driver development tool chain up to date. For more information, see
Install the latest WDK using NuGet - Step by Step.

ARM64 support
Starting from WDK version 10.0.26100.1, WDK now supports development, testing and
deployment of drivers on ARM64 machines. The WDK/EWDK can be installed and run
natively on ARM64 hardware, in addition to the previously supported emulation of x86
KMDF/UMDF2 drivers on ARM64 hardware. There is also support for debugging and
deployment of drivers to an ARM64 target machine from both ARM64 and x64 host
machines. The process of installing WDK/EWDK on ARM64 machines will automatically
identify and install all the necessary dependencies including build tools, binaries and
libraries.

Audio
Updates to the ACX audio class extensions overview and the Windows 11 APIs for Audio
Processing Objects articles including new information on the following:

ACX multi circuit composition

ACX multi stack cross driver communications

ACX audio data formats and data format lists

 ACX power management

ACX WDF driver lifetime management

Camera and streaming media

Three new camera articles for Windows 11, version 24H2 (also applies to Windows 11,
version 23H2):

Camera settings page - Describes the features and operation of the camera
settings page in Windows 11, and the default values framework that allows
configuration of the camera configuration applied when an application starts the
camera.

Camera companion apps - Describes companion apps, an extensibility feature for

manufacturers of cameras to build custom applications that can configure the
camera and adjust default image settings.

Network cameras - Describes compatibility with ONVIF network cameras in

Windows.

New camera KS Properties and DDIs:

KSPROPERTY_CAMERACONTROL_EXTENDED_FRAMERATE_THROTTLE

KSPROPERTY_CAMERACONTROL_EXTENDED_FIELDOFVIEW2

KSPROPERTY_CAMERACONTROL_EXTENDED_FIELDOFVIEW2_CONFIGCAPS

KSCAMERA_EXTENDEDPROP_FIELDOFVIEW2_CONFIGCAPS

Updated UVC MSXUs for framerate throttle and FoV2 additions. For more information,
see Microsoft extensions to USB Video Class 1.5 specification.

Display and graphics drivers

GPUs are increasingly used in artificial intelligence and machine learning scenarios due
to their computational power, parallel processing capabilities, and efficient handling of
large datasets. Several new features are added to Windows Display Driver Model
(WDDM) version 3.2 as optimizations to GPU/NPU usage, especially in cloud-based
scenarios.

Dirty bit tracking enhances the performance of VRAM data transfer between
physical hosts during the live migration of virtual machines.
 Live migration of heterogeneous GPU-P compute devices is added. Significant
content can now be transferred while virtualized resources are still active, reducing
the pause time needed to complete a migration.

A GPU native fence synchronization object is added as an extension to the

monitored fence object, supporting the following extra features:

GPU wait on monitored fence value, which allows for high performance engine-
to-engine synchronization without requiring CPU round trips.

Conditional interrupt notification only for GPU fence signals that have CPU
waiters, enabling substantial power savings.

Fence value storage in the GPU's local memory.

User-mode work submission is an in-progress feature that isn't yet enabled for
final use. This feature allows user-mode drivers to submit work directly to the GPU
without kernel-mode intervention.

Other added WDDM 3.2 features include:

The D3D12 video encoding DDI is extended to support AV1 encoding.

The method that a user-mode or kernel-mode graphics driver uses to determine

whether a particular WDDM feature is supported and enabled

TDR (timeout detection and recovery) debugging is enhanced to provide more

information about the cause of a TDR event.

Allocation notification is an in-progress feature that isn't yet enabled for final use.
This feature allows kernel-mode drivers to receive notifications about an allocation
that's about to undergo a paging eviction or promotion operation.

File system and filter drivers

Starting in Windows 11, version 24H2:

Bind links can be used to bind a file system namespace to a local "virtual path"
through the Bind Filter (bindflt.sys). Minifilters can choose to veto such bind links
on the system's boot partition. For more information, see Vetoing a bind link.

When opening a $INDEX_ALLOCATION attribute, NtCreateFile now honors the

state of the FILE_NON_DIRECTORY_FILE flag, whereas it previously didn't.

FltMgr provides Query on Create support for USN and file security information.
Network drivers
Starting in Windows 11, version 24H2, you can write a User-Mode Driver
Framework (UMDF) NetAdapterCx driver. The UMDF APIs in NetAdapterCx align
with the KMDF versions, so you can convert your KMDF-based client driver to
UMDF with little to no code changes.

UDP Receive Segment Coalescing Offload (URO) is a new hardware offload feature
that enables network interface cards (NICs) to coalesce UDP receive segments. For
more information, see UDP Receive Segment Coalescing Offload (URO) and
NetAdapterCx URO.

WiFiCx Wi-Fi 7 introduces support for Wi-Fi 7 features, providing faster

connectivity speeds, lower latency, and improved security. WiFiCx Wi-Fi 7 enables:

Multi-Link Operation (MLO) with roaming differentiation to leverage multiple

simultaneous channels to the Wi-Fi access point (AP).

Enhanced capabilities for WPA3-SAE authentication and Opportunistic Wireless

Encryption (OWE) with GCMP-256 cipher.

WiFiCx WPA3 SoftAP enables devices to set up a Soft Access Point (SoftAP) using
the Wi-Fi Protected Access 3 - Simultaneous Authentication of Equals (WPA3-SAE)
security protocol.

WiFiCx QoS R1 introduces advanced traffic management capabilities for WiFiCx

devices. QoS R1 enables prioritization of Wi-Fi data packets through Mirrored
Stream Classification Service (MSCS) and QoS Mapping (DSCP-to-UP Mapping).

Kernel
Four new wdm.h power management DDIs for Windows 11, version 24H2:

PO_EFFECTIVE_POWER_MODE_CALLBACK callback function - Invoked with the

current value of the power setting immediately after registration.

PO_EFFECTIVE_POWER_MODE enumeration - Enumerates the effective power

modes.

PoRegisterForEffectivePowerModeNotifications function - Registers a callback to

receive effective power mode change notifications.

PoUnregisterFromEffectivePowerModeNotifications function - Unregisters from

effective power mode change notifications.
Storage drivers
A storport miniport driver can now read configuration data from more locations
within the registry. For more information, see StorPortReadRegistryKey and
StorPortReadDriverRegistry.

Stornvme supports more vendor-specific NVMe features and log pages. For more
information, see the StorageAdapterProtocolSpecificPropertyEx,
StorageDeviceProtocolSpecificPropertyEx, NVMeDataTypeLogPageEx, and
NVMeDataTypeFeatureEx enum values. The ntddstor.h header file contains usage
guidance for these new property identifiers and data types as well as their
associated input and output structures.

Install
INF AddComClass directive: An AddComClass directive is used within a com-
server-install-section and registers a COM class.

INF AddComServer directive: An AddComServer directive is used within a

DDInstall.COM section and registers a COM server.

INF DDInstall.COM section: The DDInstall.COM section contains one or more INF
AddComServer directives that reference other INF-writer-defined sections in an INF
file.

The driver package INF registry conversion tool ( reg2inf.exe ) converts a registry
key and its values or a COM .dll implementing a DllRegisterServer routine into a
set of INF AddReg directives or INF DDInstall.COM section for in-proc COM servers
for inclusion into a driver package INF file.

USB
Support for USB superspeed information through
IOCTL_USB_GET_NODE_CONNECTION_SUPERSPEEDPLUS_INFORMATION and
USB_NODE_CONNECTION_SUPERSPEEDPLUS_INFORMATION.

Sensors
Support for new human presence fields in proximity sensors through
HUMAN_PRESENCE_DETECTION_TYPE and PROXIMITY_SENSOR_CAPABILITIES.
 Humans presence updates include support for tracking multiple humans.

Driver security
Updates to the Windows CodeQL rules and updates to the Driver security checklist.

Windows debugging tools - WinDbg

Major new WinDbg features are listed here. For full details on the updates to WinDbg
see WinDbg Release Notes. For general information about the debugging tools, see
What is WinDbg?.

Live Linux debugging

You can now live debug a Linux process. For more information, see these articles:

Linux live remote process debugging

Linux symbols and sources

Other WinDbg updates and new features

Source Code Extended Access

Open Enclave debugging

Ambiguous breakpoint resolution

WinDbg - Restricted Mode

Improved JavaScript Debugger Scripting - JavaScript Debugging

Accessibility improvements

Time Travel Debugging on ARM64

Smart number selection and search

New disassembly window

Updates to Supported Ethernet NICs for Network Kernel Debugging in Windows

11
 Expanded bug check information including new bug checks described in Bug
Check Code Reference

Related articles
For information on what was new for drivers in past Windows releases, see the following
pages:

Driver development changes for Windows 11, version 23H2

Driver development changes for Windows 11, version 22H2

Driver development changes for Windows 11, version 21H2

Driver development changes for Windows Server 2022

Driver development changes for Windows 10, version 2004

Back to Top

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Windows Driver Kits Release Notes
Article • 09/24/2024

The following are features and bug fix in Windows 11 24H2 WDK update (version
10.0.26100.1591) released on September 18th, 2024.

WDK VSIX installation

The WDK VSIX has been added as a Visual Studio individual component starting with
the VS 17.11 release. For more information, see the Windows Drivers Kits download
page.

Static Tools Logo - Creating a Driver

Verification Log
To create a Driver Verification Log (DVL) for the Static Tools Logo Test, see the Creating a
Driver Verification Log article.

Navigating to Extensions > Drivers > Create Driver Verification Log in Visual Studio will
now trigger the redirection message below.
Static Tools Logo - Placement requirement for
CodeQL Sarif file
The process of generating DVL for CodeQL previously required placing the SARIF file in
the same directory as the VCXProj file for the driver project. Recognizing the
inconvenience this posed for developers, we have eliminated this requirement. Now
users can generate the DVL and save it in any location of their choice by using this
command:

Windows Command Prompt

C:\Program Files (x86)\Windows Kits\10\Tools\dvl\dvl.exe" /manualCreate

`<driverName>` `<driverArchitecture>` /`<path to sarif file>`'\

UMDF WiFiCX drivers

To support UMDF WiFiCX drivers, we have added UMDF public header and library
support. These changes ensure that WiFiCX drivers leverage the advantages of writing
UMDF drivers. The following updates have been made:
 Created a new UMDF version of WifiCxTlvGenParse.lib.

Created UMDF equivalents of KMDF's dot11wificxintf.h, dot11wificxtypes.hpp, and

WifiCxTlvGenParse.lib.

Bug fixes for Device Fundamentals and WDTF

test framework
Bugs associated with DevFund tests were fixed, this change improves the WDK bring up
experience.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

What's new in driver development for
Windows 11, version 23H2
Article • 06/26/2024

This section describes new features and updates for driver development in Windows 11,
version 23H2. To target this version of Windows, you can use WDK 10.1.22621.2428
(released October 24, 2023).

Audio
To allow audio drivers to be more reliable and offer the best possible experience for PC
users, the Audio Class eXtension (ACX) is now available. For more information, see ACX
audio class extensions overview

Windows 11 APIs for Audio Processing Objects provides information on new features
designed to improve the quality and reliability of Windows Audio Processing Objects
(APOs).

Bluetooth Low Energy (LE) Audio

Bluetooth LE Audio enables streaming unicast or broadcast audio to Bluetooth LE
devices over an isochronous transport. As of version 5.3 of the Bluetooth core
specification, there's no standard defined host controller interface (HCI) for host
platforms to send and receive isochronous data to and from the Bluetooth controller.
The Windows Bluetooth vendor specific audio path (VSAP) allows platforms to use
vendor-specific solutions to enable Bluetooth LE Audio streaming. The VSAP software
interface uses Windows audio class extensions (ACX) and more interface properties
defined in this document. For more information, see Bluetooth Low Energy (LE) Audio.

Camera and streaming media

The camera driver documentation has been updated with information about the camera
profile v2 developer specification.

Camera Profile V2 developer specification

Display and graphics drivers

 Windows 11, version 23H2 includes version 1.10 of the Indirect Display Driver (IDD)
model. This latest IddCx version adds HDR10 (high dynamic range) and SDR
(standard dynamic range) Wide Color Gamut (WCG) support for indirect displays.

Updates for IddCx versions 1.10 and later

WDDM 3.0 and later drivers can support DisplayPort monitors connected over
USB4.

WDDM support for DisplayPort monitors over USB4

WDDM 3.0 and later drivers can support the Hardware flip queue feature.

Hardware flip queue

Dynamic lighting
Dynamic Lighting provides Windows users and developers with native control of lighting
devices implementing the open HID LampArray standard. By adopting an open
standard, and by working with our OEM and ODM partners, Microsoft seeks to improve
the RGB device and software ecosystem for users by increasing interoperability of
devices and apps. Device manufacturers can use standardized firmware for the first time,
enabling new native experiences across the Windows OS and apps without the high
costs of proprietary firmware and software development.

Examples of experiences include synchronizing devices from different brands together in

Windows Settings, applying effects intelligently across available devices, and leveraging
app integrations to drive device lighting. For the first time, device manufacturers are
empowered to focus purely on innovation and differentiation because their devices will
be able to take advantage of a myriad of OS and app experiences. For more information,
see Dynamic Lighting devices

File system and filter drivers

Flags were added to support Dev Drive. A minifilter driver receives these flags via
its PFLT_INSTANCE_SETUP_CALLBACK routine.

Minifilter guidance for file system placeholders was added.

Human presence sensors

With the release of Windows 11, Microsoft now natively supports the presence sensing
feature set in Windows. For Windows 11 PCs that have a presence sensor built in, users
can have their screen turn off automatically when they leave (see Lock on leave), and
then have their device wake up quickly when they approach (see Wake on approach).
This can help keep their PC more secure, help save battery power, and help users get
back to work more quickly. For more information, see Presence Sensing.

Print devices
The print driver documentation has been updated with information on the end of
servicing plan for third-party printer drivers on Windows.

End of servicing plan for third-party printer drivers on Windows

Storage drivers
StorNVMe command set support and feature support has been updated.

StorPort miniport drivers can now acquire and release spin locks.

USB
Starting in Windows 11 build 22621.1778 (KB5026446), the Windows Settings app now
lists attached USB4 hubs and devices and their capabilities. For USB4-capable systems,
navigate in the Settings app to Bluetooth & devices > USB > USB4 Hubs and Devices.
For more information, see Universal Serial Bus 4 (USB4™) settings enablement.

Starting in Windows 11, version 22H2 September Update, the Windows UCM-UCSI ACPI
device drivers support UCSI specification version 2.0 and 2.1. The UCSI specification 2.0
has breaking changes in the memory mapping of its data structures as defined in UCSI
specification Table 3-1 Data Structures . To maintain backward compatibility, Windows
requires the UCSI PPM of specification version 2.0 or greater to implement a _DSM
function under the UCM-UCSI ACPI device in ACPI firmware and return a nonzero value
to indicate that UCSI OPM should follow the reported UCSI specification version. For
more information, see UCM-UCSI ACPI device for UCSI 2.0 and greater.

Getting started
From Sample Code to Production Driver - What to Change in the Samples describes
changes that need to be made to the WDK sample drivers before releasing device
drivers based on the sample code.

Driver security
A new topic provides important driver security guidance – Windows drivers security best
practices for driver developers. Updates to the Semmle CodeQL rules and new
information on the Microsoft Vulnerable and Malicious Driver Reporting Center as well
as an updated Driver security checklist.

Windows debugging tools

Formerly released as WinDbg Preview in the Microsoft Store, WinDbg leverages the
same underlying engine as WinDbg (Classic) and supports all the same commands,
extensions, and workflows. For more information, see What is WinDbg?

Expanded bug check information including new bug checks described in Bug Check
Code Reference such as Bug Check 0x1DE: BUGCODE_WIFIADAPTER_DRIVER.

Use the new Time Travel Debugging - TTD.exe command line utility to capture time
travel code execution traces.

The new TaskManager live dump feature built into Windows, is described in Task
Manager live memory dump

New Source Code Extended Access DebugInfoD topic that is now available in the
debugger. This supports file retrieval from DebugInfoD servers through the DebugInfoD*
tag.

Debugger 2PF KDNET Support describes how to enable your miniport NDIS driver for
2PF debugger support to allow increased performance for high speed adapters, often
used in data centers.

Three new EXDI debugging topics including Setting Up QEMU Kernel-Mode Debugging
using EXDI.

Published Supported Ethernet NICs for Network Kernel Debugging in Windows 11 with
updated information on NICs.

The AppVerifier docs formerly only available in a local “CHM” file are now available
online. Application Verifier (AppVerifier) is a runtime verification tool for unmanaged
code that assists in finding subtle programming errors, security issues and limited user
account privilege problems that can be difficult to identify with normal application
testing techniques.
Related Topics
For information on what was new for drivers in past Windows releases, see the following
pages:

Driver development changes for Windows 11, version 22H2

Driver development changes for Windows 11, version 21H2
Driver development changes for Windows Server 2022
Driver development changes for Windows 10, version 2004

Back to Top

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

What's new in driver development for
Windows 11, version 22H2
Article • 10/30/2023

This section describes new features and updates for driver development in Windows 11,
version 22H2.

ACPI
The ACPI documentation has been updated with new _OSI string information for
Windows 11, version 22H2.

How to Identify the Windows Version in ACPI by Using _OSI (Updated)

Audio
To improve reliability and debuggability new Windows 11 APIs for Audio
Processing Objects are available.
Windows 11 provides additional capabilities with the use of resource groups and
these are now discussed Audio Hardware Resource Management.
Audio experience for these devices can be optimized for specific device postures,
such as when a device is held in portrait mode. This is described in Supporting
Audio Posture.
KSStudio documentation is now available on line at KsStudio Utility.

Camera and streaming media drivers

The camera driver documentation has been updated with information on background
segmentation and eye gaze modes available in Windows 11, version 22H2.

Background segmentation portrait mode and eye gaze stare mode driver sample
(New)
KSPROPERTY_CAMERACONTROL_EXTENDED_BACKGROUNDSEGMENTATION
(Updated)
KSPROPERTY_CAMERACONTROL_EXTENDED_EYEGAZECORRECTION (Updated)
USB Video Class (UVC) camera implementation guide (Updated)

Driver security
 New code scanning CodeQL rules and updated installation directions, are now
available. For more information, see CodeQL and the Static Tools Logo Test.

File system and filter drivers

The ability to do trusted kernel-mode file copy was introduced in Windows 11, version
22H2. This feature includes the ability for filters to easily detect copy scenarios.

Mobile broadband
Windows 11, version 22H2 introduces the following mobile broadband features:

MBIM Extensions Release number 4.0 (MBIMEx 4.0) introduces support for 5G SA
Phase 2 features. The 5G SA Phase 2 feature set includes support for end-to-end
URSP handling and multiple concurrent eMBB network slices.

MBIMEx 4.0 introduces access to an eSIM in the inactive SIM slot.

An errata for MBIMEx 3.0 updates the original MBIMEx 3.0 specification.

Print device apps

The Print support app (PSA) design guide has been updated with information about new
PSA functionality available starting in Windows 11, version 22H2.

Display name localization and PDL Passthrough API integration

Page level feature support and operation attributes
Enhancing the print dialog with PSA
PDL conversion with host-based processing flags
Set Print Device Capabilities (PDC) update policy

Provisioning support for loading pre-

production drivers
How to test pre-production drivers with Secure Boot enabled

Windows Debugging Tools

Debugging Tools for Windows supports kernel debugging over a network cable
using multiple Physical Functions (PFs) on the supported NICs. This approach
 improves efficiency of debugging, particularly in traffic heavy cloud environments.
For more information see, Setting Up 2PF Kernel-Mode Debugging using KDNET.
A new low level OS independent debugger transport – EXDI is described in
Configuring the EXDI Debugger Transport. This transport can connect to virtualized
environments such as QEMU, this is described in Setting Up QEMU Kernel-Mode
Debugging using EXDI.
AppVerifier test content is now updated and the documentation is now available
online – Application Verifier - Overview.

WPP Recorder
Drivers can add timestamps to Inflight Trace Recorder (IFR) log entries. Timestamps can
specify millisecond or tenth of a microsecond granularity.

Inflight Trace Recorder

WPP_RECORDER_TRI_STATE enumeration
RECORDER_LOG_CREATE_PARAMS structure
WppRecorderLogCreate macro (wpprecorder.h)
What's new in driver development for
Windows 11, version 21H2
Article • 10/30/2023

This section describes new features and updates for driver development in Windows 11,
version 21H2.

Camera
Digital Window overview
Privacy shutter notification
Create device property keys from the MS OS descriptor in USB Video Class (UVC)
firmware
Microsoft extensions to USB Video Class 1.5 specification (Updated)
Network camera design guide (Updated)

HID
Use Human Interface Device (HID) class devices over a Serial Peripheral Interface (SPI)
bus.

Introduction to HID over SPI

Architecture and overview for HID over the SPI transport
Plug and Play support for HID over SPI
HID over SPI power management
Error handling for HID over SPI

New API pages:

hidspicx.h header
EVT_HIDSPICX_NOTIFY_POWERDOWN
EVT_HIDSPICX_RESETDEVICE
HIDSPICX_DEVICE_CONFIG
HIDSPICX_REPORT
HidSpiCxDeviceConfigure
HidSpiCxDeviceInitConfig
HidSpiCxNotifyDeviceReset

Print devices
 Print support app design guide
Print support app association

Back to Top
What's new in Windows Server 2022
Article • 05/20/2022

This section describes new features and updates for driver development in Windows
Server 2022.

Kernel

DMA/MDL updates
New API pages:

PCREATE_COMMON_BUFFER_FROM_MDL callback function

DMA_COMMON_BUFFER_EXTENDED_CONFIGURATION_TYPE enumeration
DMA_COMMON_BUFFER_EXTENDED_CONFIGURATION_ACCESS_TYPE
enumeration
DMA_COMMON_BUFFER_EXTENDED_CONFIGURATION structure

Updated:

DMA_OPERATIONS structure (new field CreateCommonBufferFromMdl)

NUMA (Non-Uniform Memory Access)

New API pages:

KeQueryNodeActiveAffinity2
KeQueryNodeActiveProcessorCount

Updated:

KeQueryNodeActiveAffinity
xKeQueryLogicalProcessorRelationship

NetAdapterCx
The new NetAdapterCx platform-level device reset (PLDR) feature provides an
effective way to reset and recover malfunctioning network devices without
rebooting the system.

NetAdapterCx support for the following hardware offloads has been updated:
 Checksum offload

Generic send offload (GSO)

Receive Segment Coalescing (RSC)

Networking
New network driver documentation and features include:

The new NDIS packet timestamping feature supports the hardware timestamping
capability of a network interface card (NIC) for the Precision Time Protocol (PTP)
version 2.

The new NDIS Poll Mode feature is an OS controlled polling execution model that
drives the network interface datapath.

The Virtual Machine Multiple Queues (VMMQ) NIC offload technology extends
Native RSS (RSSv1) to a Hyper-V virtual environment.

Windows Driver Frameworks (WDF)

In Windows Server 2022, the Windows Driver Framework (WDF) includes Kernel-Mode
Driver Framework (KMDF) version 1.33 and User-Mode Driver Framework (UMDF)
version 2.33.

For info on what's included in these framework versions, see What's New for WDF
Drivers in Windows 10. To see what was added in previous versions of WDF, see:

KMDF Version History

UMDF Version History

Debugger
For information on what is new on the WinDbg Preview debugger, see WinDbg Preview
- What's New. Highlights include:

Portable PDB Symbols support.

Support for Open Enclave debugging- WinDbg Preview can now debug Open
Enclave (OE) applications.
For user mode time travel debugging, a new timeline window displays a visual
representation of important events in your trace: exceptions, breakpoints, function
 calls, and memory accesses. For more information, see WinDbg Preview - Timeline.

Updates and addtions to debug transport topics, such as Setting Up KDNET Network
Kernel Debugging Automatically, Setting Up Kernel-Mode Debugging over USB EEM on
an Arm device using KDNET and Setting Up 2PF Kernel-Mode Debugging using KDNET.

Bugcheck stop code topic addtions and updates, including listing live dump codes in a
new section - Kernel Live Dump Code Reference.

Driver Quality
New CodeQL and the Static Tools Logo Test and Supplemental Windows Driver CodeQL
Queries.

Updates and additions to Driver Verfier rules, for example the new DoubleFetch rule.

Driver Security
Updates to the Driver Security Checklist.

Audio
Updated and new topics including:

Default Audio Endpoint Selection Starting in Windows 10

Multiple Voice Assistant
Voice Activation
Low Latency Audio

New online help for the KsStudio Utility.

What's new in Windows 10, version 2004
Article • 09/10/2024

This section describes new features and updates for driver development in Windows 10,
version 2004 (Windows 10 May 2020 Update).

Windows Drivers
Windows 10, version 2004 is a transition release for Universal drivers. In this release,
Universal drivers still exist, but are being extended with Windows Drivers. A Windows
Driver is a Universal driver with additional requirements.

Windows Drivers are distinguished from Windows Desktop Drivers. While Windows
Drivers run on all Windows editions, Windows Desktop Drivers run only on Windows 10
Desktop editions.

No changes are required to Universal drivers for the version 2004 release, but
documentation is available now so that you can plan ahead for upcoming changes.

For information about how to build, install, deploy, and debug a Windows Driver, see
Get started developing Windows drivers.

Windows Hardware Error Architecture (WHEA)

WHEA includes a new interface (v2). For info about how to register as an error source
and report errors, see Using WHEA on Windows 10.

Display and Graphics Drivers

Several new and enhanced display and graphics driver features are available in Windows
10, version 2004, including D3D12 mesh shader support, sampler support, raytracing
extensions, video motion estimation, and video protected resources support. See What's
New for Windows 10 Display and Graphics Drivers for more details about these new
features.

Storage Drivers
A storage miniport driver can now get and set more information about a device's
internal state, including the ability to reset a device. See
IOCTL_STORAGE_GET_DEVICE_INTERNAL_LOG and StorPortHardwareReset as good
starting points.

Windows Debugger

WinDbg Preview

Updates to WinDbg Preview to cover new features such as WinDbg Preview - Timelines.
Time travel timelines allows for the visualization of time travel code execution traces.

Stop Codes
Updates to the Bug Check Code Reference topics and the addition of new
parameters to topics such as Bug Check 0x1A: MEMORY_MANAGEMENT and Bug
Check 0xC4: DRIVER_VERIFIER_DETECTED_VIOLATION.

New stop codes such as Bug Check 0x1DA:

HAL_BLOCKED_PROCESSOR_INTERNAL_ERROR, Bug Check 0x1A2:
WIN32K_CALLOUT_WATCHDOG_BUGCHECK and Bug Check 0x119:
VIDEO_SCHEDULER_INTERNAL_ERROR.

Driver Security
Updates to the Driver security checklist to use the BinSkim tool.

Deprecated features
The following table describes Windows driver development features that have been
removed in Windows 10.

ﾉ Expand table

Driver technology Feature Deprecated in

GNSS/Location Geolocation driver sample for Windows 8.1 and related Windows 10,
documentation version 1709

Mobile Operator AllowStandardUserPinUnlock Windows 10,

Scenarios version 1709
(Networking)

Scan/Image WSD (Web Services for Devices) Challenger Windows 10,

 Driver technology Feature Deprecated in

functionality and related documentation version 1709

Mobile Operators Mobile broadband app experience apps with Sysdev Windows 10,
metadata packages are deprecated in favor of MO version 1803
UWP APPS and COSA.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Download the Windows Driver Kit
(WDK)
Article • 09/24/2024

The WDK is used to develop, test, and deploy drivers for Windows. The most recent
public release is WDK 10.0.26100.1591 (released September 18, 2024).

You can install and run this WDK on Windows 7 and later.

You can use this kit to build drivers for Windows 10, Windows Server 2016 and
later client and server versions.

To target Windows 8.1, Windows 8, and Windows 7, install an older WDK and an older
version of Visual Studio either on the same machine or on a separate machine. For links
to older kits, see Other WDK downloads.

Join the Windows Insider Program to get WDK Insider Preview builds . For
installation instructions for the Windows Insider Preview builds, see Installing preview
versions of the Windows Driver Kit (WDK).

WDK NuGet package support

WDK is available as a NuGet package starting from version 10.0.26100.1. Users can
access and use these packages directly from nuget.org within Visual Studio. WDK NuGet
package provides a convenient way to acquire and update the WDK, it also manages
dependencies such as the SDK, helping to keep the driver development toolchain
current. For more information, see Install the latest WDK using NuGet.

ARM64 support
Starting with WDK version 10.0.26100.1, the WDK now supports the development,
testing, and deployment of drivers on ARM64 machines. The WDK/EWDK can be
installed and run natively on ARM64 hardware. Additionally, the previously supported
emulation of x86 KMDF/UMDF2 drivers on ARM64 hardware is still available. Also,
debugging and deploying drivers to an ARM64 target machine is now supported from
both ARM64 and x64 host machines. When installing the WDK/EWDK on ARM64
machines, the process will automatically identify and install all necessary dependencies,
including build tools, binaries, and libraries.
 Step 1: Install Visual Studio 2022
The WDK requires Visual Studio. For more information about system requirements for
Visual Studio, see Visual Studio 2022 System Requirements.

The following editions of Visual Studio 2022 support driver development for this release:

Download Visual Studio Community 2022

Download Visual Studio Professional 2022

Download Visual Studio Enterprise 2022

When you install Visual Studio 2022, select the Desktop development with C++
workload, then under Individual Components add:

MSVC v143 - VS 2022 C++ ARM64/ARM64EC Spectre-mitigated libs (Latest)

MSVC v143 - VS 2022 C++ x64/x86 Spectre-mitigated libs (Latest)

C++ ATL for latest v143 build tools with Spectre Mitigations (ARM64/ARM64EC)

C++ ATL for latest v143 build tools with Spectre Mitigations (x86 & x64)

C++ MFC for latest v143 build tools with Spectre Mitigations (ARM64/ARM64EC)

C++ MFC for latest v143 build tools with Spectre Mitigations (x86 & x64)

Windows Driver Kit

 Tip

Use the Search box to look for "64 latest spectre" (in English installations) or "64
latest" (in non-English installations) to quickly see these components.
 ７ Note

The Desktop development with C++ workload selected above does not install the
Windows SDK 10.0.26100.1.

Step 2: Install SDK

Installing Visual Studio will not download the latest SDK version, use the following link
to install SDK:

Download Windows SDK 10.0.26100.1

The provided links for the SDK and the WDK have matching build numbers, which is
always required for the kits to work together. If you decide to install your own SDK/WDK
pair, perhaps for a different Windows version, ensure that the build numbers match. For
more details, see Kit versioning.

Step 3: Install WDK

Download WDK 10.0.26100.1591

The WDK Visual Studio extension is included in the default WDK installation.
In Visual Studio versions 17.11.0 and later, the WDK extension should be installed with
Visual Studio. However, the WDK installer settings still show the checkbox for the VSIX
extension installation. You need to deselect this checkbox to prevent an install failure.

 Tip

If you can't find driver project templates in Visual Studio, the WDK Visual Studio
extension didn't install properly. To resolve this,launch Visual Studio Installer, click
"Modify", add "Windows Driver Kits" in the Individual Component tab and Click
"Modify"

Enterprise WDK (EWDK)

As an alternative to downloading Visual Studio, the SDK, and the WDK, you can
download the EWDK, which is a standalone, self-contained command-line environment
for building drivers. It includes Visual Studio Build Tools, the SDK, and the WDK.

The latest public version of the EWDK contains Visual Studio 2022 Build Tools 17.10.5
and MSVC toolset v14.40
The EWDK also requires the .NET Framework version 4.7.2. For more information about
other requirements for the .NET Framework, see .NET Framework system requirements.

Download EWDK 10.0.26100.1591 with Visual Studio Build Tools

Once you have downloaded the ISO, use these steps to set up your build environment:

1. Mount the EWDK ISO from a drive volume. Network share paths aren't currently
supported.

2. Run 'LaunchBuildEnv.cmd'.

3. In the environment created in step 2, type SetupVSEnv, and then press Enter.

4. Launch devenv.exe from the same environment, using the full file path. For
example: "C:\Program Files\Microsoft Visual
Studio\2022\%Community|Professional|Enterprise%\Common7\IDE\devenv.exe"

5. When you're done with the build environment, you may want to eject the ISO.

You can optionally use the Visual Studio interface with the build tools provided in the
EWDK. To do this, ensure that the Visual Studio major version matches the version of the
Visual Studio Build Tools in the EWDK. For example, Visual Studio 2022 works with the
EWDK that contain VS17.X build tools. For a list of Visual Studio 2022 version numbers,
see Visual Studio 2022 Releases.

Kit versioning
A full kit build string includes as its last two components, the build number and a QFE
(Quick Fix Engineering) value. For example, 10.0.22621.2428 has a build number of
22621, and a QFE value of 2428.

To build a driver, the build number of your SDK installation must match the build number
of your WDK installation. The QFE values does not need to match unless your driver
uses functionality that is only available in the headers included with a later QFE.

A quick way to see the full build string for locally installed kits is to go to Windows
settings (Win+I), navigate to Apps, then Installed apps, and in the Search box type kit .
The full build string appears to the right of the kit name. If you navigate to C:\Program
Files (x86)\Windows Kits\10\Include , note that the QFE shown there is hardcoded to
.0 , so this is not a reliable way to check your QFE identifier. Also note that when you

install a kit, the new installation replaces any previously existing installation of the same
build number. When you install Visual Studio with the Desktop development with C++
workload, if the installation payload includes the Windows SDK, the right-hand
Summary pane also shows a hardcoded .0 for QFE.

Driver samples for Windows

To download the driver samples, do one of the following:

Go to the driver samples page on GitHub , click Clone or download, and then
click Download ZIP.

Download the GitHub Extension for Visual Studio , and then connect to the
GitHub repositories.

Browse the driver samples on the Microsoft Samples portal.

Related downloads
Download the WDK Insider Preview

Download previous versions of the WDK

Download the Windows Assessment and Deployment Kit (Windows ADK)

Download the Windows HLK

Download the Windows Debugging Tools (WinDbg)

Download Windows Symbol Packages

See also
Windows 11 hardware requirements

Install the WDK using WinGet

Learn what's new in driver development

Review known issues

Feedback
Was this page helpful?
  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Install the WDK using NuGet
Article • 09/23/2024

This topic describes how to use NuGet to install the Windows Driver Kit on your
computer. NuGet is a popular package manager, used for packaging and distributing
software. For more information, see What is NuGet?.

Windows Drivers Kit Overview

Windows Driver Kit (WDK) is a software tool set used to develop, test and deploy
Windows drivers. The content included in the WDK can be categorized into five unique
types: Headers, Libraries, Samples, Tools and Templates.

The WDK is released in three different distributions, with different installation options.

Windows Driver Kit (WDK): The WDK is available as a traditional msi based package. It
requires Visual Studio to be installed and the WDK is installed to
%ProgramFiles(x86)%\Windows Kits\ . See Download the Windows Driver Kit (WDK) for

information on downloading and installing the WDK.

Enterprise Windows Drivers Kit (EWDK): This is shipped as a standalone ISO, which
includes the command line compiler build tools, the SDK and the WDK. The EWDK is a
standalone self-contained command-line environment. To get started, just mount the
ISO and run LaunchBuildEnv. Visit Download the Windows Driver Kit (WDK) for details
on how to download and use the EWDK.

Windows Drivers Kit NuGet Package: The WDK NuGet package consists of essential
libraries, headers, DLL, tools and metadata used for building Windows drivers that can
be shared and supported by modern CI/CD pipelines. The official release of the WDK
NuGet package is now available on nuget.org. The latest release version is
10.0.26100.1591. For information on the latest release of the WDK, SDK and Visual
Studio, see Kit versioning.

Developers can access and integrate Windows Driver Kit (WDK) NuGet packages directly
from Visual Studio via the NuGet Package Manager. By utilizing these packages, driver
developers can seamlessly install essential build tools into their projects, facilitating a
streamlined and efficient process for acquiring WDK. Moreover, the use of WDK NuGet
packages allows for more frequent updates and releases, and they can be easily
integrated into build systems within CI/CD pipelines. For more information, see Install
and manage packages in Visual Studio using the NuGet Package Manager.
Here are the links to the x64 and ARM64 WDK NuGet packages available on nuget.org.

x64: https://www.nuget.org/packages/Microsoft.Windows.WDK.x64/

ARM64: https://www.nuget.org/packages/Microsoft.Windows.WDK.ARM64

Directions for building drivers in automated build

systems
For directions on building drivers in large automated system, see Building Locally .

Getting Started with WDK NuGet

Prerequisites
X64/ARM64 PC with Windows 11 or newer.

Install Visual Studio 2022

The WDK NuGet requires Visual Studio. Download and install Visual Studio 2022
Community, Professional, or Enterprise edition.

Download Visual Studio Tools

When you install Visual Studio 2022, select the Desktop development with C++
workload, then under Individual Components add:

MSVC v143 - VS 2022 C++ ARM64/ARM64EC Spectre-mitigated libs (Latest)

MSVC v143 - VS 2022 C++ x64/x86 Spectre-mitigated libs (Latest)

C++ ATL for latest v143 build tools with Spectre Mitigations (ARM64/ARM64EC)

C++ ATL for latest v143 build tools with Spectre Mitigations (x86 & x64)

C++ MFC for latest v143 build tools with Spectre Mitigations (ARM64/ARM64EC)

C++ MFC for latest v143 build tools with Spectre Mitigations (x86 & x64)

Windows Driver Kit

How to Install WDK NuGet

Follow the following steps to acquire and install WDK NuGet package in Visual Studio.

1. Launch Visual Studio.

2. Create a new driver project, for example a "Kernel Mode Driver (KMDF)" C++
project.

3. Right Click the driver project solution file, and select Manage NuGet packages.

4. Click the drop down menu beside the package source and select nuget.org .

5. Search for "WDK".

6. Select Microsoft.Windows.WDK.x64 or Microsoft.Windows.WDK.ARM64 based on the

platform architecture that you wish to develop for.

7. Leave other checkboxes set at their defaults.

8. Select Install.

７ Note

The SDK NuGet package will automatically be installed as part of WDK NuGet
installation.

1. Review and accept the license terms to complete the installation.

 1. Build and test your WDK driver solution.

７ Note

Use of the dotnet command line doesn't work with WDK, and its use is not
recommended.

How to Update WDK NuGet

To update NuGet Packages in existing driver projects, follow these steps.

1. Open the existing driver project in Visual Studio.

2. Right Click the driver project solution file, and select Manage NuGet packages.

3. Click on the Updates tab.

4. Click on the Include prerelease box, if you wish to use prerelease WDK packages.
 5. Select the packages you wish to update in the list.

1. Select Install.

2. Select Apply.

Review and accept the license terms to complete the installation.

See also
What is NuGet?

Use command-line parameters to install, update, and manage Visual Studio

Download Visual Studio Tools

Related downloads
Download current version of the WDK and Enterprise WDK manually

Download previous versions of the WDK manually

Download the Windows Debugging Tools (WinDbg)

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Install the WDK using WinGet
Article • 09/18/2024

You can use the Windows Package Manager (WinGet) tool to install or update the
Windows Driver Kit on your computer, along with its dependencies such as Visual Studio
and the Windows Software Development Kit, all from the command line.

Refer to the WinGet install documentation if you need help making sure that you have
WinGet installed and configured correctly.

Install the latest WDK step by step using

WinGet
The latest version of the WDK is 10.0.26100.1591. It requires Visual Studio 2022 and
Windows SDK 10.0.26100.1 For more info, see Kit versioning.

Step 1: Install Visual Studio 2022

The WDK requires Visual Studio 2022 with the Desktop development with C++
workload installed, along with the VS 2022 C++ build tools and their corresponding VS
2022 C++ Spectre-mitigated libs (Latest) components for each architecture you intend
to build drivers for.

You can use WinGet to install Visual Studio 2022 with all the workloads and components
required for driver development. To do so, you need a Visual Studio installation
configuration file. Create a wdk.vsconfig file with the following contents and take note
of its location:

JSON

{
"version": "1.0",
"components": [
"Microsoft.Component.MSBuild",
"Microsoft.VisualStudio.Component.CoreEditor",
"Microsoft.VisualStudio.Component.NuGet",
"Microsoft.VisualStudio.Component.Roslyn.Compiler",
"Microsoft.VisualStudio.Component.TextTemplating",
"Microsoft.VisualStudio.Component.VC.ASAN",
"Microsoft.VisualStudio.Component.VC.ATL.ARM64.Spectre",
"Microsoft.VisualStudio.Component.VC.ATL.ARM64",
"Microsoft.VisualStudio.Component.VC.ATL.Spectre",
"Microsoft.VisualStudio.Component.VC.ATL",
 "Microsoft.VisualStudio.Component.VC.ATLMFC.Spectre",
"Microsoft.VisualStudio.Component.VC.ATLMFC",
"Microsoft.VisualStudio.Component.VC.CoreIde",
"Microsoft.VisualStudio.Component.VC.MFC.ARM64.Spectre",
"Microsoft.VisualStudio.Component.VC.MFC.ARM64",
"Microsoft.VisualStudio.Component.VC.Redist.14.Latest",
"Microsoft.VisualStudio.Component.VC.Runtimes.ARM64.Spectre",
"Microsoft.VisualStudio.Component.VC.Runtimes.ARM64EC.Spectre",
"Microsoft.VisualStudio.Component.VC.Runtimes.x86.x64.Spectre",
"Microsoft.VisualStudio.Component.VC.Tools.ARM64",
"Microsoft.VisualStudio.Component.VC.Tools.ARM64EC",
"Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
"Microsoft.VisualStudio.Component.Windows10SDK",
"Microsoft.VisualStudio.ComponentGroup.NativeDesktop.Core",
"Microsoft.VisualStudio.Workload.CoreEditor",
"Microsoft.VisualStudio.Workload.NativeDesktop"
]
}

Depending on the edition you would like to install, you will need to provide winget with
a different set of installer parameters along with the path to the .vsconfig file you have
just created to customize your installation.

Ｕ Caution

You must provide an absolute path to your wdk.vsconfig file in the following
commands. Otherwise, WinGet may fail to install Visual Studio while still reporting
success.

Visual Studio Community 2022:

Windows Command Prompt

winget install --source winget --exact --id

Microsoft.VisualStudio.2022.Community --override "--passive --config
<vsconfig-folder>\wdk.vsconfig"

Visual Studio Professional 2022:

Windows Command Prompt

winget install --source winget --exact --id

Microsoft.VisualStudio.2022.Professional --override "--passive --config
<vsconfig-folder>\wdk.vsconfig""

Visual Studio Enterprise 2022:

 Windows Command Prompt

winget install --source winget --exact --id

Microsoft.VisualStudio.2022.Enterprise --override "--passive --config
<vsconfig-folder>\wdk.vsconfig"

You can check Visual Studio documentation on How to use WinGet to install or modify
Visual Studio for more details.

Step 2: Install Windows SDK and WDK

You can install both the Windows SDK and WDK from WinGet by running the following
commands:

Windows SDK:

Windows Command Prompt

winget install --source winget --exact --id Microsoft.WindowsSDK.10.0.26100

--log $env:USERPROFILE/Desktop/sdk-install.log

Windows WDK:

Windows Command Prompt

winget install --source winget --exact --id Microsoft.WindowsWDK.10.0.26100

--log $env:USERPROFILE/Desktop/wdk-install.log

If you are using VS 17.11.0 or later, uncheck the install extension checkbox.

Step 3: Install WDK Visual Studio extension

７ Note

This section is only application when using VS earlier than 17.11.0 release

After installing the WDK from command line, you will need to install the Windows Driver
Kit Visual Studio extension separately to be able to build and test drivers. By default, the
extension is located under %ProgramFiles(x86)%\Windows
Kits\10\Vsix\VS2022\10.0.26100.0\%PROCESSOR_ARCHITECTURE%\WDK.vsix .

Using Command Prompt:

 Windows Command Prompt

for /f "usebackq tokens=*" %i in (`"%ProgramFiles(x86)%\Microsoft Visual

Studio\Installer\vswhere.exe" -nologo -latest -products * -property
enginePath`) do (
"%i\VSIXInstaller.exe" "%ProgramFiles(x86)%\Windows
Kits\10\Vsix\VS2022\10.0.26100.0\%PROCESSOR_ARCHITECTURE%\WDK.vsix"
)

Using PowerShell:

PowerShell

& $(& "${env:ProgramFiles(x86)}\Microsoft Visual

Studio\Installer\vswhere.exe" -nologo -latest -products * -property
enginePath | Join-Path -ChildPath 'VSIXInstaller.exe')
"${env:ProgramFiles(x86)}\Windows
Kits\10\Vsix\VS2022\10.0.26100.0\${env:PROCESSOR_ARCHITECTURE}\WDK.vsix"

Install other WDK versions using WinGet

You can install multiple kits for different Windows versions from WinGet.

７ Note

For versions 22000 (targeting Windows 11, version 21H2) and older, you need to
install an older version of Visual Studio. See Other WDK downloads > Step 1:
Install Visual Studio to find the required Visual Studio version for the WDK version
you would like to install.

You can search for other available kit versions using the winget search command.

Windows SDK:

Windows Command Prompt

winget search --source winget --id Microsoft.WindowsSDK

Windows WDK:

Windows Command Prompt

winget search --source winget --id Microsoft.WindowsWDK

Each command will return a table with all the available SDK/WDK versions in WinGet.
For example, when looking for all the available WDK versions, a table like this will be
shown:

Windows Command Prompt

Name Id
Version Source
----------------------------------------------------------------------------
----------------------
Windows Driver Kit - Windows 10.0.22621.2428 Microsoft.WindowsWDK.10.0.22621
10.1.22621.2428 winget
Windows Driver Kit - Windows 10.1.22000.1 Microsoft.WindowsWDK.10.0.22000
10.1.22000.1 winget
Windows Driver Kit Microsoft.WindowsWDK.10.0.19041
10.1.19041.685 winget
Windows Driver Kit - Windows 10.0.26100.1 Microsoft.WindowsWDK.10.0.26100
10.1.26100.1 winget

You can then install your required combination of kits for a specific <kit-version> using
winget install :

Windows SDK:

Windows Command Prompt

winget install --source winget --exact --id Microsoft.WindowsSDK.10.0.<kit-

version>

Windows WDK:

Windows Command Prompt

winget install --source winget --exact --id Microsoft.WindowsWDK.10.0.<kit-

version>

７ Note

If the Windows Driver Kit version you are looking for is not available in WinGet, you
will need to download and install it separately from Other WDK downloads.

Unless you have the WDK Visual Studio extension from a newer WDK installed already,
you will need to install it manually. It's located by default under
%ProgramFiles(x86)%\Windows Kits\10\Vsix\<vs-version>\10.0.<kit-
version>.0\WDK.vsix for kit versions 22621 and newer, or %ProgramFiles(x86)%\Windows
Kits\10\Vsix\<vs-version>\WDK.vsix for kit versions 22000 and older.

Locate first the folder for the <vs-version> that you will be using ( VS2022 for versions
22621 and newer, VS2019 for versions 18362 thru 22000). If that folder contains multiple
versioned folders, locate the folder inside with the latest version number. Take note of
this location as <wdk-vsix-folder> if you want to install the extension from command
line.

Using Command Prompt:

Windows Command Prompt

for /f "usebackq tokens=*" %i in (`"%ProgramFiles(x86)%\Microsoft Visual

Studio\Installer\vswhere.exe" -nologo -latest -products * -property
enginePath`) do (
"%i\VSIXInstaller.exe" "<wdk-vsix-folder>\WDK.vsix"
)

Using PowerShell:

PowerShell

& $(& "${env:ProgramFiles(x86)}\Microsoft Visual

Studio\Installer\vswhere.exe" -nologo -latest -products * -property
enginePath | Join-Path -ChildPath 'VSIXInstaller.exe') "<wdk-vsix-
folder>\WDK.vsix"

Install a full driver development environment

using a WinGet configuration file
By using a WinGet Configuration file, you can set up a new machine for driver
development with minimal manual intervention.

A configuration file for installing the Windows 11, version 24H2 WDK and its
dependencies is provided for your convenience. This configuration will set up the
following components:

Visual Studio 2022 Community.

Visual Studio required workflows and components for driver development.
Windows 11, version 24H2 SDK.
Windows 11, version 24H2 WDK.
WDK Visual Studio Extension.
Although using a configuration description file works better for provisioning a new
machine, you can use it even if you have some of the components installed already and
WinGet will attempt to only install the missing components.

 Tip

You can directly download and install the WDK configuration file using PowerShell.
After installing the latest version of WinGet, you can run the following commands:

PowerShell

# Open a new PowerShell terminal if needed

powershell

# Download configuration file to install WDK with VS 2022 Community

Invoke-WebRequest -Uri 'https://raw.githubusercontent.com/microsoft/Windows-
driver-samples/main/configuration.dsc.yaml' -OutFile configuration.dsc.yaml

# Install VS, SDK, WDK and WDK VS extension using the configuration file
winget configure -f configuration.dsc.yaml

Step 1: Set up WinGet

Make sure that you have WinGet version 1.6 or higher installed on the machine you
would like to provision. You can do so by running winget --version on your terminal
and checking that the output version number is v1.6.2631 or greater. If not, or if the
terminal throws an error telling that the command does not exist, you will need to install
the latest version of WinGet before proceeding.

Step 2: Download the WDK Configuration file

The configuration description file can be downloaded from here . Save this file as
configuration.dsc.yml and take note of its location.

 Tip

The provided configuration file will install the Community edition of Visual Studio
2022. If you need a different edition, you can edit
Microsoft.VisualStudio.2022.Community and
Microsoft.VisualStudio.Product.Community product IDs with different IDs for the

edition you would like to install (for Professional:

 Microsoft.VisualStudio.2022.Professional and
Microsoft.VisualStudio.Product.Professional ; for Enterprise:

Microsoft.VisualStudio.2022.Enterprise and
Microsoft.VisualStudio.Product.Enterprise ).

Step 3A: Run WinGet configure to install WDK

Configuration file
On a command line under the directory where the WDK configuration file was saved,
run the following command to configure your machine using that file:

Windows Command Prompt

winget configure -f configuration.dsc.yaml

Step 3B: Use Dev Home to install WDK Configuration file

Alternatively, if you have Dev Home installed, you can use it to configure your machine.
Select "Machine configuration" from the sidebar, then "Set up development
environment" > "Configuration file" on the main screen to open the WDK configuration
file that you have downloaded. After confirming that you would like to use that file to
configure your machine, installation will proceed and, after it completes, you should
have an environment ready for driver development.

See also
Use the WinGet tool to install and manage applications
WinGet Configuration: How to set up a machine using winget and a configuration
file
Use command-line parameters to install, update, and manage Visual Studio
Windows 11 hardware requirements

Related downloads
Download current version of the WDK and Enterprise WDK manually
Download previous versions of the WDK manually
Download the Windows Assessment and Deployment Kit (Windows ADK)
Download the Windows HLK
Download the Windows Debugging Tools (WinDbg)
 Download Windows Symbol Packages

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Installing preview versions of the
Windows Driver Kit (WDK)
Article • 08/23/2024

This page contains installation instructions for Insider Preview (pre-release) versions of
the Windows Driver Kit (WDK). The download links for the latest pre-release version of
the WDK and the EWDK are on https://www.microsoft.com/software-
download/windowsinsiderpreviewWDK .

Install Windows Driver Kit (WDK) Insider

Preview

1. Install Visual Studio

The WDK now supports Visual Studio 2022. All editions are supported. The WDK
no longer supports Visual Studio 2019.
Download from Visual Studio 2022.
Select workload: Development with C++.
For Arm64 and Arm64EC drivers, you must additionally install the component:
Individual components -> Compilers, build tools, and runtimes -> Visual C++
compilers and libraries for Arm64/Arm64EC. Note that the WDK has Spectre
mitigation enabled by default but requires Spectre mitigated libraries to be
installed with Visual Studio for each architecture you are developing for.

2. Disable strong name validation

The WDK Visual Studio Extensions are currently not strong name signed. Run the
following commands from an elevated command prompt to disable strong name
validation:

C++

reg add
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\StrongName\Verification\*,31bf3856ad36
4e35 /v TestPublicKey /t REG_SZ /d
00240000048000009400000006020000002400005253413100040000010001003f8c902c8fe7
ac83af7401b14c1bd103973b26dfafb2b77eda478a2539b979b56ce47f36336741b4ec52bbc5
1fecd51ba23810cec47070f3e29a2261a2d1d08e4b2b4b457beaa91460055f78cc89f21cd028
377af0cc5e6c04699b6856a1e49d5fad3ef16d3c3d6010f40df0a7d6cc2ee11744b5cfb42e0f
19a52b8a29dc31b0 /f
 reg add
HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\StrongName\Verification\*,
31bf3856ad364e35 /v TestPublicKey /t REG_SZ /d
00240000048000009400000006020000002400005253413100040000010001003f8c902c8fe7
ac83af7401b14c1bd103973b26dfafb2b77eda478a2539b979b56ce47f36336741b4ec52bbc5
1fecd51ba23810cec47070f3e29a2261a2d1d08e4b2b4b457beaa91460055f78cc89f21cd028
377af0cc5e6c04699b6856a1e49d5fad3ef16d3c3d6010f40df0a7d6cc2ee11744b5cfb42e0f
19a52b8a29dc31b0 /f

3. Install SDK Insider Preview

Get SDK Insider Preview

4. Install WDK Insider Preview

Get WDK Insider Preview

７ Note

During installation you will see the Visual Studio installer install the WDK Visual
Studio Extensions. See Download the Windows Driver Kit for additional
information.

Install Enterprise WDK (EWDK) Insider Preview

As an alternative to the above steps, the EWDK is a standalone self-contained
command-line environment for building drivers that includes Build Tools for Visual
Studio 2022. See more at Installing the Enterprise WDK.

Get the Enterprise Windows Driver Kit (EWDK) Insider Preview

To get started, disable strong name validation by running the following commands from
an elevated command prompt:

Console

reg add
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\StrongName\Verification\*,31bf3856ad36
4e35 /v TestPublicKey /t REG_SZ /d
00240000048000009400000006020000002400005253413100040000010001003f8c902c8fe7
ac83af7401b14c1bd103973b26dfafb2b77eda478a2539b979b56ce47f36336741b4ec52bbc5
1fecd51ba23810cec47070f3e29a2261a2d1d08e4b2b4b457beaa91460055f78cc89f21cd028
377af0cc5e6c04699b6856a1e49d5fad3ef16d3c3d6010f40df0a7d6cc2ee11744b5cfb42e0f
 19a52b8a29dc31b0 /f

reg add
HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\StrongName\Verification\*,
31bf3856ad364e35 /v TestPublicKey /t REG_SZ /d
00240000048000009400000006020000002400005253413100040000010001003f8c902c8fe7
ac83af7401b14c1bd103973b26dfafb2b77eda478a2539b979b56ce47f36336741b4ec52bbc5
1fecd51ba23810cec47070f3e29a2261a2d1d08e4b2b4b457beaa91460055f78cc89f21cd028
377af0cc5e6c04699b6856a1e49d5fad3ef16d3c3d6010f40df0a7d6cc2ee11744b5cfb42e0f
19a52b8a29dc31b0 /f

Then mount the ISO that you downloaded from the Insider Preview page and select
LaunchBuildEnv to use the EWDK.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Other WDK downloads
Article • 06/26/2024

The Windows Driver Kit (WDK) is used to develop, test, and deploy Windows Drivers.
This topic contains information about versions of the Windows Driver Kit (WDK),
Enterprise WDK (EWDK), and additional downloads for support purposes. To develop
drivers, use the latest public versions of the Windows Driver Kit (WDK) and tools,
available for download on Download the Windows Driver Kit (WDK).

To use these earlier versions, you must first install the version of Visual Studio that is
appropriate for your targeted platform.

Runtime requirements
Starting with the Windows 11, version 22H2 release of the WDK and EWDK, the kits
support:

Visual Studio 2022 exclusively

Building and testing kernel-mode drivers for x64 and Arm64
Building and testing drivers for Windows 10, Windows Server 2016 and later client
and server versions
Side by side (SxS) support with previous WDK/EWDK

Multiple WDKs and EWDKs can be installed concurrently on the same computer and
even be part of the same build system. You can run the Windows 11, version 22H2 WDK
on Windows 7 and later.

To target Windows 8.1, Windows 8, and Windows 7, install an older WDK (Windows 11,
version 21H2 and previous) and an older version of Visual Studio either on the same
machine or on a separate machine. For links to older kits, see the table below.

Certain device-specific stacks (for example graphics) continue to have x86/ARM32 user-
mode components to support x86/ARM32 apps.

Additionally, starting with Windows 11, version 22H2 release of the WDK and EWDK,
WDF redistributable co-installers are no longer supported. To learn how to work around
this change, see WDK Known Issues.

You can run the Windows 11, version 21H2 WDK (including the WDK for Windows
Server 2022) on Windows 7 and later, to develop drivers for the following operating
systems:
 ﾉ Expand table

Client OS Server OS

Windows 11, version 21H2 Windows Server 2022

Windows 10 Windows Server 2019, Windows Server 2016

Windows 8.1 Windows Server 2012 R2

Windows 8 Windows Server 2012

Windows 7 Windows Server 2008 R2 SP1

Step 1: Install Visual Studio

The WDK requires Visual Studio. For more information about system requirements for
Visual Studio, see Visual Studio 2022 System Requirements.

The following table indicates which Visual Studio version is required for the different
releases of the WDK.

ﾉ Expand table

Targeted versions of Windows Edition(s) of Visual Studio

Windows 11, version 23H2 Visual Studio Community 2022

Windows 11, version 22H2 Visual Studio Professional 2022
Windows 11, version 24H2 Visual Studio Enterprise 2022

Windows 11, version 21H2 Visual Studio Community 2019

Windows Server 2022 Visual Studio Professional 2019
Windows 10, version 2004 Visual Studio Enterprise 2019
Windows 10, version 1903

Windows 10, version 1809 Visual Studio Community 2017

Windows 10, version 1803 Visual Studio Professional 2017
Windows 10, version 1709 Visual Studio Enterprise 2017

Windows 10, version 1703 Visual Studio Express 2015 for Desktop
Windows 10, version 1607 Visual Studio Community 2015
Visual Studio Professional 2015
Visual Studio Enterprise 2015

Windows 8.1 Update Visual Studio 2013

Windows 8.1

Windows 8 Visual Studio Professional 2012

 Targeted versions of Windows Edition(s) of Visual Studio

Visual Studio Ultimate 2012

Configure Visual Studio for Windows 11, version 22H2,

version 21H2 and Windows 10, versions 1709, 1803, 1809,
1903, 2004, and Windows Server 2022
When you install Visual Studio, select the Desktop development with C++ workload.
The Windows 11 Software Development Kit (SDK) is automatically included and is
displayed in the right-hand Summary pane.

To develop drivers for Arm/Arm64, choose Individual components and under

Compilers, build tools, and runtimes select Visual C++ compilers and libraries for
Arm/Arm64.

Install the Windows SDK to target Windows 10, versions

1607 and 1703
If your development targets systems that run Windows 10, version 1607 or Windows 10,
version 1703, you should install Visual Studio 2015, and then also download and install
the version of the Windows SDK for the targeted version of Windows 10, as identified in
the following table.

ﾉ Expand table

Targeted versions of Windows Version of Windows SDK

Windows 10, version 1703 Windows SDK for Windows 10.0.15063.468

Windows 10, version 1607 Windows SDK for Windows 10.0.14393.795

Windows 8.1 Windows SDK for Windows 8.1

Windows 8 Windows SDK for Windows 8

The Windows SDK was not included in Visual Studio 2015, so you must install the SDK
separately. Later versions of Visual Studio include the Windows SDK.

Step 2: Install the WDK

The WDK is integrated with Visual Studio and Debugging Tools for Windows (WinDbg).
This integrated environment gives you the tools you need to develop, build, package,
deploy, test, and debug drivers.

７ Note

Starting with Windows 10, version 1709, installing the WDK will by default install
the WDK extensions for Visual Studio. These extensions are required for integration
of the WDK with Visual Studio.

ﾉ Expand table

Released with WDK and related downloads

Windows 11, WDK 10.0.26100.1 (released May 22, 2024)

Version 24H2

Windows 11, WDK 10.1.22621.2428 (released October 24, 2023)

Version 23H2

Windows 11, WDK for Windows 11, version 22H2 (10.0.22621.382, released May 24, 2022)
version 22H2

Windows 11, WDK for Windows 11, version 21H2

version 21H2

Windows Server WDK for Windows Server 2022

2022

Windows 10, WDK for Windows 10, version 2004

version 2004

Windows 10, WDK for Windows 10, version 1903

version 1903

Windows 10, WDK for Windows 10, version 1809

version 1809
Windows Server
2019

Windows 10, WDK for Windows 10, version 1803

version 1803

Windows 10, WDK for Windows 10, version 1709

version 1709

Windows 10, WDK for Windows 10, version 1703

version 1703

Windows 10, WDK for Windows 10, version 1607

version 1607
 Released with WDK and related downloads

Windows Server
2016

Windows 8.1 WDK 8.1 Update (English only) - permanently unavailable

Update WDK 8.1 Update Test Pack (English only) - permanently unavailable
WDK 8.1 Samples

Note: You can use any WDK from Windows 10, version 1607 through
Windows 11, version 21H2 to build drivers for Windows 8.1.

Windows 8 WDK 8 (English only)

WDK 8 redistributable components (English only)
WDK 8 Samples

Windows 7 WDK 7.1.0

７ Note

Please review Hardware development kits for Windows 10, Version 2004
(10.19041.1) , which addresses a bug with ExAllocatePoolZero.

） Important

If you have installed the WDK for Windows 10, version 1703 on a system that had
the WDK for Windows 10, version 1607 installed, some files from the earlier version
of the WDK might have been removed. To restore these files:

1. On the Start menu, enter Apps & features in the search box, and select Apps
& features from the results.
2. Find Windows Driver Kit - Windows 10.0.15063.0 in the list of Apps &
Features, and then select the program.
3. Select Modify, select Repair, and then follow the directions on the screen.
4. The files will be restored.

Download previous versions of the EWDK

The Enterprise WDK (EWDK) is a standalone, self-contained, command-line environment
for building drivers and basic Win32 test applications. It includes the Visual Studio Build
Tools, the SDK, and the WDK. This environment doesn't include all the features available
in Visual Studio, such as the integrated development environment (IDE).
Using the EWDK requires .NET Framework 4.7.2. For more information about which
systems run this version of the framework, see .NET Framework system requirements.
For links to download the .NET Framework, see .NET Framework system requirements.

For more information about the EWDK, see Using the Enterprise WDK.

ﾉ Expand table

Versions of Windows EWDK

Windows 11, version 24H2 Windows 11, version 24H2 (updated May 2024) EWDK

Windows 11, version 22H2 Windows 11, version 22H2 (updated May 2023) EWDK

Windows 11, version 21H2 Windows 11, version 21H2 EWDK

Windows Server 2022 EWDK for Windows Windows Server 2022

Windows 10, version 2004 EWDK for Windows 10, version 2004

Windows 10, version 1903 EWDK for Windows 10, version 1903

Windows 10, version 1809 EWDK for Windows 10, version 1809

Windows 10, version 1803 EWDK for Windows 10, version 1803

Windows 10, version 1709 EWDK for Visual Studio with Build Tools 15.6 (Recommended)
EWDK for Visual Studio with Build Tools 15.4
EWDK for Visual Studio with Build Tools 15.2

Windows 10, version 1703 EWDK for Windows 10, version 1703

７ Note

Starting in Windows 10 version 1709, the EWDK is ISO-based. To get started,

download and mount the ISO, and then run LaunchBuildEnv.

Optional: Install updated test certificates for

HAL extensions
To work with HAL Extensions, prepare your development system, running Windows 10,
version 1709 or a later version of Windows 10. Also install the WDK or the EWDK, and
then install the updated version of the Windows OEM HAL Extension Test Cert 2017
(TEST ONLY), available for download as a ZIP file: HAL_Extension_Test_Cert_2017.zip .
For more information about using this updated certificate, see Update for "Windows
OEM HAL Extension Test Cert 2017 (TEST ONLY)" test certificate on Windows Support.

Optional: Install WinDbg

WinDbg is the latest version of WinDbg with more modern visuals, faster windows, a
full-fledged scripting experience, built with the extensible debugger data model front
and center. Formerly known as WinDbg Preview, it supports Windows 10 and Windows
11.

For download links and more information about WinDbg, see Download and install the
WinDbg Windows debugger and Debugging Tools for Windows.

Standalone tools for debugging Windows XP

and Windows Vista
If you're debugging Windows XP, Windows Server 2003, Windows Vista, or Windows
Server 2008 (or using one of these operating systems to run Debugging Tools for
Windows), you need to use the Windows 7 release of the debugging tools. It's included
in the SDK for Windows 7 and .NET Framework 4.0.

） Important

Newer versions of the Visual C++ 2010 Redistributable can cause issues when you
install the SDK for Windows 7.

Get the standalone debugging tools for Windows XP by first downloading the Windows
7 SDK: Microsoft Windows SDK for Windows 7 and .NET Framework 4 .

To install the Debugging Tools for Windows as a standalone component, start the SDK
installer, and in the installation wizard, select Debugging Tools for Windows, and clear
all other components.

Related downloads
Download the Windows Assessment and Deployment Kit (Windows ADK)
Download the Windows HLK, HCK, or Logo Kit
Download the debugging Tools for Windows (WinDbg)
Download Windows Symbol Packages
Download the WDK Insider Preview
Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Windows Driver Kit (WDK) known issues
Article • 09/17/2024

This topic details known issues concerning the WDK.

WDK for Windows 11, version 24H2

Restart after provisioning

After provisioning and deployment, the target machine fails to restart after the
deployment steps.

ARM64 WDK Driver SxS Support

When both the Windows 11, version 24H2 kit and the Windows 11, version 22H2 kit are
installed on an ARM64 machine, building a KMDF driver for ARM64 with
TargetPlatformVersion set to Windows 11, version 22H2 fails with
WdfDriverEntry.lib(stub.obj) : error LNK2001: unresolved external symbol .

WDK extension fails to install

If you are using Visual Studio version 17.11.0 or later, uncheck the install extension
checkbox in the WDK installation.

WDK for Windows 11, version 22H2

Service error at startup

If you installed the original Windows 11, version 22H2 WDK between May and August
2022 (version 10.0.22621.1), you may see the following error message when you start
Visual Studio with the WDK.

The Microsoft.Windows.Tools.WinIDE.Debugger.DebuggerPackage, DebuggerPackage,

Version=10.0.0.0, Culture=neutral, PublicKeyToken=null package did not load

correctly.

This issue is fixed in WDK version 10.0.22621.382. You can uninstall the WDK and then
reinstall the latest WDK using the instructions in Download the Windows Driver Kit.
Debugger within Visual Studio doesn't work
It is not possible to debug drivers within the Visual Studio interface when using Visual
Studio 2022 version 17.2.0 and 17.3 with the Windows 11, version 22H2 WDK
(10.0.22621.382). To work around the problem, do one of the following: update Visual
Studio to 17.4.1 or later, debug with WinDbg, or use a version of Visual Studio earlier
than 17.2.0. The following error message is related to this issue:

QueryBuildManagerBusyEx must be called on the UI.

WDF redistributable co-installers don't work

Starting with this release, WDF redistributable co-installers are no longer supported.
Specifically, on a computer that has both the Windows 11, version 22H2 WDK and an
older WDK, when building a WDF 1.11 driver, msbuild fails because it cannot find the
WDF coinstaller.

To fix this problem, before installing Windows 11, version 22H2 WDK, back up the folder
\Program files (x86)\windows kit\10\redist\wdf and restore it afterwards.

Alternatively, if you have already installed the Windows 11, version 22H2 WDK, install
the MSI file at WDK 8 redistributable components on a separate computer and copy
the redist folder to the above folder. For more information, see Redistributable
Framework Components.

WDK for Windows 10, version 2004

Issue in ExAllocatePoolZero, ExAllocatePoolQuotaZero,

and ExAllocatePoolPriorityZero functions FIXED
In May 2020, OSR discovered that the new down-level support for automatic zeroing
of pool allocations had an issue that could lead to an allocation not getting zero-
initialized on systems running Windows 10, version 1909. This has now been fixed with a
security refresh of the WDK for Windows 10, version 2004 and the Enterprise WDK
(EWDK) for Windows 10, version 2004 on Dec 16th. Microsoft took advantage of the
security refresh and updated the EWDK to include the Visual Studio build tools 16.7.
Microsoft recommends all driver developers uninstall the original SDK and WDK (version
2004) and install the refresh SDK and WDK or EWDK.

To ensure there was a complete security solution in place, an OS fix was released for
Windows 10, version 1909 in November, so if there was a driver created with the
security issue the OS would be protected from it.

In addition to downloading the updated WDK/EWDK, Microsoft recommends that all

drivers switch all kernel allocations to use the new pool zeroing DDIs which return
zeroed memory by default. This will increase driver security and reliability. In order to
help with this transition, Microsoft has created a Static Driver Verifier rule which is
available in preview Windows 10 WDK versions 20236 and above. The rule will identify
all instances in a driver’s source code where the old pool allocation DDIs are being used
and will recommend replacing them with the new, safer equivalent DDI. The rule is
applicable to WDM, WDF and NDIS based drivers.

Installing WDK no longer enables Spectre mitigations for

all C++ projects as seen in WDK 1903
While the WDK install will enable Spectre mitigation by default for all drivers, it no
longer enables them for all C++ projects.

Error ‘A WDK corresponding to target ’10.0.19041.0’ was

not found.’
When selecting [Windows SDK Version] to '10.0 (latest installed version)' with WDK
10.0.19041.0 causes the "A WDK corresponding to target version '10.0.19041.0' was not
found" error even if the SDK version is installed.

Workaround: In the properties page for the driver project (Configuration Properties
>General) set Windows SDK Version to $(LatestTargetPlatformVersion). If this option is
not available to select then select the option inherit from parent or project default.

EWDK and SDV running on Server have .NET

requirements
Running Static Driver Verifier from the EWDK requires .Net Framework 4.7.2. Depending
on the version of Windows on your system, .NET may be installed, may be installed but
need to be enabled, or may not be installed. For more information about what version
of .NET is installed or the state of .NET installation please review .NET Framework
versions and dependencies.

DVL generation fails with

System.IO.FileNotFoundException
When attempting to create a Driver Verification Log (DVL), the following error will be
presented:

Console

Unhandled Exception: System.IO.FileNotFoundException:

Could not load file or assembly
'System.Runtime, Version=4.2.1.0, Culture=neutral,
PublicKeyToken=b03f5f7f11d50a3a'
or one of its dependencies.
The system cannot find the file specified.

This can occur in both the command-line and GUI environments. This issue is resolved in
a future version of the WDK and can be seen in the Windows Insider Preview WDK .
Unfortunately, no workaround exists for the current version.

SDV fails in the EWDK if VS is not installed

SDV has a dependency on VCRUNTIME140D.dll as part of Visual Studio. As such,
running the EWDK on a machine without VS installed will fail. Install Visual Studio on the
machine to work around this issue.

Driver Verifier does not get enabled/disabled when using

WDK test explorer
Driver Verifier does not get enabled/disabled when Device Fundamental tests are run
using the WDK Test Explorer.

Workaround: On the client machine manually enable/disable driver verifier per these
instructions.

WDK Side by Side installations of Windows 10, version

2004 and WDK Windows 10, version 1903 or version 1803
With both versions of kits installed on the same PC the ‘Deploy driver’ feature won’t
work for older version.

Workaround: Use 1803 on a separate machine if Deploy driver feature is needed.

Windows Device Testing Framework (WDTF) tests now

only run on systems with matching Windows 10 versions
as the WDK
In WDK for Windows 10, version 1809, changes were made to WDTF in order to support
this version of Windows 10, version 1809. The effect of this is that WDTF will no longer
run on down-level OS. The change continues with WDK for Windows 10, version 2004.

Alternative for down-level testing

The WDTF tests in WDK for Windows 10, version 1803 can be run on previous Windows
versions.

APIValidator
On an x86 arch machine APIValidator is unable to run against x64 binaries. If building
x64 drivers on an x86 machine APIValidator should be turned off.

Workaround:

1. Go to the properties page of the driver solution.

2. Select APIValidator, then General, and then change Run ApiValidator from Yes to
No.

WDK running on Windows 7 systems requires KB

3033929
You must install Microsoft Security Advisory 3033929 (KB3033929) prior to installing the
WDK on systems running Windows 7. KB3033929 can be downloaded from the
Microsoft Download Center .

Installing the WDK generates an error from Visual Studio

that the add-in component is already installed
This error message can be seen if the WDK was uninstalled but the WDK drivers
extension for Visual Studio was not uninstalled.

Resolution: In Visual Studio, go to the Extension dropdown menu, choose Manage

Extensions, select the Windows Driver Kit, and then click Uninstall.

FAQ
How do I tell if the WDK or EWDK versions I have
contains the fix for the zeroing of pool allocations?
In System Settings go to Add or Remove programs, search for Windows Driver Kit and
note the version. The original WDK for Windows 10, version 2004 has a version of
10.0.19041.1, the refreshed WDK version is 10.0.19041.685 For the EWDK, once the
EWDK environment is launched, look at the title of the command window. The refreshed
version will contain vb_release_svc_prod1.19041.685. Additionally, when looking at the
environment variables, the BuildLab variable should show
vb_release_svc_prod1.19041.685.

The Windows Software Development Kit (SDK) was also

refreshed, is this needed as well?
No, however the refreshed Windows Software Development Kit (SDK) contains a fix for
onecore.lib that may be nice to have. Also, it’s generally a good idea to keep the SDK
and WDK aligned.

If I already have the WDK for Windows 10, version 2004

installed, do I need to uninstall it before installing the
refreshed version?
It is highly recommended that if you have the original 2004 SDK and WDK that these be
uninstalled and the security refresh SDK and WDK be installed. That said if the refreshed
WDK is installed on top of the original WDK the refreshed version will overwrite the
original. Note: In this scenario “Add or remove programs”, both versions will be listed.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Bring up guide
Article • 06/01/2022

This section of the partner documentation is designed for hardware engineers and
developers who need to understand how to get started with bringing up hardware on
Windows.

In this section
Topic Description

Firmware Provides information about how to achieve Secured-core PC compliance with

Attack Firmware Attack Surface Reduction (FASR).
Surface
Reduction
(FASR)

Boot and Provides guidance about the boot process and UEFI implementation requirements
UEFI for devices that run Windows 10 and Windows Server 2016.

Windows The Advanced Configuration and Power Interface Specification, Revision 5.0 (ACPI 5.0
ACPI specification , defines a new set of features to support low-power, mobile devices
design that are based on System on a Chip (SoC) integrated circuits and that implement the
guide for connected standby power model. Starting with Windows 8 and Windows 8.1, and
SoC Windows Server 2012 and 2012 R2, Windows supports the new ACPI 5.0 features for
platforms SoC-based platforms.

Security Use the topics in this section to learn more about security in Windows 10 Mobile and
Windows Server 2016.

Windows Learn how to configure storage partitions and partitions sizes on Windows 10 Mobile
10 Mobile devices.
partition
layout
Developing, Testing, and Deploying
Drivers
Article • 01/20/2022

The Windows driver development environment and the Windows debuggers are
integrated into Microsoft Visual Studio. In this integrated driver development
environment, most of the tools you need for coding, building, packaging, deploying,
and testing a driver are available in the Visual Studio user interface.

To set up the integrated development environment, first install Visual Studio and then
install the WDK. You can find information about how to get Visual Studio and the WDK
on the WDK setup and download page. The Debugging Tools for Windows are included
with the WDK installation.

The WDK uses MSBuild.exe, which is available both in the Visual Studio user interface
and as a command-line tool. Drivers created in the Visual Studio environment use
Project and Solution files to describe a project or group of projects. The Visual Studio
environment provides a tool for converting legacy Sources and Dirs files to Project and
Solution files.

The Visual Studio environment provides templates for:

New drivers
Driver packages
New tests
Enhancement of existing tests
Custom driver deployment scripts

In the Visual Studio environment, you can configure the build process so that it
automatically creates and signs a driver package. Static and run-time analysis tools are
available in Visual Studio. You can configure a target computer for testing your driver
and automatically deploy your driver to the target computer each time you rebuild. You
can choose from an extensive set of run-time tests, and you can write your own tests.

The topics in this section show you how to use Visual Studio to perform several of the
tasks involved in driver development, deployment, and testing.

Additional Videos
You'll find videos on the following pages in the Windows driver docs:
Using the Windows Performance Toolkit (WPT) with WDF
Video: Accessing driver IFR logs without a debugger
Video: Debugging your driver with WDF source code
Videos: Debugging UMDF Drivers
Partner Center for Windows Hardware
Article • 09/06/2024

This article describes how to get started with the hardware submission process by using
the Partner Center for Windows Hardware. We take you through each step of the
process, from getting an extended validation (EV), to registration, and finally, to driver
publication and certification.

With the Windows Hardware Compatibility Program you can design, create, and test
your hardware and drivers before you submit the final version through the Partner
Center hardware dashboard for certification. By certifying your hardware device, system,
and drivers for Windows, you gain the support of Microsoft marketing resources in the
form of compatibility and reliability listings, logo artwork, and promotional partnerships.

Step 1: Get an EV code signing certificate

Your Hardware Dev Center dashboard account must have at least one extended
validation (EV) certificate associated with it to submit binaries for attestation signing or
to submit binaries for Windows Hardware Lab Kit (HLK) certification. To learn how to get
an EV certificate, see EV certificate signed drivers.

Step 2: Register for the Hardware Developer

Program
Now that you have your EV certificate ready, you can now register for the Hardware
Developer Program. To register, follow the steps in How to register for the Microsoft
Windows Hardware Developer Program.

Step 3: Test your hardware and drivers

Now that your company is registered in the Hardware Developer program, you need to
design, create, and test your hardware and drivers. To ensure that your drivers and
hardware run on Windows systems as your customers expect, you need to participate in
the Windows Hardware Compatibility Program.

Step 4: Submit for certification and

compatibility
Once your drivers are properly tested, create a new hardware submission.

Step 5: Manage driver distribution

If you have drivers that you want to distribute with Windows Update or share with
another company, see Manage driver distribution with shipping labels to learn about
common driver distribution tasks such as:

Publish a driver to Windows Update

Share a driver with a partner (Resell)
Expire a driver from Windows Update
View partner shipping labels for a shared driver

Step 6: Publish your driver

When your driver has passes the review process in the Partner hardware dashboard, it
becomes eligible for the hardware compatibility or certification program. In addition,
you can publish it to the Windows Server Catalog and the Windows Certified Products
List by providing an announcement date in your submission.

You can continue to use the Partner Center hardware dashboard to:

Customize your driver after initial certification using the Driver Update Acceptable
(DUA) process.
Manage your users and legal agreements.
Use the dashboard API to programmatically work with submissions.

Step 7: Share a link to a Windows Certification

Verification Report
Once your driver is certified, you can share the verification report with a sharable URL.
This URL allows the report to be accessed and downloaded without prior authorization
or access to the Partner Center. The sharable URL contains three identification numbers
separated by slashes:

https://developer.microsoft.com/dashboard/hardware/driver/DownloadCertificationRepo

rt/<SellerID>/<PrivateProductID>/<SubmissionID>

To create a sharable link, replace SellerID, PrivateProductID, and SubmissionID in the

example URL with the appropriate identification numbers.
The identification numbers used in the URL and their locations are:

ﾉ Expand table

Component Description

SellerID The identification number of your partner account found on the account
management page, under Account settings.

PrivateProductID The identification number generated with each product creation. Located on
the driver details page for your product. For more information, see Dashboard
ID definitions.

SubmissionID The identification number given to each submission and submission update.
Located on the driver details page for your product. For more information, see
Dashboard ID definitions.

Next Steps
Create a hardware submission

View hardware submissions

Update a hardware submission

Validate a hardware submission signature

Windows HLK Getting Started Guide

Attestation sign Windows 10+ drivers .

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get product support

Device and Driver Installation
Article • 12/20/2023

This section explains how devices and drivers are installed in Windows.

If you are unfamiliar with the device and driver installation process, we recommend that
you start by reviewing Roadmap for Device and Driver Installation. You may also want to
read Overview of Device and Driver Installation for a high-level overview of this process
and its components.

６ Collaborate with us on Windows driver

GitHub documentation feedback
The source for this content can Windows driver documentation is an
be found on GitHub, where you open source project. Select a link to
can also create and review provide feedback:
issues and pull requests. For
more information, see our  Open a documentation issue
contributor guide.
 Provide product feedback
Kernel-Mode Driver Architecture Design
Guide
Article • 05/31/2024

７ Note

For information about programming interfaces that your driver can implement or
call, see the Kernel-Mode Driver Reference.

This section includes general concepts to help you understand kernel-mode

programming and describes specific techniques of kernel programming. For a general
overview of Windows Drivers, see Getting Started with Windows Drivers, which provides
a general overview of Windows components, lists the types of device drivers used in
Windows, discusses the goals of Windows device drivers, and discusses generic sample
device drivers included in the kit.

This section contains conceptual information that describes and helps you build kernel-
mode drivers.

An Overview containing:
An overview of Windows Components
Design Goals for Kernel-Mode Drivers
A catalogue of Sample Kernel-Mode Drivers
Kernel Driver Development Best Practices, as compiled by the Microsoft Surface
team

Kernel-Mode Components describes the primary kernel-mode managers and

components of the Windows operating system.

ﾉ Expand table

Component Description

Managers

Windows Kernel- Manages objects: files, devices, synchronization mechanisms,

Mode Object Manager registry keys, and so on.

Windows Kernel- Manages physical memory for the operating system.

Mode Memory
Manager
Component Description

Windows Kernel- Handles the execution of all threads in a process.

Mode Process and
Thread Manager

Windows Kernel- Manages the communication between applications and the

Mode I/O Manager interfaces provided by device drivers.

Windows Kernel- A subsystem of the I/O manager, the Plug and Play (PnP) Manager
Mode Plug and Play enables a PC to recognize when a device is added to the system.
Manager

Windows Kernel- Manages the orderly change in power status for all devices that
Mode Power Manager support power state changes.

Windows Kernel- Manages the registry, such as monitoring changes in the registry
Mode Configuration or registering callbacks on specific registry data.
Manager

Windows Kernel- Implements transaction processing in kernel mode.

Mode Kernel
Transaction Manager

Windows Kernel- Provides routines for your driver to work with access control.
Mode Security
Reference Monitor

Libraries

Windows Kernel- Implements the core functionality that everything else in the
Mode Kernel Library operating system depends upon. The Microsoft Windows kernel
provides basic low-level operations such as scheduling threads or
routing hardware interrupts.

Windows Kernel- Refers to kernel-mode components that provide a variety of

Mode Executive services to device drivers, including: object management, memory
Support Library management, process and thread management, input/output
management, and configuration management.

Windows Kernel- A set of common utility routines needed by various kernel-mode

Mode Run-Time components.
Library

Windows Kernel- A safe string library to provide greater security in kernel-mode

Mode Safe String development.
Library

Windows Kernel- A direct memory access (DMA) library for device driver developers.
Mode DMA Library
 Component Description

Windows Kernel- A hardware abstraction layer (HAL) for kernel-mode driver

Mode HAL Library development.

Windows Kernel- A transactional logging system, the Common Log File System
Mode CLFS Library (CLFS).

Windows Kernel- A general mechanism for managing components, called Windows

Mode WMI Library Management Instrumentation (WMI).

Writing WDM Drivers and Introduction to WDM provide information needed to

write drivers using the Windows Driver Model (WDM).

Device Objects and the other topics in Device Objects and Device Stacks describe
how the operating system represents devices by device objects.

Memory Management for Windows Drivers illustrates how kernel-mode drivers

allocate memory for purposes such as storing internal data, buffering data during
I/O operations, and sharing memory with other kernel-mode and user-mode
components.

Security From Controlling Device Access and Privileges to SDDL for Device objects,
ensure that your drivers are as secure as possible.

Handling IRPs describes how kernel-mode drivers handle I/O request packets
(IRPs).

DMA Direct Memory Access (DMA) is a critical aspect of driver development, and
the topics in this node cover DMA from A to Z.

Controller Objects represent a physical device controller with attached devices.

Interrupt Service Routines (ISRs) handle interrupts for drivers of a physical device
that receives interrupts.

Message-Signaled Interrupts trigger an interrupt by writing a value to a particular

memory address.

Deferred Procedure Calls (DPC Objects) can be queued from ISRs and are
executed at a later time and at a lower IRQL than the ISR.

Plug and Play (PnP) focuses on the system software support for PnP and how
drivers use that support to implement PnP.

Power Management describes the architecture that provides a comprehensive

approach to system and device power management.
 Windows Management Instrumentation (WMI) are extensions to your kernel-
mode driver, which enable your driver to become a WMI provider. A WMI provider
makes measurement and instrumentation data available to WMI consumers, such
as user-mode applications.

Driver Programming Techniques Programming drivers in the kernel mode of

Windows requires techniques that sometimes differ significantly from those of
ordinary user-mode programming.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Windows Driver Frameworks
Article • 06/20/2024

Windows Driver Frameworks (WDF) is an abstraction layer that takes care of much of the
common code required to write a Windows driver. A lot of the required boilerplate is
provided, so when you use WDF you can opt in to providing driver-specific functionality.

WDF drivers include both Kernel-Mode Driver Framework (KMDF) and User-Mode Driver
Framework (UMDF).

For detailed change logs showing new functionality added in each framework release,
see KMDF Version History and UMDF Version History.

Windows 11 and Windows Server 2022 include KMDF version 1.33 and UMDF version
2.33.

You can use these framework versions to build drivers for:

Windows 10 and 11 (all SKUs)

Windows Server 2022

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Driver Security Guidance
Article • 07/25/2022

This section contains information on enhancing driver security.

In this section
Topic Description

Driver security checklist This topic provides a driver security checklist

for driver developers.

Threat modeling for drivers Driver writers and architects should make
threat modeling an integral part of the design
process for any driver. This topic provides
guidelines for creating threat models for
drivers.

Windows security model for driver developers This topic describes how the Windows security
model applies to drivers and explains what
driver writers must do to improve the security
of their devices.

Evaluate HVCI driver compatibility This topic describes how to implement

Hypervisor-protected Code Integrity (HVCI)
compatible code.

Development security practices for Windows This topic describes how to write secure code
driver developers for Windows drivers to prevent abuse and
tampering by malicious actors.
Install the Windows debugger
Article • 03/06/2024

WinDbg is a debugger that can be used to analyze crash dumps, debug live user-mode
and kernel-mode code, and examine CPU registers and memory.

This latest version features a more modern user experience with an updated interface,
fully-fledged scripting capabilities, an extensible debugging data model, built-in Time
Travel Debugging (TTD) support, and many additional features.

For more information, see WinDbg Overview.

７ Note

Formerly released as WinDbg Preview in the Microsoft Store, this version leverages
the same underlying engine as WinDbg (classic) and supports all the same
commands, extensions, and workflows.

Install WinDbg directly

Download the WinDbg installer file below, then open the file and follow the prompts.

Download WinDbg

Install WinDbg with Microsoft Store

Install WinDbg with Windows Package

Manager
To install WinDbg using the Windows Package Manager, run the following from the
command line / PowerShell:

PowerShell
 winget install Microsoft.WinDbg

Notes

Requirements
Supported Operating Systems:
Windows 11 (all versions)
Windows 10 Anniversary Update (version 1607) or newer
Processor architectures:
x64 and ARM64

Updating WinDbg
When installed directly or with Microsoft Store, WinDbg will periodically check for new
versions in the background and auto-update if necessary.

When installed with Windows Package Manager, run this command to update WinDbg:

PowerShell

winget upgrade Microsoft.WinDbg

Troubleshooting
If you encounter difficulties installing or keeping WinDbg updated, see Troubleshoot
installation issues with the App Installer file.

If you find any bugs or have a feature request, you can follow the feedback button in the
ribbon to go to the GitHub page where you can file a new issue.

Getting started with WinDbg

To get started with WinDbg, see Getting Started with Windows Debugging.

To get started with debugging kernel-mode drivers, see Debug Universal Drivers - Step
by Step Lab (Echo Kernel-Mode). This is a step-by-step lab that shows how to use
WinDbg to debug Echo, a sample driver that uses the Kernel-Mode Driver Framework
(KMDF).
Previous versions and related downloads
To debug older versions of Windows, use WinDbg (classic) available with Debugging
Tools for Windows.

Download the Windows Driver Kit (WDK)

Windows Symbol Packages

Windows Hardware Lab Kit

Download and install the Windows Assessment and Deployment Kit (Windows
ADK)

Windows Insider - Windows Preview builds

Using WinDbg and the debugger
commands
Article • 11/14/2023

WinDbg is a debugger that can be used to analyze crash dumps, debug live user-mode
and kernel-mode code, and examine CPU registers and memory.

This latest version features a more modern user experience with an updated interface,
fully fledged scripting capabilities, an extensible debugging data model, built-in Time
Travel Debugging (TTD) support, and many additional features.

For more information, see WinDbg Overview.

To install the debugger, see Install the Windows debugger.

To get started with WinDbg, see Getting Started with Windows Debugging.

Debugger commands
To learn more about the debugger commands, see Using Debugger Commands.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

UWP device apps
Article • 03/03/2023

Device manufacturers can create a UWP device app that serves as a companion to their
device. UWP device apps have more capabilities than regular UWP apps and can
perform privileged operations, such as firmware updates. Also, UWP device apps can
start from AutoPlay (on more devices than other apps can), automatically install the first
time a device is connected, and extend the printer and camera experiences built into
Windows 8.1 and Windows 10.

This section describes what UWP device apps are and how device manufacturers can
create them. If you're new to UWP device apps, take a look at Getting started.

If you're looking for information about UWP mobile broadband apps, see Mobile
Broadband.

In this section
Topic Description

What's new This section provides a glimpse of what's new for UWP device apps.

Getting started Start here to begin building UWP device apps.

Build a UWP This step-by-step guide describes in detail how to build a UWP device app with
device app Microsoft Visual Studio and the Device Metadata Authoring Wizard.
step-by-step

AutoPlay for This topic describes how to use the Device Metadata Authoring Wizard to
UWP device enable AutoPlay. It also describes how to handle AutoPlay activations in your
apps app.

Device sync In Windows 8.1, your UWP app can use a device background task to synchronize
and update for data on your peripheral device. If your app is associated with device metadata,
UWP device that UWP device app can also use a device background agent to perform device
apps updates, such as firmware updates.

Print support Provides guidance and examples for printer OEMs and IHVs that are
app design implementing a print support app (PSA) for their device.
guide

Print support Provides guidance and examples for associating a print support app (PSA) with
app a printer.
association
Topic Description

UWP device This section introduces UWP device apps for printers.
apps for
printers

UWP device This section introduces UWP device apps for cameras.
apps for
cameras

UWP device This topic introduces the ways that UWP device apps can access internal
apps for devices.
internal
devices

Automatic This topic describes how automatic installation works and how the app,
installation for metadata, and drivers can be updated and uninstalled.
UWP device
apps

Hardware This topic provides steps for a driver developer to associate a driver with a
Support App Universal Windows Platform (UWP) app.
(HSA): Steps
for Driver
Developers

Hardware This topic provides steps for an app developer to associate a Universal Windows
Support App Platform (UWP) app with a Universal Windows driver.
(HSA): Steps
for App
Developers
Overview of Driver Technologies
Article • 02/23/2023

For general information about developing drivers see Getting started with Windows
drivers and Write your first driver.

The majority of the driver technology information is the same for all editions of
Windows 10. When you must make special considerations for a particular edition of
Windows, such as for Windows 10 Mobile, we explicitly called these out in each
technology area.

Windows drivers
You can create a Windows Driver—a driver that uses a subset of the available interfaces
—to run on all editions of Windows 10. Where possible, use a Windows Driver to enable
deployment of your drivers on multiple devices. For more information about how to
build, install, deploy, and debug a Windows Driver for Windows 10, see Getting Started
with Windows Drivers and Deploying a Driver to a Test Computer.

Device drivers and Windows 10 for desktop

computers
For information about the tools used to develop desktop drivers, see Driver
Development Tools and Tools for Verifying Drivers. For information about deploying
drivers to Windows 10 on a desktop, see Device and Driver Installation. For information
about troubleshooting driver installation, see Troubleshooting Configuration of Driver
Deployment, Testing and Debugging.

Driver technologies
3D print devices
ACPI
Audio
Battery Drivers
Biometric Drivers
Bluetooth Drivers
Component Firmware Update (CFU)
Display, graphics, and compute accelerator drivers
 File system drivers
Global Navigation Satellite System (GNSS) drivers
GPIO drivers
Hardware notifications
HID Drivers
IEEE Drivers
Imaging device drivers
Kernel-mode driver technology
Mobile broadband
Multifunction device drivers
NetAdapterCx
Network drivers
NFC device drivers
Parallel port drivers
Partner application development
PCI drivers
PCMCIA drivers
Point of Service device drivers
Power management technologies
Print device drivers
SD card bus drivers
Sensor drivers
Serial port drivers
Smartcard device drivers
Simple Peripheral Bus (SPB) drivers
Storage device drivers
Storage Firmware Update (SFU)
Streaming media device drivers
Test Authoring and Execution Framework (TAEF)
Universal Serial Bus (USB)
Windows Device Testing Framework (WDTF)
Windows Hardware Error Architecture (WHEA)
Windows portable device drivers

Related sections
Getting started with Windows drivers
Driver Development Tools
Partner Center for Windows Hardware
3D printer driver design guide
Article • 08/16/2024

This section provides information about 3D printer drivers in Windows 10.

3D printing in Windows 10 provides the following features:

Driver model for 3D manufacturing devices

Support for UWP apps and extensions for 3D devices

Job spooling and queuing support

Keywords for modeling device capabilities

API for apps to submit 3D manufacturing jobs to your 3D printer

For the latest information about 3D printing in Windows 10, see the following resources:

Channel 9 3D printing blog

Download the Windows 3D Printing SDK to start developing drivers for printing to a
3D printer.

In this section
3D print partner onboarding guide

Microsoft Standard Driver for 3D Printers

MS3DPrint Standard G-Code driver

3D printer custom USB interface support

3D printing sample WSD app

Enable WSPrint 2.0 on a device

Print schema keywords for 3D manufacturing

Related sections
Print DDI reference
Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

ACPI design guide
Article • 03/03/2023

This section describes how device drivers can interface with an Advanced Configuration
and Power Interface (ACPI) device.

ACPI devices are defined by the Advanced Configuration and Power Interface (ACPI)
Specification .

In this section
Section Description

Supporting ACPI Provides information about how to use a Windows Driver Model (WDM)
Devices function driver to enhance the functionality of an ACPI device.

Evaluating ACPI Provides information about how device drivers that comply with the
Control Methods requirements of Kernel-Mode Driver Framework (KMDF), User-Mode Driver
Framework (UMDF), or Windows Driver Model (WDM) can evaluate ACPI
control methods.

How to Identify Provides information about the ACPI Source Language (ASL) Operating
the Windows System Interface Level (_OSI) method used to identify the host operating
Version in ACPI system.
by Using _OSI

Related sections
ACPI DDI reference
Audio Devices Design Guide
Article • 04/12/2024

This section describes how to design Microsoft Windows Driver Model (WDM) audio
drivers. These drivers control audio adapters that render and capture streams containing
audio data in wave and MIDI formats.

The following topics are discussed:

Windows 10: What's New for Audio Drivers

Windows Audio Architecture

Roadmap for Developing WDM Audio Drivers

WDM Audio Drivers Overview

WDM Audio Architecture: Basic Concepts

WDM Audio Architecture: Advanced Topics

WDM Audio Support in Different Versions of Windows

Windows Audio Processing Objects

Audio Miniport Drivers

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Battery devices design guide
Article • 10/05/2023

A battery typically has a pair of drivers: the generic battery class driver provided by
Microsoft, and a miniclass driver written specifically for that individual type of battery.
The class driver defines the overall functionality of the batteries in the system and
interacts with the power manager.

This design guide focuses on:

Writing battery miniclass drivers

Learn how to write battery miniclass drivers by referring to the Writing Battery Miniclass
Drivers guide.

Writing UPS minidrivers

Find information on writing UPS minidrivers, which were used with older versions of
Windows, in the Writing UPS Minidrivers guide.
Biometric Devices Design Guide
Article • 09/30/2024

This section describes how to write user-mode drivers that work with the Windows
Biometric Driver Interface (WBDI). WBDI is the driver interface of the Windows Biometric
Framework (WBF). WBF ships with Windows 7 and later versions of the Windows
operating system.

Ｕ Caution

While WudfBioUsbSample is no longer ships as part of the WDK, the WBDI

interface that this sample demonstrates and that is documented in these pages is
still the recommended way to write biometric drivers. You can still find the sample
in previous releases of the Windows driver samples repo, for example Windows 11,
version 22H2 - May 2022 Driver Samples Update .

In this section
Getting Started with Biometric Drivers
Roadmap for Developing Biometric Drivers
Sample Biometric Driver
Supporting Biometric IOCTL Calling Sequence
Using WinUSB in a WBDI Driver
Installing a Biometric Driver
Managing Queues in a WBDI Driver
Creating a Device Interface for a WBDI Driver
Supporting Secure Channels in WBDI Drivers
Using WBDI with Non-PnP Devices or Proprietary Stacks
Hardware Considerations for Biometric Drivers
Ranking a Biometric Driver on Windows Update
Testing Biometric Drivers
Signing WBDI Drivers
Windows Hello: Steps to Submit a Fingerprint Driver
Custom Control Codes

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Bluetooth Profile Drivers
Article • 01/10/2024

This section describes Bluetooth profile drivers. The information in this section is divided
into the following topics:

Bluetooth Profile Drivers Overview

Bluetooth Low Energy Overview

Using the Bluetooth Driver Stack

Debugging Bluetooth Profile Drivers

Bluetooth FAQ

Transport Bus Driver for Bluetooth Power Control Handling Guidelines

Bluetooth LE Proximity Profile Devices and Apps

６ Collaborate with us on Windows driver

GitHub documentation feedback
The source for this content can Windows driver documentation is an
be found on GitHub, where you open source project. Select a link to
can also create and review provide feedback:
issues and pull requests. For
more information, see our  Open a documentation issue
contributor guide.
 Provide product feedback
Component Firmware Update (CFU)
Article • 03/03/2023

Component Firmware Update (CFU) provides Original Equipment Manufacturers (OEMs)

and Independent Hardware Vendors (IHVs) a reliable and authenticated method for
updating firmware on devices that have shipped to customers. This release contains
reference firmware for receiving the firmware payload.

７ Note

CFU is available in Windows 10, version 2004 (Windows 10 May 2020 Update) and
later versions.

See the Introducing Component Firmware Update blog post and WinHEC 2018 -
Component Firmware Update video for an introduction to CFU concepts.

In this section
Topic Description

CFU firmware Provides detailed guidance on implementing the CFU firmware protocol and
implementation creating new firmware images to install on the target device.
guide

CFU INF file Provides information on configuring your custom device INF file for your
configuration firmware update.

CFU protocol Provides detailed information on the CFU protocol offer, content, and firmware
specification update command sequence.

CFU standalone Provides information on the CFU standalone tool that sends firmware update
tool image files to a device. It can be used to test your firmware update on your
device during development and before uploading it to Windows Update.

CFU virtual HID Simulates updating firmware on a virtual HID device.

device firmware
update
simulation
Driver design guides for display,
graphics, and compute accelerator
devices
Article • 02/23/2023

The following design guides are for developers of display, graphics, and compute
accelerator drivers on Windows. For information about available "Video driver samples",
see Windows driver samples.

Windows Display Driver Model (WDDM)

WDDM is the driver architecture available starting with Windows Vista. Drivers
that adhere to WDDM run on Windows Vista and later.
For compute accelerator drivers, use the Microsoft Computer Driver Model
(MCDM), which is a subset of WDDM 2.0+.

Legacy: Windows 2000 Display Driver Model (XDDM)

XDDM was the display and graphics driver architecture available for Windows 2000
through Windows Vista and Windows 7 only.
Driver Development Tools
Article • 07/01/2024

Purpose
The Windows Driver Kit (WDK) provides a set of tools that you can use to develop,
analyze, build, install, and test your driver. The WDK includes powerful verification tools
that are designed to help you detect, analyze, and correct errors in driver code during
the development process. Many of these tools can be used very early in the
development process where they are most critical and can save you the most time and
effort.

Driver Development Tools Documentation

This section describes the tools and techniques that can help you during development:

Tools for Verifying Drivers

Additional Driver Verification Tools

Tools for Testing Drivers

Tools for Software Tracing

Additional Driver Tools

ApiValidator You can use the ApiValidator.exe tool to verify that the APIs that your driver
calls are valid for a Universal Windows driver.

Developing, Testing, and Deploying Drivers

） Important

Windows Hardware Compatibility Program requires CodeQL for Static Tool Logo
(STL) Tests on our Client and Server Operating Systems. We will continue to
maintain support for SDV and CA on older products. Partners are highly
encouraged to review the CodeQL requirements for the Static Tool Logo Test. For
more information about using CodeQL, see CodeQL and the Static Tools Logo Test.
Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

File Systems and Filter Driver Design
Guide
Article • 09/25/2024

The File Systems and Filter Driver Design Guide describes how to design and implement
a file system filter driver for Windows. It also provides driver-relevant information about
Windows file systems. See the programming reference for reference pages.

File systems
Windows file systems are implemented as file system drivers working above the storage
system.

Every system-supplied file system in Windows is designed to provide reliable data

storage with varying features to meet the user's requirements.

Standard file systems available in Windows include NTFS, ExFAT, UDF, and FAT32. A
comparison of features for each of these file systems is shown in File System
Functionality Comparison.
The Resilient File System (ReFS) is available on Windows Server 2012 and later
versions. ReFS offers scalable large volume support and the ability to detect and
correct data corruption on disk.

Developing a new file system driver is almost always unnecessary, and

requirements/specifications for new file system drivers aren't predictable. To that end,
this design guide doesn't cover file system development. If you do need to develop a
new file system driver beyond those available in Windows, sample code is available as a
model.

File system filter drivers

A file system filter driver, or minifilter, intercepts requests targeted at a file system or
another file system filter driver. By intercepting the request before it reaches its
intended target, a minifilter can extend or replace functionality provided by the original
target of the request. Examples of filter drivers include:

Anti-virus filters
Backup agents
Encryption products
Filter driver developers use the Filter Manager (FltMgr.sys). This system-supplied module
provides developers a framework to implement filter drivers without having to manage
all the complexities of file I/O. FltMgr simplifies filter driver development and solves
many of the problems with the legacy filter driver model, such as FltMgr having the
ability to control load order through an assigned altitude.

File system and filter sample code

Microsoft provides several file system filter driver samples. Anyone who decides to
develop their own file system can file system driver sample code as well.

File system filter driver certification

Certification information for File Systems and File System Filter Drivers is found in the
Windows Hardware Lab Kit (HLK). Tests for file systems and filter drivers are found under
Filter.Driver.

Other resources
OSR offers various training resources for file system filter developers. They also host
community discussion forums such as the Windows File Systems and Minifilters Devs
Interest List , where you can ask questions and communicate with filter driver
developers from around the world.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Get started with drivers on Windows
Article • 09/27/2024

Start here to learn fundamental concepts about drivers.

You should already be familiar with the C programming language, and you should
understand the ideas of function pointers, callback functions, and event handlers.

In this section
What is a driver?
Do you need to write a driver?
Choosing a driver model
Write your first driver
From Sample Code to Production Driver
Provision a computer for driver deployment and testing (WDK 10)
Concepts for all driver developers

Related topics
Windows Driver Kit (WDK)

Driver Security Guidance

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Global Navigation Satellite System
(GNSS) driver design guide
Article • 03/03/2023

This section contains design guidance for building Global Navigation Satellite System
(GNSS) device drivers.

In this section
Global Navigation Satellite System (GNSS) driver design guide for Windows 8.1

Global Navigation Satellite System (GNSS) driver design guide for Windows 10

Related sections
Global Navigation Satellite System (GNSS) DDI reference
General-Purpose I/O (GPIO) Driver
Design Guide
Article • 03/14/2023

This section describes how to write a driver for a general-purpose I/O (GPIO) controller
device. A GPIO controller configures GPIO pins to perform low-speed data I/O
operations, to act as device-selects, and to receive interrupt requests. Starting with
Windows 8, the GPIO framework extension (GpioClx) simplifies the task of writing a
driver for a GPIO controller. Additionally, GpioClx provides a uniform I/O request
interface to peripheral device drivers that communicate with devices that connect to
GPIO pins on a controller.

In this section
Topic Description

GPIO Driver Support Overview Starting with Windows 8, the GPIO framework
extension (GpioClx) simplifies the task of
writing a driver for a GPIO controller device.
Additionally, GpioClx provides driver support
for peripheral devices that connect to GPIO
pins. GpioClx, which is a system-supplied
extension to the kernel-mode driver framework
(KMDF), performs processing tasks that are
common to members of the GPIO device class.

GpioClx I/O and Interrupt Interfaces Typically, the clients of a GPIO controller are
drivers for peripheral devices that connect to
GPIO pins. These drivers use GPIO pins as low-
bandwidth data channels, device-select
outputs, and interrupt-request inputs.
Peripheral device drivers open logical
connections to GPIO pins that are configured
as data inputs or outputs. They use these
connections to send I/O requests to these pins.
In addition, peripheral device drivers can
logically connect their interrupt service routines
to GPIO pins that are configured as interrupt
request inputs.
Topic Description

GPIO-Based Hardware Resources Starting with Windows 8, the general-purpose

I/O (GPIO) pins that are controlled by a GPIO
controller driver are available to other drivers
as system-managed hardware resources. GPIO
I/O pins, which are pins that are configured as
data inputs or data outputs, are available as a
new Windows resource type, GPIO I/O
resources. In addition, GPIO interrupt pins,
which are pins that are configured as interrupt
request inputs, are available as ordinary
Windows interrupt resources.

GPIO Interrupts Some general-purpose I/O (GPIO) controller

devices can configure their GPIO pins to
function as interrupt request inputs. These
interrupt request inputs are driven by
peripheral devices that are physically
connected to the GPIO pins. The drivers for
these GPIO controllers can enable, disable,
mask, unmask, and clear interrupt requests on
individual GPIO pins.

GpioClx DDI The general-purpose I/O (GPIO) controller

driver communicates with the GPIO framework
extension (GpioClx) through the GpioClx
device-driver interface (DDI). This DDI is
defined in the Gpioclx.h header file and is
described in General-Purpose I/O (GPIO) Driver
Reference. As part of this DDI, GpioClx
implements several driver support methods,
which are called by the GPIO controller driver.
This driver implements a set of event callback
functions, which are called by GpioClx. GpioClx
uses these callbacks to manage interrupt
requests from GPIO pins that are configured as
interrupt inputs, and to transfer data to or from
GPIO pins that are configured as data inputs
and outputs.
Hardware notifications design guide
Article • 01/20/2022

Describes support for key buttons (Power, Windows, volume and rotation lock) and
other indicators in a standardized way, together with associated corresponding
Windows Engineering Guidance (WEG).

In this section
Topic Description

GPIO buttons Windows 8 introduced support for general-purpose I/O (GPIO) buttons and
and indicators indicators by using a HID miniport class driver. The goal was to provide support
implementation for key buttons (Power, Windows, volume and rotation lock) in a standardized
guide way, together with associated corresponding Windows Engineering Guidance
(WEG). Windows 8.1 is focused on enhancing the quality of the end-to-end user
experience and unifying the behavior across various innovative form factors.

GPIO buttons This topic describes Windows 8.1 test scenarios for hardware buttons and
and indicators indicators, to ensure an optimal user experience for various form factors.
supplemental
testing

Hardware Windows 10, version 1709 provides an infrastructure for the hardware-agnostic
notifications support of notification components such as LEDs and vibration mechanisms.
support This support is delivered through the introduction of a Kernel-Mode Driver
Framework (KMDF) class extension specifically for hardware notification
components that allows for the rapid development of client drivers. A KMDF
class extension is essentially a KMDF driver that provides a defined set of
functionality for a given class of devices, similar to a port driver in the Windows
Driver Model (WDM). This section provides an overview of the architecture of
the hardware notification class extension. For additional information about the
KMDF, see Using WDF to Develop a Driver.
Introduction to Human Interface
Devices (HID)
Article • 12/08/2023

Human Interface Devices (HID) is a device class definition to replace PS/2-style

connectors with a generic USB driver to support HID devices such as keyboards, mice,
game controllers, and so on. Prior to HID, devices could only utilize strictly defined
protocols for mice and keyboards. Hardware innovation required either overloading
data in an existing protocol or creating nonstandard hardware with its own specialized
driver. HID provides support for boot mode devices while adding support for innovation
through extensible, standardized, and easily programmable interfaces.

HID devices include alphanumeric displays, bar code readers, speakers, headsets,
auxiliary displays, sensors, and many others. Hardware vendors also use HID for their
proprietary devices.

HID began with USB but was designed to be bus-agnostic. It was designed for low
latency, low bandwidth devices but with flexibility to specify the rate in the underlying
transport. The USB-IF ratified the specification for HID over USB in 1996. Support for
HID over other transports soon followed. Details on currently supported transports can
be found in HID Transports Supported in Windows. Third-party, vendor-specific
transports are also allowed via custom transport drivers.

HID concepts
HID consists of two fundamental concepts, a report descriptor, and reports. Reports are
the actual data that is exchanged between a device and a software client. The report
descriptor describes the format and meaning the data that the device supports.

Reports
Applications and HID devices exchange data through reports. There are three report
types:

ﾉ Expand table

Report type Description

Input report Data sent from the HID device to the application, typically when the state of a
control changes.
 Report type Description

Output Data sent from the application to the HID device, for example to the LEDs on a
report keyboard.

Feature Data that can be manually read and written, and are typically related to
report configuration information.

Each top level collection defined in a report descriptor can contain zero or more reports
of each type.

Usage tables
The USB-IF working group publishes HID usage tables that are part of the report
descriptors that describe what HID devices are allowed to do. These HID usage tables
contain a list with descriptions of Usages describing the intended meaning and use of a
particular item in the report descriptor. For example, a usage is defined for the left
button of a mouse. The report descriptor can define where in a report an application can
find the current state of the mouse's left button. The usage tables are broken up into
several name spaces, called usage pages. Each usage page describes a set of related
usages to help organize the document. The combination of a usage and a usage page
define the usage ID that uniquely identifies a specific usage in the usage tables.

See also
USB-IF HID Specifications

６ Collaborate with us on Windows driver

GitHub documentation feedback
The source for this content can Windows driver documentation is an
be found on GitHub, where you open source project. Select a link to
can also create and review provide feedback:
issues and pull requests. For
more information, see our  Open a documentation issue
contributor guide.
 Provide product feedback
IEEE 1394 bus driver design guide
Article • 03/14/2023

This section includes:

The IEEE 1394 Driver Stack

Installing IEEE 1394 Device Drivers

Asynchronous I/O for IEEE 1394 Devices

Isochronous I/O for IEEE 1394 Devices

Modifying the 1394 Configuration ROM

IEEE 1394 Hardware Emulation Drivers

1394 Samples and Diagnostic Tools

IEC-61883 Client Drivers

Imaging device driver design guide
Article • 03/03/2023

This section contains information about Windows Image Acquisition (WIA) drivers, Still
Image (STI) drivers, and Web Services on Devices (WSD).

７ Note

The WIA programming interface is used to develop imaging drivers for modern
Windows operating systems. The STI programming interface was used to develop
imaging drivers in legacy Windows operating systems. The STI programming
interface documentation will be archived in a future release.

In this section
Device Interface Classes for Imaging Devices

Windows Image Acquisition Drivers

WIA Properties

64-Bit and WIA

WIA Compatibility Layer

WIA Driver Filters

WIA Item Trees

WIA with Web Services for Devices

Developing a WIA Driver

Developing a WIA Camera Driver

WIA Minidriver Best Practices

WIA Microdriver Commands

Building, Troubleshooting and Debugging WIA Minidrivers

WIA Samples and Tools

Still Image Drivers

Web Services on Devices

Web Services on Devices Reference

WIA and STI Driver Reference

The following table contains reference information for Windows Image Acquisition
(WIA) drivers and for Still Imaging (STI) drivers. These drivers control devices, including
scanners and cameras, that capture still images. For more information about these
drivers, see Windows Image Acquisition Drivers and Still Image Drivers.

The following sections describe the interfaces, functions, structures, and properties used
by WIA and STI drivers.

Section Description

Device Interface Classes for Device class GUID for imaging devices.
Imaging Devices

IWiaMiniDrv Interface Interface for managing all communications between a WIA

minidriver and the WIA service.

WIA Driver Services Library Helper functions used by a WIA minidriver to manage device items
Functions and data transfers.

WIA Properties Properties of WIA devices, including status, capabilities, and device
identification information.

WIA Utility Library Functions Utility functions and classes used by a WIA minidriver to support
and Classes debugging and to perform common tasks.

IWiaMiniDrvCallBack Callback interface for transferring status and image data between
Interface the WIA service and a WIA minidriver.

IWiaDrvItem Interface Interface used by a WIA minidriver to manage a tree of WIA driver
items.

IWiaErrorHandler Interface Interface used by a WIA minidriver to provide error status and to
support error recovery.

IWiaImageFilter Interface Interface implemented by an image processing filter and called by

the WIA service to communicate with the filter.

IWiaLog Interface and Interface and macros used by a WIA minidriver to record trace,
Diagnostic Log Macros error, and warning messages to a diagnostic log file.

IWiaSegmentationFilter Interface used by a WIA minidriver to detect regions in a

Interface segmented image.
 Section Description

IWiaTransferCallback Interface implemented by an image processing filter and called by

Interface the WIA service to initiate the processing of image streams.

WIA Microdriver Functions, Functions, structures, and commands used by WIA microdrivers.
Structures, and Commands

WIA User Interface Interface used by device vendors to provide custom user interfaces
Extensions for their devices.

WIA Structures Structures used by driver-level WIA methods and functions.

Still Image Interfaces Interfaces, structures, data types, and control codes used by STI
drivers.

Web Services on Devices Web Services on Devices information, including Scan Service (WS-
Reference SCAN)

Related sections
Imaging DDI reference
Kernel-Mode Driver Architecture Design
Guide
Article • 05/31/2024

７ Note

For information about programming interfaces that your driver can implement or
call, see the Kernel-Mode Driver Reference.

This section includes general concepts to help you understand kernel-mode

programming and describes specific techniques of kernel programming. For a general
overview of Windows Drivers, see Getting Started with Windows Drivers, which provides
a general overview of Windows components, lists the types of device drivers used in
Windows, discusses the goals of Windows device drivers, and discusses generic sample
device drivers included in the kit.

This section contains conceptual information that describes and helps you build kernel-
mode drivers.

An Overview containing:
An overview of Windows Components
Design Goals for Kernel-Mode Drivers
A catalogue of Sample Kernel-Mode Drivers
Kernel Driver Development Best Practices, as compiled by the Microsoft Surface
team

Kernel-Mode Components describes the primary kernel-mode managers and

components of the Windows operating system.

ﾉ Expand table

Component Description

Managers

Windows Kernel- Manages objects: files, devices, synchronization mechanisms,

Mode Object Manager registry keys, and so on.

Windows Kernel- Manages physical memory for the operating system.

Mode Memory
Manager
Component Description

Windows Kernel- Handles the execution of all threads in a process.

Mode Process and
Thread Manager

Windows Kernel- Manages the communication between applications and the

Mode I/O Manager interfaces provided by device drivers.

Windows Kernel- A subsystem of the I/O manager, the Plug and Play (PnP) Manager
Mode Plug and Play enables a PC to recognize when a device is added to the system.
Manager

Windows Kernel- Manages the orderly change in power status for all devices that
Mode Power Manager support power state changes.

Windows Kernel- Manages the registry, such as monitoring changes in the registry
Mode Configuration or registering callbacks on specific registry data.
Manager

Windows Kernel- Implements transaction processing in kernel mode.

Mode Kernel
Transaction Manager

Windows Kernel- Provides routines for your driver to work with access control.
Mode Security
Reference Monitor

Libraries

Windows Kernel- Implements the core functionality that everything else in the
Mode Kernel Library operating system depends upon. The Microsoft Windows kernel
provides basic low-level operations such as scheduling threads or
routing hardware interrupts.

Windows Kernel- Refers to kernel-mode components that provide a variety of

Mode Executive services to device drivers, including: object management, memory
Support Library management, process and thread management, input/output
management, and configuration management.

Windows Kernel- A set of common utility routines needed by various kernel-mode

Mode Run-Time components.
Library

Windows Kernel- A safe string library to provide greater security in kernel-mode

Mode Safe String development.
Library

Windows Kernel- A direct memory access (DMA) library for device driver developers.
Mode DMA Library
 Component Description

Windows Kernel- A hardware abstraction layer (HAL) for kernel-mode driver

Mode HAL Library development.

Windows Kernel- A transactional logging system, the Common Log File System
Mode CLFS Library (CLFS).

Windows Kernel- A general mechanism for managing components, called Windows

Mode WMI Library Management Instrumentation (WMI).

Writing WDM Drivers and Introduction to WDM provide information needed to

write drivers using the Windows Driver Model (WDM).

Device Objects and the other topics in Device Objects and Device Stacks describe
how the operating system represents devices by device objects.

Memory Management for Windows Drivers illustrates how kernel-mode drivers

allocate memory for purposes such as storing internal data, buffering data during
I/O operations, and sharing memory with other kernel-mode and user-mode
components.

Security From Controlling Device Access and Privileges to SDDL for Device objects,
ensure that your drivers are as secure as possible.

Handling IRPs describes how kernel-mode drivers handle I/O request packets
(IRPs).

DMA Direct Memory Access (DMA) is a critical aspect of driver development, and
the topics in this node cover DMA from A to Z.

Controller Objects represent a physical device controller with attached devices.

Interrupt Service Routines (ISRs) handle interrupts for drivers of a physical device
that receives interrupts.

Message-Signaled Interrupts trigger an interrupt by writing a value to a particular

memory address.

Deferred Procedure Calls (DPC Objects) can be queued from ISRs and are
executed at a later time and at a lower IRQL than the ISR.

Plug and Play (PnP) focuses on the system software support for PnP and how
drivers use that support to implement PnP.

Power Management describes the architecture that provides a comprehensive

approach to system and device power management.
 Windows Management Instrumentation (WMI) are extensions to your kernel-
mode driver, which enable your driver to become a WMI provider. A WMI provider
makes measurement and instrumentation data available to WMI consumers, such
as user-mode applications.

Driver Programming Techniques Programming drivers in the kernel mode of

Windows requires techniques that sometimes differ significantly from those of
ordinary user-mode programming.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Mobile broadband
Article • 01/20/2022

Use the docs in this section to learn more about mobile broadband and how to
configure mobile broadband experiences for your customers.

Overview

Using metadata to configure mobile broadband experiences

Mobile operator scenarios

Multifunction device driver design
guide
Article • 03/03/2023

A multifunction device occupies one location on its parent bus but contains more than
one function. Combination printer/scanner/fax devices and modem/network cards are
common multifunction devices.

In a multifunction device, the individual functions are independent. This means the
functions must have the following characteristics:

The functions cannot have start-order dependencies.

The resource requirements for one function cannot be expressed in terms of the
resources of another function (for example, function1 uses I/O port x and function2
uses port x + 200).

Each function must be able to operate as a separate device, even if it is serviced by

the same drivers as another function.

Each function on the device must be enumerated.

Resource requirements for each function must be communicated to the PnP

manager.

There must be INF files and drivers for each function.

The component responsible for each of these tasks depends on the multifunction
standard for the device's parent bus, the extent to which the device conforms to the
standard, and the capabilities of the parent bus driver.

If the device complies with the multifunction standards for its bus, your driver
requirements are significantly reduced. Industry-wide multifunction standards have been
defined for the PC Card and PCI buses.

If you are working with a multifunction DVD/CD-ROM device used for data storage (not
for audio/video playback), you should use the system-supplied WDM DVD class driver,
which treats the device as a single logical unit.

For a multifunction device that combines other functionality, you can use a system-
supplied driver and INF file if the device complies with the multifunction standards for
its bus. The system supplied multifunction driver (mf.sys) can handle the bus-level
enumeration and resource allocation requirements for the device, and the system-
supplied INF (mf.sys) can install the multifunction device. You need to supply only a
function driver and INF file for each of the individual device functions.

If the device does not comply with the standard for its bus, you might need to supply a
driver equivalent to mf.sys in functionality, in addition to function drivers and INF files
for the device functions.

To install a multifunction device, you typically provide a base INF file for the device and
an additional INF file for each of the device's functions. The base INF file typically copies
the INF files for the device's individual functions. For information about how to
accomplish this, see Copying INFs.

The following sections describe driver and installation requirements for various types of
multifunction devices:

Supporting Multifunction PC Card Devices

Supporting Multifunction PCI Devices

Supporting Multifunction Devices On Other Buses

Using the System-Supplied Multifunction Bus Driver

Creating Resource Maps for a Multifunction Device

See INF File Sections and INF File Directives for information about INF file syntax.

The Windows Driver Kit (WDK) includes a separate section that describes how to support
multifunction audio devices.
Network Adapter WDF Class Extension
(NetAdapterCx)
Article • 05/22/2024

Overview
Starting in Windows 10, version 2004, the Windows Driver Kit (WDK) includes a Network
Adapter WDF Class Extension module (NetAdapterCx) that enables you to write a
KMDF-based client driver for a Network Interface Controller (NIC). Starting in Windows
11, version 24H2, the UMDF version of NetAdapterCx enables NIC drivers to operate in
user-mode. NetAdapterCx gives you the power and flexibility of WDF and the
networking performance of NDIS, and makes it easy to write a driver for your NIC.

In previous versions of Windows, WDF and NDIS had individual advantages, but did not
interoperate well. The only way to write a NIC driver was to write an NDIS miniport
driver. To use WDF in an NDIS miniport driver, you had to write extra code in your driver,
and even then, you only had access to a small subset of WDF functionality.

With the NetAdapterCx model, conversely, you write a real WDF driver for your NIC. This
means that your NetAdapterCx driver has access to full WDF functionality, as well as
networking-specific APIs and I/O support from the NetAdapter class extension. As
shown in the block diagram below, NetAdapterCx still works behind the scenes with
NDIS, but it handles all the interaction with NDIS on your behalf.
Additional info
The following video Network Adapter Class Extension: Overview discusses the benefits
of using NetAdapterCx.
https://www.microsoft.com/en-us/videoplayer/embed/RE5daTH?postJsllMsg=true

To learn how to port an NDIS 6.x miniport driver to the NetAdapterCx NIC driver model,
see Porting NDIS miniport drivers to NetAdapterCx.

To start working right away with driver samples on GitHub, clone our NetAdapter-Cx-
Driver-Samples repo.
To see the source code for NetAdapterCx itself, or perform step-through debugging, see
our Network-Adapter-Class-Extension repo on GitHub.

If you would like to work with Microsoft as you develop a NetAdapterCx client driver, or
have feedback on the class extension, please send us an email.

The following video Network Adapter Class Extension: Roadmap and Collaboration
discusses future roadmap and collaboration opportunities.
https://www.microsoft.com/en-us/videoplayer/embed/RE5ddHE?postJsllMsg=true

Topics
This section contains the following topics:

Porting NDIS miniport drivers to NetAdapterCx

Building a NetAdapterCx client driver
INF files for NetAdapterCx client drivers
User-mode NetAdapterCx
Managing the lifetime of objects in NetAdapterCx
Accessing configuration information
Debugging a NetAdapterCx client driver
Transferring network data
NetAdapterCx receive side scaling (RSS)
Configuring power management
NDIS-WDF function equivalents
NetAdapterCx limitations
Mobile Broadband (MBB) WDF class extension (MBBCx)
Wi-Fi WDF class extension (WiFiCx)

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Network Driver Design Guide
Article • 09/27/2024

This Network Driver Design Guide describes how to design and create network device
drivers for Windows operating systems beginning with Windows Vista.

This guide includes the following sections:

Introduction to Network Drivers

NDIS version guide

NDIS Core Functionality

Scalable Networking

Virtualized Networking

Wireless Networking

Network Module Registrar

Winsock Kernel

IP Helper

Windows Filtering Platform Callout Drivers

System Area Networks

Remote NDIS (RNDIS)

Kernel Mode SDK Topics for Network Drivers

Previous Versions of Network Drivers

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Near field communications (NFC) design
guide
Article • 01/11/2024

Windows exposes a rich set of experiences using NFC technology including:

Wi-Fi Direct pairing - Peripheral devices can participate in Tap and Setup and Tap
and Reconnect use cases.
Near field proximity – Provides a common surface for Windows to use NFP
capabilities.
Smart card support – Allows callers to the NFC device driver to perform low level
smart card operations on NFC contactless smart cards.
NFC power management - NFC drivers intelligently manage the power state of the
device.

To enable NFC support, Microsoft relies on IHVs to provide device drivers that
implement the device driver interface (DDI) defined in these topics. Use the User-Mode
Driver Framework (UMDF) 2.0 to write NFC drivers for Windows.

Related topics
Getting Started with UMDF
NFC device driver interface (DDI) reference

６ Collaborate with us on Windows driver

GitHub documentation feedback
The source for this content can Windows driver documentation is an
be found on GitHub, where you open source project. Select a link to
can also create and review provide feedback:
issues and pull requests. For
more information, see our  Open a documentation issue
contributor guide.
 Provide product feedback
Parallel Device Driver Design Guide
Article • 03/14/2023

This section includes:

Introduction to Parallel Ports and Devices

System-Supplied Parallel Drivers

Vendor-Supplied Parallel Drivers

Parallel Devices Reference

Partner app development
Article • 03/03/2023

Partners have the ability to create special use applications for things like the Windows
10 settings app. Some partner-specific app development scenarios require functionality,
such as access to system APIs, that isn't available to APIs with General capabilities.
Instead these apps require Restricted or special use capabilities, allowing for
functionality available for partner development in a controlled fashion.

In this section
Topic Description

Background tasks and custom Learn how to use tasks and triggers in conjunction with your
triggers for device drivers device drivers and apps.

Create a partner settings app Learn how to create an OEM settings apps for custom hardware
components to help differentiate your brand.

Mobile Broadband Learn more about mobile broadband and how to configure
mobile broadband experiences for your customers.

Wi-fi Direct Learn more about Wi-Fi Direct and the Wi-Fi Direct Services API
in Windows.
PCI driver programming guide
Article • 09/26/2024

The following table summarizes the PCIe features supported by different versions of
Windows. For details, see the specified sections in the official PCIe specification .

ﾉ Expand table

Feature Minimum
Windows version

Resizable BAR capability Windows 10

See section 7.22.

Atomic Operations Windows 10

See section 6.15.

ACPI additions for FW latency optimizations Windows 10

See ACPI Additions for FW Latency Optimizations

ATS/PRI Windows 10
- ATS specification
- Errata for the PCI Express® Base Specification Revision 3.1, Single Root
I/O Virtualization and Sharing Revision 1.1, Address Translation and Sharing
Revision 1.1, and M.2 Specification Revision 1.0

Optimized Buffer Flush/Fill (OBFF) - Windows 8

See section 6.19. - Windows
Server 2012

Latency Tolerance Reporting (LTR) Capability - Windows 8

See section 7.25. - Windows
Server 2012

Alternative Routing-ID Interpretation (ARI) - Windows 8

See section 6.13. - Windows
Server 2012

Message Signaled Interrupt (MSI/MSI-X) Support - Windows Vista

See section 6.1.4. - Windows
Server 2008 R2

TLP Processing Hints (TPH) - Windows 8

See section 6.17. - Windows
Server 2012

Single Root I/O Virtualization (SR-IOV) - Windows 8

See Single Root I/O Virtualization (SR-IOV). - Windows
 Feature Minimum
Windows version

Server 2012

In this section
PCI Power Management and Device Drivers

Accessing PCI Device Configuration Space

I/O Resource Usage Reduction

Order of Resources in Start-Device IRP

PCI Express FAQ for Graphics

PCI Sample

Obtaining PCI Segment Values

See Also
Official PCIe specification

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

PCMCIA Bus Driver Design Guide
Article • 03/14/2023

This section includes:

Access Attribute Memory of a PCMCIA Device

PCMCIA_INTERFACE_STANDARD Interface for Memory Cards

PCMCIA IRQ Routing on Windows XP

POS device driver design guide
Article • 03/03/2023

This section provides driver design guidance for point-of-service (POS) devices.

In this section
Topic Description

POS driver samples Provides samples that demonstrate how to create universal drivers
for point-of-service (POS) devices.

Barcode scanner Bluetooth Describes UUIDs for use with the Bluetooth Service Discovery
service UUIDs Protocol (SDP) for barcode scanners.

Barcode scanner events Describes events that are specific to barcode scanners.

Magnetic stripe reader Describes events that are specific to magnetic stripe readers (MSRs).
events

POS events Describes general POS events that are passed from the device driver
to the POS API layer.

Related sections
POS DDI reference
Power Metering and Budgeting Design
Guide
Article • 01/20/2022

This section describes the Power Metering and Budgeting (PMB) infrastructure and the
Power Meter Interface (PMI).

This section contains the following topics:

Overview of the Power Metering and Budgeting Infrastructure

User-Mode Power Service

Power Meter Interface

Software Defined Batteries

ACPI Power Meter Interface

Energy Meter Interface

EMI naming convention

Printer driver design guide
Article • 10/01/2024

This section provides information on designing printer drivers.

In this section
Modern print platform and Windows protected print mode

End of servicing plan for third-party printer drivers on Windows

Legacy v3 and v4 third-party printer driver design guide

Related sections
Print Support Apps design guide

Legacy v3 and v4 third-party printer driver DDI reference

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

SD Bus Driver Design Guide
Article • 03/14/2023

SD Card Driver Stack

Opening, Initializing and Closing an SD Card Bus Interface

Handling SD Card Interrupts

SD Card Requests

SD Card I/O Requests

Secure Digital Requests That Use Direct I/O

Secure Digital Requests That Use Extended I/O

Managing SD Cards in User-Mode Applications

Restrictions on SD Card Drivers

SD Card Hardware Identifiers

For information about Secure Digital (SD) device identification strings, see Identifiers for
Secure Digital (SD) Devices.

Restrictions on SD Card Drivers

Certain restrictions apply to Secure Digital (SD) card device drivers that manage a
function on an SD combo or multifunction card. The driver stacks for the various card
functions on a multifunction card must operate independently of one another. To ensure
this independence, the bus driver rejects the following operations:

SD commands that change the device state, such as SELECT_CARD.

SD I/O commands that specify function zero but are outside the range of the
address specified in the function basic register (FBR).

SD I/O commands that specify a function number of a different device stack.

SD device drivers can manage the host controller's common register set and the state of
the device by calling SdBusSubmitRequest with function requests of type
SDRF_GET_PROPERTY and SDRF_SET_PROPERTY. For a description of these function
request types, see SD_REQUEST_FUNCTION.

SD Bus Sample (Windows 8.1)

This sample (no longer supported) is a functional Secure Digital (SD) IO driver. The
driver is written using the Kernel Mode Driver Framework. It is a driver for a generic
mars development board that implements the SDIO protocol without additional
functionality.

Download the Storage SDIO driver sample from GitHub.

Introduction to the Sensor and Location
Platform in Windows
Article • 01/11/2024

The Windows operating system provides native support for sensor devices. This support
includes location sensors such as GPS devices. As part of this support, the platform
provides a standard way for device manufacturers to expose sensor devices to software
developers and consumers. At the same time, the platform gives developers a
standardized API and device driver interface (DDI) to work with sensors and sensor data.
This section summarizes the Windows sensor and location platform, discusses the
various parts of the platform, and describes how the pieces work together to provide a
comprehensive system for working with sensors.

Sensor Device Overview

Sensors come in many configurations and, from a certain perspective, almost anything
that provides data about physical phenomena can be called a sensor. Although we
typically think of sensors as hardware devices, logical sensors can also provide
information through emulation of sensor functionality in software or firmware. Also, a
single hardware device can contain multiple sensors.

The sensor and location platform organizes sensors into categories, which represent
broad classes of sensor devices, and types, which represent specific kinds of sensors. For
example, a sensor in a video game controller that detects the position and movement of
a player's hand (perhaps for a video bowling game) would be categorized as an
Orientation sensor, but its type would be 3-D Accelerometer. In code, Windows
represents categories and types by using globally unique identifiers (GUIDs), many of
which are predefined. Device manufacturers can create new categories and types by
defining and publishing new GUIDs, when it is required.

Location devices comprise one especially interesting category. By now, most people are
familiar with global positioning systems (GPS). In Windows, a GPS is a kind of sensor
that is part of the Location category. The Location category could include other sensor
types. Some of these sensor types are software based, such as an IP resolver that
provides location information based on an Internet address, a cellular phone tower
triangulator that determines location based on nearby towers, or a sensor that
determines location from the presence of Wi-Fi networks.
About the Platform
The Windows sensor and location platform consists of the following developer and user
components:

The DDI. Windows provides a standard way for sensor devices to connect to the
computer and to provide data to other subsystems.
The Windows Sensor API provides a set of methods, properties, and events to work
with connected sensors and sensor data.
The Windows Location API, which is built on the Windows Sensor API, provides a
set of programming objects. These objects include scripting objects, for working
with location information.
The Control Panel gives computer users control over location settings.

The following sections describe each of these components.

Device Driver Interface

Sensor manufacturers can create device drivers to connect sensors with Windows.
Sensor device drivers are implemented by using the Windows Portable Devices (WPD)
driver model, which is based on the Windows User Mode Driver Framework
(UMDF).Many device drivers have been written by using these frameworks. Because
these technologies are established, experienced device driver programmers will find
writing a sensor driver to be a familiar task. The sensor DDI uses specific UMDF and
WPD data types and interfaces, and also defines sensor-specific WPD commands and
parameters, where it is required.

To help make it easier to write a device driver that exposes a sensor to Windows (and to
the sensor and location platform in particular), the operating system includes a driver
class extension. A required component for sensor device drivers, this COM object
provides a simple set of interfaces that enable programmers to implement a sensor
driver without writing lots of boilerplate code. The class extension can also reduce, or
even eliminate, the need to manage WPD calls. This documentation contains detailed
information about the sensor DDI and class extension object.

Sensor API
The Windows Sensor API enables C++ developers to create sensor-based programs by
using a set of COM interfaces. The API defines interfaces to perform common sensor
programming tasks that include managing sensors by category, type, or ID, managing
sensor events, working with individual sensors and sensor collections, and working with
sensor data. The Windows SDK includes header files, documentation, samples, and tools
to help guide software developers on how to use sensors in Windows programs.

Location API
Built on the sensor platform, the Location API provides an easy way to retrieve data
about geographic location while protecting user privacy. The Location API provides its
functionality through a set of COM interfaces that represent objects. These objects can
be used by programmers who understand how to use COM through the C++
programming language, or in scripting languages, such as JScript. Scripting support
gives easy access to location data for projects that run in the Local Computer zone, such
as gadgets. The Windows SDK includes header files, documentation (including scripting
reference documentation), samples, and tools to help guide Web and software
developers on how to use location information in their programs.

User Control Panel

Windows includes a control panel that allows computer users to enable or disable
location settings. Because thesesettings can expose sensitive data, this user interface
gives users control over whether programs have access to their location.

Whitepapers
ﾉ Expand table

Title Description

HID Sensors Usages This paper provides information about the HID Sensor Class
Driver for Windows 8 and later operating systems.

Integrating Ambient Light Sensors This paper provides information about ambient light sensor
with Computers Running (ALS) features in the Windows 10 operating system.
Windows 10 Creators Update

Integrating Motion and This paper is intended to help OEMs, ODMs, and IHVs
Orientation Sensors understand motion and orientation sensor capabilities and
requirements for Windows 10 and earlier operating systems.

Related sections
Sensors DDI reference
Sensors Blogs
６ Collaborate with us on Windows driver
GitHub documentation feedback
The source for this content can Windows driver documentation is an
be found on GitHub, where you open source project. Select a link to
can also create and review provide feedback:
issues and pull requests. For
more information, see our  Open a documentation issue
contributor guide.
 Provide product feedback
Serial Controller Driver Design Guide
Article • 07/01/2022

You can design a driver or application that uses the serial I/O request interface to
communicate with a peripheral device connected to a serial port. A serial port is a
hardware communication interface on a serial controller, which is a 16550 UART or
compatible device. To control a serial port to which a peripheral device is permanently
connected, you can design a custom serial controller driver that works with version 2 of
the serial framework extension (SerCx2), which replaces version 1 (SerCx).

In older versions of Windows, a named serial COM port located on the case of a PC, the
inbox Serial.sys and Serenum.sys drivers were used.

７ Note

This topic describes programming traditional COM ports. For information on USB
attached serial ports, see USB serial driver (Usbser.sys).

SerCx2
You can write a serial controller driver that works together with version 2 of the serial
framework extension (SerCx2) to manage a serial controller. You can also write a
peripheral driver for a peripheral device that is connected to a port on a serial controller
that is jointly managed by SerCx2 and a serial controller driver. This peripheral driver
uses the serial I/O request interface to transfer data to and from the device. An
extension-based serial controller driver handles all hardware-specific tasks for the serial
controller, but uses SerCx2 to perform many system tasks that are common to all serial
controllers. SerCx2 is a system-supplied component starting with Windows 8.1.

SerCx2 relieves the serial controller driver of the processing work required to manage
time-outs, and to coordinate I/O transactions that compete for access to the serial
controller. As a result, the serial controller driver is smaller and simpler. The hardware
vendor for the serial controller supplies an extension-based serial controller driver that
manages the hardware-specific functions in the serial controller, and that relies on
SerCx2 to perform generic serial-controller tasks. This driver communicates with SerCx2
through the SerCx2 device driver interface.

For more information about SerCx2, see Using Version 2 of the Serial Framework
Extension (SerCx2).
In this section
Using Version 2 of the Serial Framework Extension (SerCx2)
Previous Versions of Windows - Serial Controller Drivers
Serial IRP major function codes
Serial Port Console Redirection Table (SPCR)
Smart Card Reader Devices Design
Guide
Article • 07/16/2024

Design guide for developing drivers for smart card reader devices.

In this section
ﾉ Expand table

Topic Description

Smart Card Driver Describes the standard environment for the smart card reader driver.
Environment

Management of IOCTL Explains how reader drivers manage IOCTL requests, how the callback
Requests in a Smart routine mechanism works, and what a reader driver must do to initialize
Card Reader Driver its callback routines.

WDM Reader Driver Lists the routines that are required by a WDM reader driver.

Smart Card Minidrivers The smart card minidriver provides a simpler alternative to developing
a legacy cryptographic service provider (CSP) by encapsulating most of
the complex cryptographic operations from the card minidriver
developer.

Smart Card Reader A table listing the Smart Card reader states and their meanings.
States

Installing Smart Card Provides installation information that is specific to smart card reader
Reader Drivers drivers for Windows.

Registering a WDM Provides required registry values and their descriptions for registering a
Smart Card Reader WDM Smart Card Reader driver.
Driver

Enabling Smart Card Registry value name and contents of the registry value for event
Event Logging in the logging.
Registry

WDM Device Names Instructions for complying with the naming conventions for device
for Smart Card Readers names in Windows operating systems.

Smart Card Driver Describes the smart card driver libraries support of debugging features.
Debugging
 Topic Description

Specifications and To work with the smart card support in Microsoft Windows operating
Resources systems, smart card readers and cards should be compatible with
Interoperability Specification for ICCs and Personal Computer Systems.
Smart card readers and device drivers should also be Plug and Play
compliant.

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Simple Peripheral Bus (SPB) Driver
Design Guide
Article • 01/20/2022

This section describes how to write a driver for a simple peripheral bus (SPB) controller
device or for a peripheral device that is connected to an SPB. The SPB category includes
buses such as I²C and SPI. The hardware vendor for an SPB controller device provides an
SPB controller driver to manage the hardware functions in the controller. This driver
might support a family of similar controller devices. The hardware vendor for an SPB-
connected peripheral device provides an SPB peripheral driver to manage the hardware
functions in the peripheral device. This driver might support a family of peripheral
devices across a variety of hardware platforms that provide compatible SPBs.

In versions of Windows before Windows 8, the operating system obtained information

from SPB-connected devices on a PC motherboard only indirectly through the platform
firmware. Starting with Windows 8, hardware vendors can supply Windows drivers to
directly control their SPB controllers and their SPB-connected peripheral devices, and to
make these devices available for use by the operating system and by applications. For
more information, see SPB Controller Drivers and SPB Peripheral Device Drivers.

SPBs are frequently used to connect low-speed peripheral devices to motherboard

chipsets and System on a Chip (SoC) modules. An integrated circuit requires fewer pins
to connect to a serial bus than to a parallel bus, which transmits multiple bits of data per
clock cycle. Typically, SPBs are used in cost-sensitive applications in which low pin
counts and simple connections are more important than data transmission speed.
Because SPBs run at low speeds and require few electrical connections, they are
frequently used in applications in which battery power must be conserved.

For example, the PC motherboard in a laptop computer might use an I²C bus to
communicate with a low-speed device that monitors the battery level. Similarly, the SoC
module in a smart phone or other mobile device might use an I²C bus to connect to a
sensor device, such as an accelerometer, a GPS device, or a temperature sensor.

An SPB is not a Plug and Play bus. Peripheral devices typically have fixed connections to
an SPB and cannot be removed. Even if a peripheral device can be unplugged from a
slot on an SPB, the slot is typically dedicated to this device. During system startup, the
ACPI firmware in the hardware platform enumerates the SPB-connected peripheral
devices for the Plug and Play manager, and specifies the hardware resources that are
dedicated to each device.
Included in these resources is a connection ID that identifies the device's connection to
the SPB. The connection ID encapsulates the information (for example, a bus address
and a bus clock frequency) that an SPB controller requires to establish a connection to
the device. Other hardware resources might include an interrupt to which the driver
connects its ISR. However, the hardware resources for the device do not include memory
for device registers. An SPB-connected peripheral device is not memory mapped and
can be accessed only through the SPB. For more information, see Connection IDs for
SPB-Connected Peripheral Devices.

An SPB provides no bus-specific means to convey interrupt requests from peripheral

devices to the processor. Instead, an SPB-connected peripheral device signals an
interrupt through a separate hardware path that lies outside of both the SPB and the
SPB controller. The interrupt service routine (ISR) for an SPB-connected peripheral
device must run at IRQL = PASSIVE_LEVEL so that it can synchronously send I/O requests
to serially access the hardware registers of the device over the SPB. For more
information, see Interrupts from SPB-Connected Peripheral Devices.
Storage driver design guide
Article • 01/20/2022

Storage drivers include class, port, miniport, and filter drivers. Typically, a device vendor
will implement a miniport driver for a specific adapter or adapter type. Although not
common, a new storage class can be defined and a new class driver developed for it.
Storage classes in Windows include the Disk, CDROM, USB storage, and encrypted drive
classes. Storage driver development is usually limited to writing a miniport driver to
work with the StorPort port driver.

Other types of storage drivers are secure silo drivers and Device Specific Modules
(_DSM) for multipath I/O. For storage management, WMI providers are developed as a
control interface to a driver.

The storage driver design guide includes the following sections:

Roadmap for Developing Windows Storage Drivers

Roadmap for Developing Storport Miniport Drivers
Storage Drivers
Storage Class Drivers
Storage Port Drivers
Storage Miniport Drivers
Storage Virtual Miniport Drivers
Storage Filter Drivers
Crash Dump Filter Drivers
Storage Silo Drivers
CD-ROM Drivers
Tape Drivers
Changer Drivers
Storage Scenarios

Samples
Studying samples is a practical way to see how working storage drivers are developed.
Sample storage drivers are available on GitHub.

Driver Verification for StorPort

Using code analysis tools during driver development and testing helps to catch
performance problems and defects in a storage driver. The Static Driver Verifier (SDV)
tool is available to discover defects in storage driver code. Included with SDV are
compliance rules for verifying proper usage of StorPort routines by miniport drivers.
Storage Firmware Update (SFU)
Article • 03/03/2023

Storage Firmware Update (SFU) provides a reliable and authenticated method for
updating firmware on NVMe storage drives that have shipped to customers.

In this section
Topic Description

Storage Firmware Provides detailed guidance on implementing SFU and the process of creating
Update (SFU) new firmware images to be installed on the target NVMe storage drives.
driver
Streaming media device driver design
guide
Article • 04/25/2024

Use the guidance in this section to design and implement drivers for devices that stream
video and audio (for example, webcams and digital camcorders).

New and updated content for Windows 11,

version 22H2 and Windows 11, version 23H2
Camera settings page

Camera companion apps

Network cameras

Background segmentation portrait mode and eye gaze stare mode driver sample

KSPROPERTY_CAMERACONTROL_EXTENDED_BACKGROUNDSEGMENTATION

KSPROPERTY_CAMERACONTROL_EXTENDED_EYEGAZECORRECTION

USB Video Class (UVC) camera implementation guide

Privacy shutter replacement image

New and updated content for Windows 11

Camera privacy shutters and kill switches

Privacy shutter/switch notification

Digital Window overview

Microsoft extensions to USB Video Class 1.5 specification

Create device property keys from the MS OS descriptor in USB Video Class (UVC)
camera firmware

Network camera design guide

In this section
Camera Profile V2 developer specification

USB Video Class (UVC) camera implementation guide

USB Video Class (UVC) driver implementation checklist

Frame Server Custom Media Source

Universal camera driver design guide for Windows 10

Device firmware update for USB devices without using a co-installer

360 camera video capture

Camera intrinsics

DShow Bridge implementation guidance for UVC devices

Camera class INF file setting for Universal camera drivers

OEM guidance on settings for the Windows 10 in-box camera app

Video stabilization registry settings

Extended camera controls

Camera driver bring up guide

Camera Device Orientation

Streaming Media Samples

AVStream Minidrivers

AVStream Property Sets

Encoder Property Sets

Encoder Events

AV/C Protocol Driver Function Codes

AV/C Streaming Protocol Driver Function Codes

AV/C Streaming Constants

Video Capture Minidriver Property Sets

Video Capture Minidriver Event Sets

Device transform manager events

Windows 2000 Kernel Streaming Model Design Guide

Kernel Streaming Proxy Plug-ins

Kernel Streaming Topology Nodes

Kernel Streaming Interface Sets

Kernel Streaming Event Sets

Kernel Streaming Method Sets

Stream Class SRB Reference

DVD Decoder Minidriver Property Sets

DVD Decoder Minidriver Event Sets

COM Interfaces

Broadcast Driver Architecture Property, Event, and Method Sets

Broadcast Driver Architecture Constants

Related sections
Streaming media DDI reference

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A

Test Authoring and Execution
Framework (TAEF)
Article • 01/20/2022

The Test Authoring and Execution Framework (TAEF) provides a consistent mechanism
for developers and testers to write and run automation. The framework provides a single
infrastructure that allows them to share tests across disciplines and teams.
Universal Serial Bus (USB)
Article • 12/08/2023

Universal Serial Bus (USB) provides an expandable Plug and Play serial interface that
ensures a standard, low-cost connection for peripheral devices. USB devices include
keyboards, mice, joysticks, printers, scanners, storage devices, modems, video
conferencing cameras, and more.

The USB-IF is a Special Interest Groups (SIGs) that maintains the Official USB
Specification , test specifications and tools.

Windows operating systems include native support for USB host controllers, hubs, and
devices and systems that comply with the official USB specification. Windows also
provides programming interfaces that you can use to develop device drivers and
applications that communicate with a USB device.

USB in Windows
Windows support for USB Type-C connectors: For OEMs who want to build a
Windows system with USB Type-C connectors.

Universal Serial Bus 4 (USB4™): Provides OEMs, IHVs and silicon vendors bringing
up Windows systems supporting USB4 with information about the USB4
connection manager, facilitating debugging, and bring-up procedures.

USB FAQ: Frequently asked questions from driver developers about the USB stack
and features that are supported in USB.

Microsoft OS Descriptors for USB Devices: Windows defines MS OS descriptors

that allows better enumeration when connected to system running Windows
operating system.
Development tools
Download the Windows Driver Kit (WDK)

USB samples
UWP app samples for USB
Windows driver samples for USB

Create a USB driver or app for Windows

Introduces you to USB driver development. Provides information about choosing the
most appropriate model for providing a USB driver for your device.

Write a USB client driver (KMDF, UMDF)

This section includes tutorials about writing your first user-mode and kernel-mode USB
drivers by using the USB templates included with Microsoft Visual Studio.

Getting started with USB client driver development

USB device driver programming reference

Write a USB host controller driver

If you're developing an xHCI host controller that isn't compliant with the specification or
developing a custom non-xHCI hardware (such as a virtual host controller), you can
write a host controller driver that communicates with UCX. For example, consider a
wireless dock that supports USB devices. The PC communicates with USB devices
through the wireless dock by using USB over TCP as a transport.

Developing Windows drivers for USB host controllers

USB host controller (UCX) reference

Ucxclass.h
Ucxcontroller.h
Ucxroothub.h
Ucxusbdevice.h
Ucxendpoint.h
Ucxsstreams.h
Write a function controller driver for a USB device
You can develop a controller driver that handles all USB data transfers and commands
sent by the host to the device. This driver communicates with the Microsoft-provided
USB function controller extension (UFX).

Developing Windows drivers for USB function controllers

USB function class extension (UFX) reference

Ufxbase.h
Ufxclient.h
Ufxproprietarycharger.h

Write a USB Type-C connector driver

Windows 10 introduces support for the new USB connector: USB Type-C. You can write a
driver for the connector that communicates with the Microsoft-provided class extension
module: UcmCx to handle scenarios related to Type-C connectors such as, which ports
support Type-C, which ports support power delivery.

Developing Windows drivers for USB Type-C connectors

USB connector manager class extension (UcmCx) reference

Ucmmanager.h

Write a USB dual-role controller driver

USB Dual Role controllers are now supported in Windows 10. Windows includes in-box
client drivers for ChipIdea and Synopsis controllers. For other controllers, Microsoft
provides a set of programming interfaces that allow the dual-role class extension
(UrsCx) and its client driver to communicate with each other to handle the role-
switching capability of a dual-role controller.

For more information about this feature, see:

USB Dual Role Driver Stack Architecture

USB dual-role controller driver programming reference

Ursdevice.h

Write a USB driver for emulated devices

You can develop an emulated Universal Serial Bus (USB) host controller driver and a
connected virtual USB device. Both components are combined into a single KMDF driver
that communicates with the Microsoft-provided USB device emulation class extension
(UdeCx).

Developing Windows drivers for emulated USB devices (UDE)

Emulated USB host controller driver programming reference

Udecxusbdevice.h
Udecxusbendpoint.h
Udecxwdfdevice.h
Udecxurb.h

WDF extension for developing USB drivers

USB connector manager class extension (UcmCx) reference
Ucmmanager.h
USB host controller (UCX) reference
Ucxclass.h
Ucxcontroller.h
Ucxroothub.h
Ucxusbdevice.h
Ucxendpoint.h
Ucxsstreams.h
USB function class extension (UFX) reference
Ufxbase.h
Ufxclient.h
Ufxproprietarycharger.h

Write a UWP app

Talk to USB devices, start to finish: Provides step-by-step instructions about
implementing USB features in a UWP app. To write such an app for a USB device,
you need Visual Studio and Microsoft Windows Software Development Kit (SDK).

Windows.Devices.Usb: UWP namespace programming reference.

Write a Windows desktop app

Write a WinUSB application: Describes how an application can call WinUSB
Functions to communicate with a USB device.
 WinUSB functions
Winusb.h
Usbioctl.h

Common programming scenarios: List of common tasks that a driver or an app

performs in order to communicate with a USB device. Get quick info about the
programming interfaces you need for each task.

Testing USB devices with Windows

Overview of Microsoft USB Test Tool (MUTT) devices

Get information about the tools that you can use to test your USB hardware or software,
capture traces of operations and other system events, and observe how the USB driver
stack responds to a request sent by a client driver or an application.

Read an overview of tests in the Hardware Certification Kit that enable hardware vendors
and device manufacturers to prepare their USB devices and host controllers for
Windows Hardware Certification submission.

Universal Serial Bus 4 (USB4™)

Universal Serial Bus 4 (USB4™): Provides OEMs, IHVs and silicon vendors bringing
up Windows systems supporting USB4 with information about the USB4
connection manager, facilitating debugging, and bring-up procedures.

Introduction to the USB4 connection manager in Windows: The connection

manager in a USB4 domain is responsible for enumeration, configuration, and
management of the USB4 domain.

Universal Serial Bus 4 (USB4™) design details and general requirements: High-level
design and user experience requirements.

Universal Serial Bus 4 (USB4™) required testing: The HLK requirements aren't
designed to provide complete end-to-end functional test coverage for the USB4
feature set. We recommend that you perform thorough validation of important
usage scenarios.

Other Resources for USB

Official USB Specification : Provides complete technical details for the USB
protocol.
 Microsoft Windows USB Core Team Blog : Check out posts written by the
Microsoft USB Team. The blog focuses on the Windows USB driver stack that works
with various USB Host controllers and USB hubs found in Windows PC. A useful
resource for USB client driver developers and USB hardware designers to
understand the driver stack implementation, resolve common issues, and explain
how to use tools for gathering traces and log files.

OSR Online Lists - ntdev : Discussion list managed by OSR Online for kernel-
mode driver developers.

Windows Hardware Dev Center: Miscellaneous resources based on frequently

asked questions from developers who are new to developing USB devices and
drivers that work with Windows operating systems.

USB hardware for learning

MUTT devices: MUTT and SuperMUTT devices and the accompanying software
package are integrated into the HCK suite of USB tests. They provide automated
testing that can be used during the development cycle of USB controllers, devices
and systems, especially stress testing.

OSR USB FX2 Learning Kit : If you're new to USB driver development. The kit is
the most suitable to study USB samples included in this documentation set. You
can get the learning kit from OSR Online Store.

Learn about Microsoft-provided USB drivers

USB device-side drivers in Windows: Describes the architecture of the USB function
stack.

USB host-side drivers in Windows: Provides an overview of the Universal Serial Bus
(USB) driver stack architecture. Microsoft provides a core stack of drivers that
interoperate with devices that are connected to EHCI and xHCI controllers.

USB-IF device class drivers: Lists the Microsoft-provided drivers for the supported
USB device classes. Windows provides in-box device class drivers for many USB-IF
approved device classes, audio, mass storage, and so on.

USB generic function driver–WinUSB: WinUSB is a generic driver for USB devices
that is included with all versions of Windows since Windows Vista. Windows
provides Winusb.sys that can be loaded as a function driver for a custom device
and a function of a composite device.
 USB generic parent driver for composite devices–Usbccgp: Parent driver for USB
devices with multiple functions. Usbccgp creates physical device objects (PDOs) for
each of those functions. Those individual PDOs manage their respective USB
function drivers, which could be the Winusb.sys driver or a USB device class driver.

６ Collaborate with us on Windows driver

GitHub documentation feedback
The source for this content can Windows driver documentation is an
be found on GitHub, where you open source project. Select a link to
can also create and review provide feedback:
issues and pull requests. For
more information, see our  Open a documentation issue
contributor guide.
 Provide product feedback
Windows Device Testing Framework
(WDTF) design guide
Article • 01/20/2022

The Microsoft Windows Device Testing Framework (WDTF) enables you to create,
manage, reuse, and extend device-centric, scenario-based automated tests.

In this section
Topic Description

Writing a To get the most benefit from the Device Fundamental tests, your device should
WDTF have a Simple I/O plug-in that can perform simple I/O to your device. This can be
SimpleIO one of the default Simple I/O plugs that come with WDTF or one that you wrote. To
plug-in for see if your device type is supported and to determine if there are specific
your device requirements for testing, refer to Provided WDTF Simple I/O plug-ins.

Writing Whether you start writing driver tests with the templates provided in the Windows
tests with Driver Kit (WDK), or whether you create the tests on your own, the Microsoft
WDTF Windows Device Testing Framework (WDTF) enables you to create and extend
device-centric, scenario-based automated tests.

Triaging To help you better understand what is going on in your WDTF-based tests, you can
WDTF- use the built-in support for WDTF Object Logging and WPP Software Tracing.
based tests

WDTF The Microsoft Windows Device Testing Framework (WDTF) enables you to create,
Architecture manage, reuse, and extend device-centric, scenario-based automated tests.
and
Overview
Windows Hardware Error Architecture
(WHEA) design guide
Article • 03/14/2023

This section describes the Windows Hardware Error Architecture (WHEA), which provides
support for hardware error reporting and recovery. In this section, the following
information is provided:

An overview of WHEA and its components. For more information, see Windows
Hardware Error Architecture Overview.

How to develop and distribute platform-specific hardware error driver (PSHED)

plug-ins. For more information, see Platform-Specific Hardware Error Driver Plug-
Ins.

How user-mode applications can communicate with the WHEA platform. For more
information, see Windows Hardware Error Architecture-Aware User-Mode
Applications.

In this section
Introduction to the Windows Hardware Error Architecture

New Information for Windows Hardware Error Architecture

Windows Hardware Error Architecture Definitions

Windows Hardware Error Architecture Overview

Platform-Specific Hardware Error Driver Plug-Ins

Windows Hardware Error Architecture-Aware User-Mode Applications

Windows Hardware Error Architecture Debugger Extensions

Related topics
Windows Hardware Error Architecture ACPI Table Specification

Hardware Management and Security

Bug Check 0x124: WHEA_UNCORRECTABLE_ERROR (Windows Debuggers)

Windows Portable Devices
Article • 03/14/2023

In This Section
WPD Design Guide
WPD Programming Guide
WPD Reference
API reference docs for Windows Driver
Kit (WDK)
The Windows driver API reference documentation is presented in two different views. In
the table of contents, select a technology to see the subset of APIs and headers
pertaining to that driver technology. Or, select a header to see all APIs in that header.
When you select an API, the table of contents switches to the technology-scoped view
for that API.

Buses and ports

ｉ REFERENCE

General-purpose I/O (GPIO)

Simple Peripheral Bus (SPB)

Peripheral Component Interconnect (PCI)

Universal Serial Bus (USB)

Connectivity

ｉ REFERENCE

Bluetooth

Network

Smart Card Readers

Devices

ｉ REFERENCE

Human Interface Device (HID)

Image and Scan

Print
Sensors

Driver Model

ｉ REFERENCE

Kernel

WDF

Streaming

ｉ REFERENCE

Audio

Camera

System

ｉ REFERENCE

Advanced Configuration and Power Interface (ACPI)

Display

File system

Hardware notifications

Storage
Windows driver samples
Article • 09/27/2024

You can browse and download individual Windows 11 driver samples on the Microsoft
Samples portal. You can also clone, fork, or download the Windows-driver-samples
repo on GitHub.

Earlier versions of Windows driver samples are archived at Microsoft Archive on GitHub:

Windows 8.1 driver samples

Windows 8 driver samples

For Windows 7, samples were included in the Windows Driver Kit (WDK).

Driver samples for specific technologies

For more information about the Windows 11 driver samples available for a specific
technology area, see the following topics:

Audio driver samples

AVStream driver samples

Battery driver samples

Bluetooth driver samples

File system driver samples

General driver samples

General-purpose input/output (GPIO) driver samples

Global Navigation Satellite System (GNSS) driver samples

Human interface devices (HID) driver samples

Input driver samples

Networking driver samples

Near field communication (NFC) driver samples

Near field proximity (NFP) driver samples

 Power framework (PoFx) driver samples

Point of service (POS) driver samples

Secure Digital (SD) driver samples

Security driver samples

Sensor driver samples

Serial driver samples

Setup samples

Smart card driver samples

Simple peripheral bus (SPB) driver samples

Storage driver samples

Thermal driver samples

Tools samples

Trusted Execution Environment (TrEE) driver samples

Universal Serial Bus (USB) driver samples

Video driver samples

Windows Image Acquisition (WIA) driver samples

Windows Management Instrumentation (WMI) driver samples

Feedback
Was this page helpful?  Yes  No

Provide product feedback | Get help at Microsoft Q&A