KMODE_EXCEPTION_NOT_HANDLED is Windows stop code 0x0000001E (0x1E). Microsoft's reference says it means "a kernel-mode program generated an exception that the error handler didn't catch." In plain terms, code running with the highest privileges hit a problem it had no plan for, and Windows stopped rather than risk carrying on.
Microsoft gives customers a short route: look at the driver named on the screen, check the System Log, confirm any new hardware is compatible, and look at the BIOS. The page is written mainly for programmers, so most of its length is about reading the exception.
This page is built from the Microsoft Learn article "Bug Check 0x1E: KMODE_EXCEPTION_NOT_HANDLED" 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 0x1E page as written for programmers and directs customers to https://www.windows.com/stopcode. Anything taken from the general page rather than the 0x1E page is labelled as such.
What do the four parameters say?
The meaning of the first parameter decides how to read the exception. As printed in Microsoft's reference:
| Parameter | What Microsoft says it holds |
|---|---|
| 1 | The exception code that wasn't handled |
| 2 | The address where the exception occurred |
| 3 | Exception information parameter 0 of the exception record |
| 4 | Exception information parameter 0 of the exception record (the same wording as parameter 3 in Microsoft's table) |
Parameters 3 and 4 carry identical descriptions in Microsoft's table. This page repeats them as printed and does not guess which of the two is meant to differ. Parameter 2, the address, is the one Microsoft says should identify the driver or function that caused the problem.
Which exception codes does Microsoft name?
The cause section says you must identify which exception was generated, and lists three common ones:
| Exception code | Name | What Microsoft says it indicates |
|---|---|---|
| 0x80000002 | STATUS_DATATYPE_MISALIGNMENT | An unaligned data reference was encountered |
| 0x80000003 | STATUS_BREAKPOINT | A breakpoint or ASSERT was encountered when no kernel debugger was attached to the system |
| 0xC0000005 | STATUS_ACCESS_VIOLATION | A memory access violation occurred; parameter 4 is the address the driver attempted to access |
For the full list, Microsoft points to its NTSTATUS values reference and to the ntstatus.h header in the Windows Driver Kit. The three above are the ones named on the 0x1E page itself.
The second row is the odd one for ordinary users. A breakpoint is something a developer puts in code to pause a debugger. When it fires on a machine with no debugger attached, Windows has nothing to pause for, so the exception goes unhandled and the stop code appears. Microsoft says this problem "should occur rarely" and, if it repeats, the system may have been started with the /NODEBUG switch while a breakpoint is still in the code.
Hardware, drivers and the BIOS: what the Remarks section adds
Microsoft's Remarks section groups the customer-side advice under three headings.
Hardware incompatibility. Confirm that any new hardware is compatible with the installed version of Windows. Microsoft's example link is its Windows 10 specifications page.
Faulty device driver or system service. A faulty driver or system service might cause the error. Hardware issues such as BIOS incompatibilities, memory conflicts and IRQ conflicts can generate it too. If a driver is named in the message, disable or remove it, and disable or remove any drivers or services added recently. If the error happens during startup and the system partition uses NTFS, Microsoft says you might be able to use Safe Mode to disable the driver in Device Manager.
The BIOS note. Microsoft adds that the error might occur after the first restart during Windows Setup, or after Setup is finished, and that a possible cause is a system BIOS incompatibility, which can be resolved by upgrading the system BIOS version.
Why is a stack trace hard to get for this code?
Microsoft's Resolution section warns that it "might be difficult" to get a stack trace when debugging this problem and gives a procedure for when the cause is unknown. It assumes you can find a function called NT!PspUnhandledExceptionInSystemThread; if you cannot, it says to look for ntoskrnl!KiDispatchException instead, whose third parameter is a trap frame address. This is programmer territory, and the practical reading for everyone else is simple: the useful clue is parameter 2, the address, and the driver name if the screen shows one.
What Microsoft tells non-programmers to do
If you cannot use the Windows debugger, Microsoft says to use basic troubleshooting techniques. The 0x1E page gives them in this order:
- If a driver is identified in the bug check message, disable the driver or check with the manufacturer for driver updates.
- Confirm that new hardware is compatible with the installed version of Windows.
- Disable or remove recently added drivers or services; use Safe Mode to disable a driver in Device Manager if the error occurs at startup on an NTFS system partition.
- Check the System Log in Event Viewer for other error messages, and run the hardware diagnostics supplied by the system manufacturer, especially the memory scanner.
- If the error appears around Windows Setup, consider a BIOS update.
There is no step about repairing system files, resetting Windows or editing the registry for this code, and this page does not add any.
Checklist before changing anything
- Photo of the blue screen, including any driver name it shows
- Parameter 1 from the System Log (the exception code)
- Drivers or services installed just before the first crash
- New hardware added recently
- Whether the crash happens at startup, during Setup, or later
How to work through a 0x1E blue screen
- Photograph the screen and note the exception code
- Disable or update a driver if one is named
- Remove recent drivers, services or hardware
- Run the manufacturer's diagnostics and consider a BIOS update
Registry edits and paid tools. Microsoft's page does not mention them, so neither does this one.
The worked example Microsoft prints
The 0x1E page ends with a full example from an x86 machine, and it is worth knowing it is there before you start guessing. In it .bugcheck reports the arguments c0000005 8013cd0a 00000000 0362cffff - so parameter 1 is STATUS_ACCESS_VIOLATION and parameter 2 is the faulting address. The stack trace reaches NT!PspUnhandledExceptionInSystemThread, and from there Microsoft's route is fixed: dd on the pointer it is passed, .exr on the first value for the exception record, .cxr on the second for the context record, then kb again. In Microsoft's own example the trace that finally appears names a third-party driver, not a Windows component.
The page carries a documentation date of 8 December 2022. That is printed in the source file, and it is why nothing here describes a newer Windows build than the page does.
Sources and how to check
- Microsoft Learn, "Bug Check 0x1E: KMODE_EXCEPTION_NOT_HANDLED" — https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/bug-check-0x1e--kmode-exception-not-handled. 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 KMODE_EXCEPTION_NOT_HANDLED Blue Screen 0x1E
What is stop code 0x1E?
It is KMODE_EXCEPTION_NOT_HANDLED (0x0000001E). Microsoft says a kernel-mode program generated an exception that the error handler didn't catch.
What does parameter 1 mean?
It is the exception code that wasn't handled. Microsoft names 0x80000002, 0x80000003 and 0xC0000005 as common ones.
Can a BIOS problem cause 0x1E?
Microsoft says hardware issues such as BIOS incompatibilities can generate this error and that a BIOS upgrade can resolve BIOS problems.
Is 0x1E the same as 0x7E?
No. 0x1E is for a kernel-mode program; 0x7E is for a system thread. See the 0x7E page on this site.
Does Microsoft say how to fix it for sure?
No. It lists checks, not a guaranteed fix.