NaN values in PyTorch models often act as silent killers, corrupting training without raising immediate errors. A common debugging approach using torch.autograd.set_detect_anomaly often fails to pinpoint the root cause and imposes severe performance penalties. In response, a new open-source tool called PyTorch NaN Detector offers a lightweight alternative using forward hooks to catch these errors in approximately 3 milliseconds per batch. Traditional anomaly detection retains the full computation graph and forces synchronous execution, which disrupts the asynchronous nature of GPU operations. This results in overhead ranging from 10 to 15 times on CPU and up to 100 times on GPU, making it impractical for large-scale training. Furthermore, this method typically identifies where a NaN propagates during the backward pass rather than the layer where it originated. In a complex network, a NaN generated early can lead to misleading error messages in much later layers, forcing developers to debug the wrong components. The proposed solution utilizes PyTorch's register_forward_hook API to inspect tensors after every module's forward pass. This approach avoids reconstructing the computation graph, requiring only a simple check for infinite or NaN values. The tool adds a negligible overhead of roughly 3 to 4 milliseconds, even when monitoring multiple layers simultaneously. It structures detected events with metadata including the batch index, layer name, and statistical summaries of the output, facilitating precise post-mortem analysis. Key features include thread-safe registration to handle multi-worker data loaders, bounded memory usage to prevent leaks during long runs, and a gradient norm guard. The gradient check monitors parameters immediately after the backward pass, detecting exploding gradients before they propagate into NaNs during the next forward step. This allows for early intervention, often catching instability one full training step before activations become invalid. The implementation supports various usage modes. Developers can wrap standard training loops with a context manager to enable real-time monitoring. For production environments, a drop-in training function provides robust integration. Advanced usage includes backward hooks to catch gradient-specific issues and ordered sequential definitions to ensure readable layer names in logs. Users can also skip specific layer types known to produce non-finite values under normal conditions, such as dropout layers during evaluation. While effective, the tool is a monitoring aid rather than a fix for underlying code issues. It does not replace standard practices like gradient clipping, careful learning rate scheduling, or proper initialization. Limitations include the inability to detect NaNs originating within custom C++ extensions or specific backward pass implementations unless backward hooks are explicitly enabled. Overhead may also accumulate slightly in very deep models, though this remains manageable by excluding non-parametric layers from monitoring. The tool, along with benchmarks and source code, is available on GitHub. It is designed to minimize training disruption while providing developers with the necessary data to identify and resolve numerical instability efficiently. The benchmark data, derived from CPU tests on multi-layer perceptrons, confirms the significant speed advantage over native anomaly detection, particularly as model complexity grows.