move default error handler to World

Author: SpecificProtagonist

crates/bevy_app/src/app.rs

@@ -10,6 +10,7 @@ use alloc::{
 pub use bevy_derive::AppLabel;
 use bevy_ecs::{
     component::RequiredComponentsError,
+    error::{panic, ErrorHandler},
     event::{event_update_system, EventCursor},
     intern::Interned,
     prelude::*,
@@ -85,6 +86,7 @@ pub struct App {
     /// [`WinitPlugin`]: https://docs.rs/bevy/latest/bevy/winit/struct.WinitPlugin.html
     /// [`ScheduleRunnerPlugin`]: https://docs.rs/bevy/latest/bevy/app/struct.ScheduleRunnerPlugin.html
     pub(crate) runner: RunnerFn,
+    default_error_handler: ErrorHandler,
 }
 
 impl Debug for App {
@@ -143,6 +145,7 @@ impl App {
                 sub_apps: HashMap::default(),
             },
             runner: Box::new(run_once),
+            default_error_handler: panic,
         }
     }
 
@@ -1334,6 +1337,34 @@ impl App {
         self.world_mut().add_observer(observer);
         self
     }
+
+    /// Gets the error handler to set for new supapps.
+    ///
+    /// Note that the error handler of existing subapps may differ.
+    pub fn get_error_handler(&self) -> ErrorHandler {
+        self.default_error_handler
+    }
+
+    /// Override the error handler for the all subapps (including the main one).
+    ///
+    /// This handler will be called when an error is produced and not otherwise handled.
+    ///
+    /// # Example
+    /// ```
+    /// # use bevy_app::*;
+    /// # use bevy_ecs::error::warn;
+    /// App::new()
+    ///     .set_error_handler(warn)
+    ///     .add_plugins(DefaultPlugins)
+    ///     .run()
+    /// ```
+    pub fn set_error_handler(&mut self, handler: ErrorHandler) -> &mut Self {
+        self.default_error_handler = handler;
+        for sub_app in self.sub_apps.iter_mut() {
+            sub_app.world_mut().set_default_error_handler(handler);
+        }
+        self
+    }
 }
 
 type RunnerFn = Box<dyn FnOnce(App) -> AppExit>;

crates/bevy_ecs/src/error/command_handling.rs

@@ -6,21 +6,24 @@ use crate::{
     world::{error::EntityMutableFetchError, World},
 };
 
-use super::{default_error_handler, BevyError, ErrorContext};
+use super::{BevyError, ErrorContext, ErrorHandler};
 
 /// Takes a [`Command`] that returns a Result and uses a given error handler function to convert it into
 /// a [`Command`] that internally handles an error if it occurs and returns `()`.
-pub trait HandleError<Out = ()> {
+pub trait HandleError<Out = ()>: Send + 'static {
     /// Takes a [`Command`] that returns a Result and uses a given error handler function to convert it into
     /// a [`Command`] that internally handles an error if it occurs and returns `()`.
-    fn handle_error_with(self, error_handler: fn(BevyError, ErrorContext)) -> impl Command;
+    fn handle_error_with(self, error_handler: ErrorHandler) -> impl Command;
     /// Takes a [`Command`] that returns a Result and uses the default error handler function to convert it into
     /// a [`Command`] that internally handles an error if it occurs and returns `()`.
     fn handle_error(self) -> impl Command
     where
         Self: Sized,
     {
-        self.handle_error_with(default_error_handler())
+        move |world: &mut World| {
+            self.handle_error_with(world.default_error_handler)
+                .apply(world);
+        }
     }
 }
 
