DRIVER_IRQL_NOT_LESS_OR_EQUAL is Windows stop code 0x000000D1 (0xD1). Microsoft's reference says it indicates "that a kernel-mode driver attempted to access pageable memory while the process IRQL was too high." Put simply, a driver touched memory at a moment when it was not allowed to wait for that memory to be loaded.
Microsoft's own summary of the usual cause is "drivers that have used improper memory addresses." The page is written for programmers, with a short list of basic checks for everyone else.
This page is built from the Microsoft Learn article "Bug Check 0xD1: DRIVER_IRQL_NOT_LESS_OR_EQUAL" and, where noted, Microsoft's general page on analysing blue screen data, both read on 13 October 2026 and checked against the Microsoft Docs source files. Microsoft marks the 0xD1 page as written for programmers and directs customers to https://www.windows.com/stopcode. Anything taken from the general page rather than the 0xD1 page is labelled as such.
What do the parameters say?
As printed in Microsoft's reference for 0xD1:
| Parameter | What Microsoft says it holds |
|---|---|
| 1 | Memory referenced |
| 2 | IRQL at time of reference |
| 3 | The type of access: 0 read, 1 write, 2 execute, 8 execute |
| 4 | Address that referenced memory; Microsoft suggests the ln (list nearest symbols) command to see the function name |
Parameter 3 lists "execute" twice, as 2 and as 8, in Microsoft's table. This page repeats it as printed. Parameter 4 is the one a debugger turns into a function name.
What is an IRQL, and why does it matter here?
IRQL stands for interrupt request level. Windows uses it to decide what may interrupt what: code running at a higher level cannot be interrupted by code at a lower one. In Microsoft's example output from the debugger, the processor's saved IRQL is 2, labelled DISPATCH_LEVEL. The reference points readers to Windows Internals (7th edition, part 1) for more.
The reason this stop code exists is simple. Pageable memory may need to be read in from disk before it can be used, and code at DISPATCH_LEVEL or above cannot wait for that. If a driver touches pageable data or runs pageable code there, Windows stops. Microsoft adds a caution for debuggers: in the majority of cases of this bug check, "the issue is not the IRQL level, but rather the memory that is being accessed."
What causes it, according to Microsoft?
Typically a driver has tried to access an address that is pageable, or completely invalid, while the IRQL was too high. Microsoft names three ways this happens:
- Dereferencing a bad pointer, such as a NULL or freed pointer, while executing at or above DISPATCH_LEVEL.
- Accessing pageable data at or above DISPATCH_LEVEL.
- Executing pageable code at or above DISPATCH_LEVEL.
And three ways the page fault itself can arise: a function marked as pageable was running at an elevated IRQL (which includes obtaining a lock); a call was made to a function in another driver, and that driver was unloaded; or a function was called through an invalid function pointer.
Which debugger commands does Microsoft pair with which parameter?
The Resolution section reads like a map from each parameter to a command. For people who will never open a debugger, it still shows what each number is for:
| Parameter or goal | Command Microsoft names | What it is used for |
|---|---|---|
| Parameter 4 | ln (list nearest symbols) | To see the name of the function that referenced the memory |
| Parameter 4 | u, ub, uu (unassemble) | To look at the code at the referencing address |
| Parameter 1 | !pool | To see whether the address is in paged pool |
| Parameter 1 | !address and !pte | To learn more about that area of memory |
| Parameter 1 | The display memory commands | To examine the memory referenced |
| Whole system | lm t n and !memusage | To list loaded modules and examine the general state of system memory |
Microsoft's own caution, quoted above, is that in most cases the memory being accessed is the issue rather than the IRQL, which is why the page keeps returning to the memory address.
How does Microsoft suggest finding the driver?
If a responsible driver can be identified, its name is printed on the blue screen and stored in memory at the location KiBugCheckDriver, which a debugger can display with the dx command. Microsoft's example output shows a driver named Wdf01000.sys in that spot.
For deeper work it names the !analyze extension, the stack-trace commands and !irql, plus pool and page-table commands to learn about the memory in parameter 1. It also describes Driver Verifier, a tool built into Windows that examines driver behaviour in real time. You start it by entering verifier at a command prompt, and Microsoft warns that it adds overhead, so you should verify as few drivers as possible.
What Microsoft tells non-programmers to do
If you are not equipped to use the Windows debugger, Microsoft lists three basic techniques on the 0xD1 page:
- Check the System Log in Event Viewer for additional error messages that might help identify the device or driver causing the bug check.
- If a driver is identified in the bug check message, disable the driver or check with the manufacturer for driver updates.
- Confirm that any new hardware is compatible with the installed version of Windows.
For further general troubleshooting information, the 0xD1 page sends readers to Microsoft's "Analyze Bug Check Blue Screen Data" page. It lists no memory test, disk check or system file repair for this code, and this page adds none.
Checklist before changing anything
- Photo of the blue screen, including any driver name it shows
- Parameter 3 from the System Log (read, write or execute)
- Drivers installed or updated just before the first crash
- New hardware added recently
- Whether Driver Verifier has been run, and on which drivers
How to work through a 0xD1 blue screen
- Photograph the screen and note any driver name
- Check the System Log for other errors
- Disable or update the named driver
- Confirm new hardware is compatible with your Windows version
Registry edits and paid tools. Microsoft's page does not mention them, so neither does this one.
What is the trap frame, and when does it help?
Microsoft's Resolution section adds one conditional step that is easy to miss. If a trap frame is available in the dump file, it says to use the .trap command to set your context to the provided address. A trap frame is the saved processor state from the moment the fault was taken, so switching to it puts the debugger where the driver actually was rather than where the bug check handler ended up. Microsoft offers it as an "if available" step, not a required one, which is why it sits beside the stack backtrace commands rather than ahead of them.
Every stop code covered here is listed in our Windows blue screen stop code index.
Sources and how to check
- Microsoft Learn, "Bug Check 0xD1: DRIVER_IRQL_NOT_LESS_OR_EQUAL" — https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/bug-check-0xd1--driver-irql-not-less-or-equal. Source file in the MicrosoftDocs/windows-driver-docs repository.
- Microsoft Learn, "Analyze bug check (stop code error) data" — https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/blue-screen-data (general guide).
- Bug check code reference, Microsoft Learn: https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/bug-check-code-reference2
- Troubleshoot blue screen errors (for regular users): https://www.windows.com/stopcode
- Licence and credit: Microsoft Learn documentation is published under CC BY 4.0. This page selects, rewords and reorders it, adds a plain-language reading, and is not endorsed by Microsoft. The original is linked above.
- Checked as of 13 October 2026.
Questions readers ask about DRIVER_IRQL_NOT_LESS_OR_EQUAL Blue Screen 0xD1
What is stop code 0xD1?
It is DRIVER_IRQL_NOT_LESS_OR_EQUAL (0x000000D1). Microsoft says a kernel-mode driver attempted to access pageable memory while the IRQL was too high.
Is the problem the IRQL itself?
Microsoft says that in the majority of cases the issue is not the IRQL level but the memory that is being accessed.
What does parameter 3 mean?
It shows the type of access: 0 for read, 1 for write, 2 and 8 for execute, as listed by Microsoft.
What is Driver Verifier?
A tool built into Windows that examines driver behaviour in real time; you start it by entering verifier at a command prompt.
Does Microsoft say how to fix it for sure?
No. It lists checks, not a guaranteed fix.