Fix floating-point inexact EXCEPTION 0XC000008F

You're running an old Windows application—maybe a game from 2005, a scientific calculator, or a CAD tool compiled with Visual C++ 6.0—and it crashes with EXCEPTION (0XC000008F). The error message says something like STATUS_FLOAT_INEXACT_RESULT. Let me break down exactly what's happening and how to stop it.

When this error shows up

This error pops up when a program uses the old x87 floating-point unit (FPU) instead of the newer SSE2 math. The program performs a calculation that produces an inexact result (like 1/3 = 0.33333...), and the FPU's exception mask isn't set properly. Windows sees the unhandled floating-point exception and kills the process with error 0XC000008F.

Common triggers:

• Launching a game compiled with DirectX 9 or earlier on Windows 10/11
• Running a legacy Visual Basic 6 app
• Starting a Fortran or Delphi program that uses heavy math
• Any software compiled without the /fp:precise flag in Visual Studio

Root cause in plain English

Back in the day, x87 chips handled floating-point math. Windows would mask floating-point exceptions by default, so the program wouldn't crash. Modern Windows expects programs to use SSE2 math (which handles precision differently). When an old program still uses x87 but the exception mask is missing or reset, the OS doesn't know what to do with the inexact result, so it throws STATUS_FLOAT_INEXACT_RESULT. The real fix is to either force the program to use SSE2, or re-enable the exception mask in the x87 control word.

Step-by-step fix

You've got three possible fixes. Try them in order. They won't break your system, but test one at a time.

Fix 1: Disable floating-point exceptions globally

This is the quickest. It tells Windows to ignore all floating-point exceptions.

1. Press the Windows key, type "Edit environment variables for your account" and open it.
2. In the System Variables section, click New.
3. For Variable name, type: _NO_DEBUG_HEAP
4. For Variable value, type: 1
5. Click OK.
6. Click New again.
7. Variable name: FP_EXCEPTIONS_DISABLE
8. Variable value: 1
9. Click OK in all dialogs.
10. Restart your computer.

After reboot, try launching the app. If it works, you're done. If not, remove those variables and try the next fix.

Fix 2: Use compatibility mode for the specific program

This forces the program to run in an older Windows environment that masks these exceptions.

1. Right-click the program's .exe file (or shortcut).
2. Select Properties.
3. Go to the Compatibility tab.
4. Check Run this program in compatibility mode for.
5. From the dropdown, pick Windows 7 (or Windows XP SP3 if the app is really old).
6. Also check Disable fullscreen optimizations (helps with old games).
7. Click Apply then OK.
8. Launch the program again.

If the crash stops, leave those settings on. If not, remove compatibility mode and try Fix 3.

Fix 3: Patch the program with a floating-point exception handler

This is the most technical fix. You'll use a small tool to inject an exception handler into the program at startup.

1. Download SetX86FPPrecision from the Microsoft Sysinternals archive. (Search "SetX86FPPrecision"—it's a small command-line tool.)
2. Extract it to a folder, like C:\Tools\.
3. Open Command Prompt as Administrator.
4. Navigate to that folder: cd C:\Tools
5. Type: setx86fpprecision.exe /mxcsr=0x1F80 /cw=0x027F and press Enter.
6. You should see "Set FP control word to 0x027F, MXCSR to 0x1F80".
7. Now launch your problem program from the same Command Prompt window.

What this does: It sets the x87 control word and MXCSR register to mask all floating-point exceptions, including inexact results. The program inherits these settings. If it works, you can create a batch file to do this every time you run the app.

@echo off
setx86fpprecision.exe /mxcsr=0x1F80 /cw=0x027F
start "" "C:\Path\To\YourApp.exe"

If it still fails

If none of these fixes work, you're dealing with a program that explicitly changes its own FPU control word or runs in a sandbox that blocks these tweaks. Here's what to check:

• Is the program 64-bit? The x87 FPU is largely replaced by SSE2 on 64-bit Windows, but some 64-bit apps can still crash if they use _controlfp incorrectly. Try recompiling with /arch:SSE2 if you have the source code.
• Are you running an antivirus that hooks math operations? Temporarily disable real-time protection (don't keep it off) and test. I've seen Bitdefender and Kaspersky intercept floating-point calls and cause this error.
• Update your graphics drivers. Old GPU drivers can mess with DirectX floating-point state. Download the latest driver from NVIDIA, AMD, or Intel.
• Check the program's developer notes. Some legacy apps require a specific runtime, like Visual C++ 2005 Redistributable. Install the right one.

If you still see 0XC000008F after all this, the app is likely incompatible with modern Windows. Your best bet is to run it in a virtual machine with Windows XP or use a tool like Windows Application Compatibility Toolkit to create a custom shim (that's an advanced topic, but it can override FPU behavior at the OS level).