@@ -29,7 +32,7 @@ where
     C: Command<Result<T, E>>,
     E: Into<BevyError>,
 {
-    fn handle_error_with(self, error_handler: fn(BevyError, ErrorContext)) -> impl Command {
+    fn handle_error_with(self, error_handler: ErrorHandler) -> impl Command {
         move |world: &mut World| match self.apply(world) {
             Ok(_) => {}
             Err(err) => (error_handler)(

crates/bevy_ecs/src/error/handler.rs

@@ -75,83 +75,6 @@ impl ErrorContext {
     }
 }
 
-mod global_error_handler {
-    use super::{panic, BevyError, ErrorContext};
-    use bevy_platform_support::sync::atomic::{
-        AtomicBool, AtomicPtr,
-        Ordering::{AcqRel, Acquire, Relaxed},
-    };
-
-    /// The default global error handler, cast to a data pointer as Rust doesn't
-    /// currently have a way to express atomic function pointers.
-    /// Should we add support for a platform on which function pointers and data pointers
-    /// have different sizes, the transmutation back will fail to compile. In that case,
-    /// we can replace the atomic pointer with a regular pointer protected by a `OnceLock`
-    /// on only those platforms.
-    /// SAFETY: Only accessible from within this module.
-    static HANDLER: AtomicPtr<()> = AtomicPtr::new(panic as *mut ());
-
-    /// Set the global error handler.
-    ///
-    /// If used, this should be called [before] any uses of [`default_error_handler`],
-    /// generally inside your `main` function before initializing the app.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use bevy_ecs::error::{set_global_default_error_handler, warn};
-    /// set_global_default_error_handler(warn);
-    /// // initialize Bevy App here
-    /// ```
-    ///
-    /// To use this error handler in your app for custom error handling logic:
-    ///
-    /// ```rust
-    /// use bevy_ecs::error::{default_error_handler, BevyError, ErrorContext};
-    ///
-    /// fn handle_errors(error: BevyError, ctx: ErrorContext) {
-    ///    let error_handler = default_error_handler();
-    ///    error_handler(error, ctx);        
-    /// }
-    /// ```
-    ///
-    /// # Warning
-    ///
-    /// As this can *never* be overwritten, library code should never set this value.
-    ///
-    /// [before]: https://doc.rust-lang.org/nightly/core/sync/atomic/index.html#memory-model-for-atomic-accesses
-    /// [`default_error_handler`]: super::default_error_handler
-    pub fn set_global_default_error_handler(handler: fn(BevyError, ErrorContext)) {
-        // Prevent the handler from being set multiple times.
-        // We use a separate atomic instead of trying `compare_exchange` on `HANDLER_ADDRESS`
-        // because Rust doesn't guarantee that function addresses are unique.
-        static INITIALIZED: AtomicBool = AtomicBool::new(false);
-        if INITIALIZED
-            .compare_exchange(false, true, AcqRel, Acquire)
-            .is_err()
-        {
-            panic!("Global error handler set multiple times");
-        }
-        HANDLER.store(handler as *mut (), Relaxed);
-    }
-
-    /// The default error handler. This defaults to [`panic`],
-    /// but you can override this behavior via [`set_global_default_error_handler`].
-    ///
-    /// [`panic`]: super::panic
-    #[inline]
-    pub fn default_error_handler() -> fn(BevyError, ErrorContext) {
-        // The error handler must have been already set from the perspective of this thread,
-        // otherwise we will panic. It will never be updated after this point.
-        // We therefore only need a relaxed load.
-        let ptr = HANDLER.load(Relaxed);
-        // SAFETY: We only ever store valid handler functions.
-        unsafe { core::mem::transmute(ptr) }
-    }
-}
-
-pub use global_error_handler::{default_error_handler, set_global_default_error_handler};
-
 macro_rules! inner {
     ($call:path, $e:ident, $c:ident) => {
         $call!(
@@ -163,6 +86,9 @@ macro_rules! inner {
     };
 }
 
+/// Defines how Bevy reacts to errors.
+pub type ErrorHandler = fn(BevyError, ErrorContext);
+
 /// Error handler that panics with the system error.
 #[track_caller]
 #[inline]

crates/bevy_ecs/src/observer/runner.rs

@@ -3,7 +3,7 @@ use core::any::Any;
 
 use crate::{
     component::{ComponentHook, ComponentId, HookContext, Mutable, StorageType},
-    error::{default_error_handler, ErrorContext},
+    error::ErrorContext,
     observer::{ObserverDescriptor, ObserverTrigger},
     prelude::*,
     query::DebugCheckedUnwrap,
@@ -458,14 +458,14 @@ fn hook_on_add<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
             ..Default::default()
         };
 
-        let error_handler = default_error_handler();
+        let default_error_handler = world.default_error_handler;
 
         // Initialize System
         let system: *mut dyn ObserverSystem<E, B> =
             if let Some(mut observe) = world.get_mut::<Observer>(entity) {
                 descriptor.merge(&observe.descriptor);
                 if observe.error_handler.is_none() {
-                    observe.error_handler = Some(error_handler);
+                    observe.error_handler = Some(default_error_handler);
                 }
                 let system = observe.system.downcast_mut::<S>().unwrap();
                 &mut *system

crates/bevy_ecs/src/schedule/executor/multi_threaded.rs

@@ -14,7 +14,7 @@ use tracing::{info_span, Span};
 
 use crate::{
     archetype::ArchetypeComponentId,
-    error::{default_error_handler, BevyError, ErrorContext, Result},
+    error::{ErrorContext, ErrorHandler, Result},
     prelude::Resource,
     query::Access,
     schedule::{is_apply_deferred, BoxedCondition, ExecutorKind, SystemExecutor, SystemSchedule},
@@ -131,7 +131,7 @@ pub struct ExecutorState {
 struct Context<'scope, 'env, 'sys> {
     environment: &'env Environment<'env, 'sys>,
     scope: &'scope Scope<'scope, 'env, ()>,
-    error_handler: fn(BevyError, ErrorContext),
+    error_handler: ErrorHandler,
 }
 
 impl Default for MultiThreadedExecutor {
@@ -182,7 +182,7 @@ impl SystemExecutor for MultiThreadedExecutor {
         schedule: &mut SystemSchedule,
         world: &mut World,
         _skip_systems: Option<&FixedBitSet>,
-        error_handler: fn(BevyError, ErrorContext),
+        error_handler: ErrorHandler,
     ) {
         let state = self.state.get_mut().unwrap();
         // reset counts
@@ -538,7 +538,6 @@ impl ExecutorState {
         world: UnsafeWorldCell,
     ) -> bool {
         let mut should_run = !self.skipped_systems.contains(system_index);
-        let error_handler = default_error_handler();
 
         for set_idx in conditions.sets_with_conditions_of_systems[system_index].ones() {
             if self.evaluated_sets.contains(set_idx) {
@@ -587,7 +586,7 @@ impl ExecutorState {
                 Ok(()) => true,
                 Err(e) => {
                     if !e.skipped {
-                        error_handler(
+                        world.default_error_handler()(
                             e.into(),
                             ErrorContext::System {
                                 name: system.name(),
@@ -787,8 +786,6 @@ unsafe fn evaluate_and_fold_conditions(
     conditions: &mut [BoxedCondition],
     world: UnsafeWorldCell,
 ) -> bool {
-    let error_handler = default_error_handler();
-
     #[expect(
         clippy::unnecessary_fold,
         reason = "Short-circuiting here would prevent conditions from mutating their own state as needed."
@@ -804,7 +801,7 @@ unsafe fn evaluate_and_fold_conditions(
                 Ok(()) => (),
                 Err(e) => {
                     if !e.skipped {
-                        error_handler(
+                        world.default_error_handler()(
                             e.into(),
                             ErrorContext::System {
                                 name: condition.name(),

crates/bevy_ecs/src/schedule/executor/simple.rs

@@ -8,7 +8,7 @@ use tracing::info_span;
 use std::eprintln;
 
 use crate::{
-    error::{default_error_handler, BevyError, ErrorContext},
+    error::{ErrorContext, ErrorHandler},
     schedule::{
         executor::is_apply_deferred, BoxedCondition, ExecutorKind, SystemExecutor, SystemSchedule,
     },
@@ -44,7 +44,7 @@ impl SystemExecutor for SimpleExecutor {
         schedule: &mut SystemSchedule,
         world: &mut World,
         _skip_systems: Option<&FixedBitSet>,
-        error_handler: fn(BevyError, ErrorContext),
+        error_handler: ErrorHandler,
     ) {
         // If stepping is enabled, make sure we skip those systems that should
         // not be run.
@@ -167,8 +167,6 @@ impl SimpleExecutor {
 }
 
 fn evaluate_and_fold_conditions(conditions: &mut [BoxedCondition], world: &mut World) -> bool {
-    let error_handler = default_error_handler();
-
     #[expect(
         clippy::unnecessary_fold,
         reason = "Short-circuiting here would prevent conditions from mutating their own state as needed."
@@ -180,7 +178,7 @@ fn evaluate_and_fold_conditions(conditions: &mut [BoxedCondition], world: &mut W
                 Ok(()) => (),
                 Err(e) => {
                     if !e.skipped {
-                        error_handler(
+                        world.default_error_handler()(
                             e.into(),
                             ErrorContext::System {
                                 name: condition.name(),

crates/bevy_ecs/src/schedule/executor/single_threaded.rs

@@ -8,7 +8,7 @@ use tracing::info_span;
 use std::eprintln;
 
 use crate::{
-    error::{default_error_handler, BevyError, ErrorContext},
+    error::{ErrorContext, ErrorHandler},
     schedule::{is_apply_deferred, BoxedCondition, ExecutorKind, SystemExecutor, SystemSchedule},
     world::World,
 };
@@ -50,7 +50,7 @@ impl SystemExecutor for SingleThreadedExecutor {
         schedule: &mut SystemSchedule,
         world: &mut World,
         _skip_systems: Option<&FixedBitSet>,
-        error_handler: fn(BevyError, ErrorContext),
+        error_handler: ErrorHandler,
     ) {
         // If stepping is enabled, make sure we skip those systems that should
         // not be run.
@@ -211,8 +211,6 @@ impl SingleThreadedExecutor {
 }
 
 fn evaluate_and_fold_conditions(conditions: &mut [BoxedCondition], world: &mut World) -> bool {
-    let error_handler: fn(BevyError, ErrorContext) = default_error_handler();
-
     #[expect(
         clippy::unnecessary_fold,
         reason = "Short-circuiting here would prevent conditions from mutating their own state as needed."
@@ -224,7 +222,7 @@ fn evaluate_and_fold_conditions(conditions: &mut [BoxedCondition], world: &mut W
                 Ok(()) => (),
                 Err(e) => {
                     if !e.skipped {
-                        error_handler(
+                        world.default_error_handler()(
                             e.into(),
                             ErrorContext::System {
                                 name: condition.name(),

crates/bevy_ecs/src/schedule/schedule.rs

@@ -27,7 +27,6 @@ use tracing::info_span;
 
 use crate::{
     component::{ComponentId, Components, Tick},
-    error::default_error_handler,
     prelude::Component,
     resource::Resource,
     schedule::*,
@@ -441,7 +440,7 @@ impl Schedule {
         self.initialize(world)
             .unwrap_or_else(|e| panic!("Error when initializing schedule {:?}: {e}", self.label));
 
-        let error_handler = default_error_handler();
+        let error_handler = world.default_error_handler();
 
         #[cfg(not(feature = "bevy_debug_stepping"))]
         self.executor