Does the Spyder kernel status indicator accurately reflect state after fatal script crashes?

Direct Answer

No, the Spyder kernel status indicator does not accurately reflect the state after a fatal script crash. In the event of a hard crash—such as a segmentation fault or a C-extension abort—the IPython kernel process terminates before it can transmit the final "idle" signal to the Spyder frontend. Consequently, the indicator remains stuck in the "Busy" state despite the backend being dead.

Explanation of State Transitions

The transition from "Busy" to "Idle" is not based on the frontend monitoring the process life cycle, but on explicit messaging via ZeroMQ (ZMQ) on the IOPub channel.

• Standard Flow: When a script finishes or raises a Python-level exception, the IPython shell catches the event and sends a status: idle message. The UI updates immediately.
• Fatal Crash: A crash at the C-level (e.g., a segfault) or a call to os._exit() bypasses Python's exception handlers and finally blocks. The kernel process vanishes without sending the required ZMQ message.
• Detection Delay: The frontend relies on a heartbeat mechanism to detect a lost connection. Until the heartbeat timeout is reached, the UI assumes the kernel is still processing a long-running task.

Comparison of Crash Behaviors

Crash Type	Indicator State	Mechanism
Python Exception	Returns to Idle	IPython catches error $\rightarrow$ sends idle signal.
C-Extension Segfault	Stays Busy	Process dies $\rightarrow$ no signal sent.
OS-level Termination	Stays Busy	Immediate exit $\rightarrow$ no signal sent.

Configuration and Verification

There is no configuration to force an instant status refresh upon a crash, as the frontend cannot know the kernel has died until a communication attempt fails. You can, however, adjust the detection latency:

• Heartbeat Adjustment: Navigate to Tools → Preferences → IPython Console → Advanced. Lowering the Heartbeat interval (default 30,000ms) will reduce the time it takes for the UI to transition from "Busy" to "Disconnected" or "Dead."

Verification Steps

1. Execute a standard RuntimeError; observe the indicator return to "Idle."
2. Execute a hard crash using ctypes to access a null pointer:

   import ctypes; ctypes.string_at(0)

3. Observe the indicator remain "Busy" even though the console is unresponsive.
4. Wait for the heartbeat timeout to see if the status changes to "Dead" (this behavior varies based on whether the kernel is configured as Inline or External).

Required Diagnostic Detail

Are you using an Inline or External kernel? This determines whether the frontend can detect the process death via a socket timeout or if it remains permanently "Busy" because the kernel shared the same process space.