STATUS_WX86_FLOAT_STACK_CHECK 0xC0000270 Fix

That division-by-zero style crash from your old 32-bit app? The x86 emulator's float stack got corrupted. Here's the real fix list, starting with the WOW64 settings.

I know this one's infuriating — you double-click a perfectly good 32-bit app and Windows throws 0xC0000270 in your face like it's your fault the app was compiled in 2004.

Here's the short version: the WOW64 (Windows 32-bit on Windows 64-bit) emulation layer watches your app's x87 floating-point register stack, and if the app leaves too many values on that stack — or pops more than it pushed — the emulator kills the process. That's STATUS_WX86_FLOAT_STACK_CHECK. It's not a Windows bug. It's your app doing something the x87 spec technically allowed in 1998 and the emulator now refuses to tolerate.

The fix that works 80% of the time

Before you touch anything else, try running the app with the x87 exception handling turned down. The emulator's default behavior is aggressive; you can relax it per-application.

Right-click the .exe and choose Properties.
Go to the Compatibility tab.
Click Change high DPI settings… no, wait, that's not it. Click Run compatibility troubleshooter first, then back out and use the manual path below.

Actually, skip the troubleshooter. It rarely helps with 0xC0000270. Do this instead:

Open an elevated Command Prompt and run:

reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers" /v "C:\Path\To\YourApp.exe" /t REG_SZ /d "~ WINXPSP3 DISABLEDXMAXIMIZEDWINDOWS" /f

Replace the path with your actual executable. That forces Windows to run the app in Windows XP SP3 compatibility mode, which uses a much more permissive x87 emulation path. For most legacy CAD tools, audio editors, and old financial software, this alone stops the crash.

If that doesn't work, you need to attack the DEP side. Data Execution Prevention will sometimes interpret the emulator's stack-check trampoline as a buffer overflow attempt.

bcdedit /set nx OptIn

Reboot after that. Then, if you're still crashing, exclude the app from DEP entirely:

System Properties → Advanced → Performance Settings → Data Execution Prevention.
Select Turn on DEP for all programs and services except those I select.
Add your .exe to the exclusion list.
Reboot.

I've seen this fix a 12-year-old PCB layout tool that crashed every time it opened a drill file. The developer was long gone, but the DEP exclusion gave the user another five years with it.

Why this actually works

The x87 FPU has an 8-register stack. Real hardware tolerates a lot of sloppy behavior — you can push eight values, push a ninth, and the chip just wraps around and sets a flag. The WOW64 emulator doesn't wrap. It checks the stack pointer after every x87 instruction, and if the pointer is outside the valid range, it raises STATUS_WX86_FLOAT_STACK_CHECK and terminates the thread.

Windows XP SP3 compatibility mode flips the emulator into a legacy path that mirrors the old hardware behavior. DEP exclusion stops the security layer from interfering with that legacy path. Together they reproduce the environment the app was written for.

Less common variations

Windows on ARM (Snapdragon X, Surface Pro X)

On ARM64 Windows 11, the x86 emulation is completely different — it's Microsoft's xtajit64.dll translation layer, not WOW64. The same error surfaces but the fix is different. Update to the latest Windows 11 23H2 cumulative update, then disable the Hardware-enforced Stack Protection setting under Windows Security → Device Security → Core isolation. That feature conflicts with older x87 translation. Also check that your app isn't in the ARM64EC compatibility list — some apps run better under pure x86 emulation.

Apps calling __control87_2 incorrectly

If you have the source code and this crash happens right after a call into a math library, your code is probably using __control87_2 wrong. It sets both the x87 and SSE2 control words, and on WOW64 the two get out of sync. Kill the SSE2 half:

unsigned int x87cw, sse2cw;
__control87_2(_PC_53, _MCW_PC, &x87cw, &sse2cw);

Then check that sse2cw matches x87cw. If it doesn't, your code's been silently corrupting the float stack for years and only crashes on emulated environments.

Third-party DLL injection

Screen readers, RGB lighting software, and old antivirus hooks all inject DLLs into 32-bit processes. If one of those DLLs does its own x87 math and doesn't clean up, your app takes the fall. Check with Process Explorer — sort by the .dll list in the lower pane of your process, and if you see anything from Corsair, Razer, or a security vendor, temporarily disable it and retest.

Prevention

Recompile with /fp:strict or /fp:precise. If you own the source, this is the real fix. Modern MSVC (2019+) produces code that plays nice with WOW64.
Test on Windows 11, not just Windows 10. Microsoft tightened the x86 emulator checks in 22H2. An app that worked on Win10 can start throwing 0xC0000270 after the upgrade.
Keep the compatibility shim in a deployment script. If you roll this out to a team, push the AppCompatFlags\Layers registry key via Group Policy instead of walking each user through it.
Watch for the crash after Windows updates. Every Patch Tuesday that touches wow64.dll has a chance of re-breaking legacy apps. Snapshot before updates on machines that depend on them.

And if nothing above works, isolate the process. Run the app inside a Windows XP virtual machine. It's not elegant, but for a piece of software whose vendor disappeared a decade ago, it's often the fastest path back to getting work done.