When does RStudio's Stop button fail to interrupt a running computation?

The Short Answer

RStudio's Stop button (and the Esc key) fails whenever the R interpreter is blocked and cannot check its internal interrupt flag. This occurs primarily when execution is inside compiled native code (C, C++, or Fortran) that does not explicitly call R_CheckUserInterrupt(), or when the process is blocked by a synchronous system call (such as certain I/O or network operations) that prevents the R event loop from cycling.

Likely Explanations vs. Confirmed Behavior

Confirmed R Behavior

• The Interrupt Loop: R does not "kill" a thread instantly. Instead, the Stop button sets a flag. R checks this flag at specific intervals—usually between the execution of R-level expressions.
• Compiled Code Blockage: When you call a function via .Call() or .External(), control leaves the R interpreter. If that native function runs a long loop without manually checking the interrupt status, R cannot see the "Stop" request until the native function returns.
• System-Level Locks: Operations waiting on a kernel-level response (e.g., a hanging socket connection or a locked file system) may freeze the entire process, rendering the IDE's signals ineffective.

Assumptions on setTimeLimit()

It is a common assumption that setTimeLimit(elapsed = ...) provides a hard timeout. However, setTimeLimit relies on the same mechanism as the Stop button: it triggers an error when R checks the time. If the execution is trapped in a native C++ loop that doesn't check for interrupts, setTimeLimit will not fire until the native code returns control to R. It is not a preemptive "kill" signal.

Practical Verification

To verify if a specific package or function is "interrupt-safe," you can test it with a known non-interruptible pattern. If you use Rcpp, a loop like this will ignore the Stop button:

// Non-interruptible C++ loop
for(int i = 0; i < 1000000000; ++i) {
    // Do heavy work without R_CheckUserInterrupt()
}

Conversely, adding R_CheckUserInterrupt() inside the loop allows the Stop button to function.

Predicting Graceful Cancellation

Before launching a computation, you can gauge the risk based on these categories:

Operation Type	Interrupt Reliability	Risk
Pure R loops/apply	High	Low
Standard R packages (e.g., dplyr)	Medium-High	Low
Heavy Linear Algebra (BLAS/LAPACK)	Low	Medium
Custom C++/Fortran extensions	Variable	High (if not explicitly coded)

Missing Diagnostic: Are you running these computations on a local machine or via RStudio Server/Workbench? Network latency in remote sessions can sometimes mimic a frozen process even when the R kernel is technically responsive.