You’re in the middle of running a generation in Stable Diffusion, or maybe you just launched a GPU-intensive application, and suddenly everything stops. The error message appears: “Error occurred on GPU ID 100.” No further explanation. No obvious fix. Just a wall of text and a crashed process.
This error is frustrating precisely because it seems vague. GPU ID 100 doesn’t point to one single cause. It can show up because of a memory issue, a driver conflict, a misconfigured environment, a VRAM shortage, or even a corrupted model file. The good news is that each of these causes has a clear fix once you know what you’re actually dealing with.
This guide walks through every known cause of this error, how to identify which one is hitting your system, and how to resolve it completely so you can get back to work.
Note: This guide focuses on NVIDIA GPUs running CUDA, since that’s where this error is most commonly reported. If you’re running an AMD GPU with ROCm instead of CUDA, the underlying cause is usually the same (VRAM exhaustion or a driver/runtime mismatch), but the specific fixes — like CUDA version checks — won’t apply directly; check ROCm compatibility instead.
What the GPU ID 100 Error Actually Means
Before jumping into fixes, it helps to understand what this error is actually telling you. GPU ID 100 is an internal identifier used by certain software frameworks and GPU processing pipelines to reference a specific GPU in the system. When you see “error occurred on GPU ID 100,” the software failed to complete an operation on the GPU it was assigned to use.
This doesn’t mean your GPU is physically broken. In most cases, it means the software either ran out of VRAM, lost communication with the GPU driver, encountered incompatible settings, or tried to load something the GPU couldn’t process in its current state. Physical hardware failure is actually one of the less common causes of this specific error.
In many cases, the full console log will also show a more specific underlying error, such as torch.cuda.OutOfMemoryError or a CUDA runtime error code. If you can access the terminal or command window running the process, scroll up past the GPU ID 100 message — the actual root cause is often logged a few lines earlier.
Why This Error Appears in Stable Diffusion Specifically
The GPU ID 100 error is most commonly reported inside Stable Diffusion environments, particularly AUTOMATIC1111, ComfyUI, Forge, and InvokeAI. These platforms rely heavily on the GPU for inference, and when something interrupts that process, this is often the error that surfaces.
The error became more widespread as users started running larger models, higher-resolution outputs, and more complex workflows that pushed VRAM to its limits. A setup that worked fine six months ago can start throwing GPU ID 100 errors after a model update, a driver update, or after simply increasing output resolution.
VRAM Shortage as the Most Common Cause
If there’s one place to start troubleshooting, it’s VRAM. Most GPU ID 100 errors come down to the GPU running out of memory mid-process. When the software tries to allocate more VRAM than the card physically has available, the operation fails and surfaces as this error.
This is especially common with:
- Running high-resolution outputs like 1024×1024 or above on cards with 4GB or 6GB of VRAM
- Loading large models such as SDXL on mid-range cards not designed for them
- Running multiple processes simultaneously that each claim a portion of VRAM
- Using high batch sizes without adjusting memory settings
Fixing this usually involves reducing resolution, lowering batch size, enabling model offloading to system RAM, enabling an attention optimization library like Xformers (which reduces VRAM usage during the attention computation step), or switching to a lighter model that fits within your card’s VRAM limit.
A Note on Shared vs. Dedicated GPU Memory (Windows)
On Windows, Task Manager shows both “Dedicated GPU memory” (your actual VRAM) and “Shared GPU memory” (system RAM borrowed by the GPU when VRAM runs out). When an application spills over into shared memory, performance drops sharply and errors like GPU ID 100 become more likely, since shared memory is far slower and less reliable for sustained AI workloads. If you see shared memory usage climbing during a generation, that’s a strong sign your VRAM is the real bottleneck.
How to Fix GPU ID 100 Error Step by Step
Step 1: Restart the Application and Clear VRAM
Start simple. Close the application entirely — not just the browser tab or the process window, but the full backend server. On Windows, check Task Manager and end any lingering Python processes that may still be holding VRAM. Restart fresh and try again. VRAM fragmentation from a previous failed run can sometimes cause persistent errors that disappear with a clean restart.
Step 2: Reduce VRAM Usage in Settings
Inside AUTOMATIC1111 or your WebUI of choice, look for launch arguments and settings that reduce VRAM load. Adding the flag --medvram or --lowvram when launching tells the application to offload parts of the model to system RAM instead of keeping everything on the GPU. Enabling --xformers (where supported) can also cut VRAM usage noticeably without a major speed penalty. This reduces the chance of running out of VRAM mid-generation.
The tradeoff with --medvram/--lowvram is slower generation times, but it solves the error reliably for most users with 6GB or less of VRAM.
Step 3: Update or Roll Back GPU Drivers
Driver conflicts are the second most common trigger for this error. A recently installed driver update can break compatibility with the CUDA version your software depends on, or introduce bugs that affect how the GPU handles memory allocation.
Two approaches work here. First, try updating to the latest stable driver from your GPU manufacturer’s website and test again. If the error started appearing after a recent driver update, roll back to the previous version using Device Manager on Windows or the equivalent tool on Linux. Keeping a note of which driver version your setup worked on is genuinely useful for exactly this situation.
Step 4: Check CUDA and cuDNN Compatibility
Stable Diffusion and most GPU-accelerated AI tools run on CUDA, NVIDIA’s parallel computing platform. If your installed CUDA version doesn’t match what the application expects, you’ll see crashes and errors like GPU ID 100 regularly.
Open a command prompt or terminal and run nvidia-smi to check your current CUDA version. Cross-reference this with the required CUDA version listed in your software’s documentation. Mismatches here are a common and easily overlooked cause of this error.
Step 5: Reinstall PyTorch With the Correct Version
Most AI and machine learning tools including Stable Diffusion use PyTorch for GPU operations. An incorrect PyTorch version, or one that’s incompatible with your current CUDA installation, can cause exactly this error.
The PyTorch website has a selector tool that generates the correct installation command based on your operating system, CUDA version, and package manager. Uninstall your current PyTorch installation and reinstall using the correct command for your setup. This resolves a surprising number of persistent GPU ID 100 errors that other steps don’t fix.
Step 6: Close Background GPU Processes
Other applications running in the background and using your GPU can push your available VRAM below what your main application needs. Common culprits include web browsers with hardware acceleration enabled, Discord, OBS, other games or applications left open, and even some antivirus tools.
Before running VRAM-intensive operations, close unnecessary background applications. You can verify what’s using your GPU’s memory in Task Manager on Windows by adding the GPU memory column to the processes view.
Step 7: Check the Model File for Corruption
If you recently downloaded a new model and the error started appearing immediately after, the model file itself might be the problem. A corrupted or incomplete download can cause crashes during inference that surface as GPU errors.
Delete the model file and redownload it from the source. If possible, verify the file hash after downloading to confirm the file downloaded completely and without corruption. Many model hosting platforms provide an MD5 or SHA256 hash alongside downloads for exactly this purpose.
Step 8: Check Available System RAM
Even with sufficient VRAM, extremely low system RAM can cause issues when the application tries to offload data. If your system RAM is near capacity from other running applications, the GPU pipeline can fail when it tries to use system memory as overflow. Closing RAM-heavy applications before running generations helps here, and adding more system RAM is worth considering if you regularly push your machine to its limits.
Step 9: Check System Logs for the Underlying Cause
If the error persists after the steps above, check for a more detailed log. On Windows, the Event Viewer (under Windows Logs > System) can reveal driver crashes or timeouts around the same time as the error. On Linux, running dmesg | tail right after the crash often shows kernel-level GPU or driver messages that point to the real cause more precisely than the application’s own error message.
Less Common Causes Worth Knowing
On multi-GPU systems, the GPU ID in the error message can point to a specific device. GPU ID 100 in some frameworks is a default fallback identifier rather than a physical GPU index, but in setups with multiple GPUs, it can indicate the application is trying to access a GPU that isn’t configured correctly or isn’t being recognized properly.
In these setups, checking environment variables like CUDA_VISIBLE_DEVICES and confirming the correct GPU is being targeted can resolve the error quickly.
Overclocking is another less common but real cause. If you’ve pushed your GPU’s memory clock beyond stable limits, VRAM errors can show up during heavy workloads like AI inference. Resetting to stock clock speeds and retesting is a quick way to rule this out.
Unstable power delivery can produce similar symptoms to overclocking instability — if your PSU is undersized or a cable isn’t fully seated, sustained GPU load during inference can trigger crashes that look identical to a VRAM or driver error. It’s worth ruling out if the error appears specifically under heavy, sustained workloads rather than immediately on launch.
Quick Reference: Cause and Fix Summary
| Likely Cause | Fastest Fix |
|---|---|
| VRAM shortage | Lower resolution/batch size, enable --medvram or --xformers |
| Driver conflict | Update or roll back GPU driver |
| CUDA/cuDNN mismatch | Check version with nvidia-smi, reinstall matching version |
| Wrong PyTorch build | Reinstall PyTorch using the official selector tool |
| Background apps hogging VRAM | Close browsers, Discord, OBS before running |
| Corrupted model file | Redownload and verify file hash |
| Low system RAM | Close other apps, consider a RAM upgrade |
| Multi-GPU misconfiguration | Check CUDA_VISIBLE_DEVICES |
| Overclock/power instability | Reset to stock clocks, check PSU and cable seating |
Preventing the GPU ID 100 Error Going Forward
A few habits prevent this error from showing up regularly. Keep drivers updated but wait a week or two after major driver releases to let initial bugs get patched. Match your model selection to your GPU’s actual VRAM capacity rather than pushing beyond its limits. Back up working configurations so you have a known good state to return to after updates. And monitor VRAM usage during generation using a tool like GPU-Z or HWiNFO to catch approaching limits before they cause crashes.
Conclusion
The GPU ID 100 error sounds more serious than it usually is. In the vast majority of cases, this comes down to VRAM limits being exceeded, a driver or CUDA version conflict, or a corrupted model file rather than anything physically wrong with your graphics card. Working through the steps in order, starting with VRAM reduction and driver verification, resolves the error for most users without needing any deep technical knowledge. Understanding what triggers it also makes it much easier to avoid in the future, so you spend less time troubleshooting and more time actually using your system for what it’s built for.
Frequently Asked Questions
What Causes the Error Occurred on GPU ID 100? This error is most commonly caused by running out of VRAM, driver incompatibility, a CUDA version mismatch, or a corrupted model file. VRAM shortage is the most frequent trigger.
Does GPU ID 100 Error Mean My GPU Is Damaged? No. In almost all cases, this is a software or configuration issue rather than a hardware failure. A physically damaged GPU usually shows different symptoms, such as display artifacts, frequent crashes, or complete system instability.
How Do I Fix GPU ID 100 in Stable Diffusion? Start by enabling the --medvram or --lowvram launch flag, lowering your image resolution, updating your GPU driver, and ensuring your PyTorch and CUDA versions are compatible with your Stable Diffusion installation.
Can Outdated Drivers Cause the GPU ID 100 Error? Yes. Outdated or incompatible GPU drivers can create conflicts with CUDA and machine learning frameworks, making driver-related issues one of the most common causes of the GPU ID 100 error.
Why Does GPU ID 100 Error Appear After a Windows Update? Windows updates can automatically install new GPU drivers or modify system components that affect CUDA compatibility. Reinstalling your preferred GPU driver version after a Windows update often resolves the issue.
Does This Error Happen on AMD GPUs Too? It can, though it’s far less commonly reported since most Stable Diffusion setups run on NVIDIA CUDA. On AMD hardware running ROCm, the same underlying causes — VRAM exhaustion and driver mismatches — apply, but the fix involves checking ROCm version compatibility instead of CUDA.
