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,
         }
     }
 
@@ -1115,7 +1118,10 @@ impl App {
     }
 
     /// Inserts a [`SubApp`] with the given label.
-    pub fn insert_sub_app(&mut self, label: impl AppLabel, sub_app: SubApp) {
+    pub fn insert_sub_app(&mut self, label: impl AppLabel, mut sub_app: SubApp) {
+        sub_app
+            .world_mut()
+            .set_default_error_handler(self.default_error_handler);
         self.sub_apps.sub_apps.insert(label.intern(), sub_app);
     }
 
@@ -1334,6 +1340,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

@@ -7,21 +7,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);
+        }
     }
 }
 
@@ -30,7 +33,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/error/mod.rs

@@ -8,8 +8,8 @@
 //! [`panic`] error handler function is used, resulting in a panic with the error message attached.
 //!
 //! You can change the default behavior by registering a custom error handler:
-//! Use [`set_global_default_error_handler`]
-//! to set a custom error handler function for your entire app.
+//! Use [`World::set_default_error_handler`] to set a custom error handler function for a world,
+//! or `App::set_error_handler` for a whole app.
 //! In practice, this is generally feature-flagged: panicking or loudly logging errors in development,
 //! and quietly logging or ignoring them in production to avoid crashing the app.
 //!
@@ -35,7 +35,7 @@
 //! context surrounding the error – such as the system's [`name`] – in your error messages.
 //!
 //! ```rust, ignore
-//! use bevy_ecs::error::{set_global_default_error_handler, BevyError, ErrorContext};
+//! use bevy_ecs::error::{BevyError, ErrorContext};
 //! use log::trace;
 //!
 //! fn my_error_handler(error: BevyError, ctx: ErrorContext) {
@@ -47,9 +47,9 @@
 //! }
 //!
 //! fn main() {
-//!     set_global_default_error_handler(my_error_handler);
-//!     
-//!     // Initialize your Bevy App here
+//!     let mut world = World::new();
+//!     world.set_default_error_handler(my_error_handler);
+//!     …
 //! }
 //! ```
 //!

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,
@@ -232,14 +232,15 @@ impl Observer {
             system: Box::new(|| {}),
             descriptor: Default::default(),
             hook_on_add: |mut world, hook_context| {
+                let default_error_handler = world.default_error_handler;
                 world.commands().queue(move |world: &mut World| {
                     let entity = hook_context.entity;
                     if let Some(mut observe) = world.get_mut::<Observer>(entity) {
                         if observe.descriptor.events.is_empty() {
                             return;
                         }
                         if observe.error_handler.is_none() {
-                            observe.error_handler = Some(default_error_handler());
+                            observe.error_handler = Some(default_error_handler);
                         }
                         world.register_observer(entity);
                     }
@@ -420,12 +421,13 @@ fn hook_on_add<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
         B::component_ids(&mut world.components_registrator(), &mut |id| {
             components.push(id);
         });
+        let default_error_handler = world.default_error_handler;
         if let Some(mut observe) = world.get_mut::<Observer>(entity) {
             observe.descriptor.events.push(event_id);
             observe.descriptor.components.extend(components);
 
             if observe.error_handler.is_none() {
-                observe.error_handler = Some(default_error_handler());
+                observe.error_handler = Some(default_error_handler);
             }
             let system: *mut dyn ObserverSystem<E, B> = observe.system.downcast_mut::<S>().unwrap();
             // SAFETY: World reference is exclusive and initialize does not touch system, so references do not alias

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

@@ -13,7 +13,7 @@ use std::sync::{Mutex, MutexGuard};
 use tracing::{info_span, Span};
 
 use crate::{
-    error::{default_error_handler, BevyError, ErrorContext, Result},
+    error::{ErrorContext, ErrorHandler, Result},
     prelude::Resource,
     schedule::{is_apply_deferred, BoxedCondition, ExecutorKind, SystemExecutor, SystemSchedule},
     system::ScheduleSystem,
@@ -134,7 +134,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 {
@@ -240,7 +240,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
@@ -586,7 +586,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) {
@@ -635,7 +634,7 @@ impl ExecutorState {
                 Ok(()) => true,
                 Err(e) => {
                     if !e.skipped {
-                        error_handler(
+                        world.default_error_handler()(
                             e.into(),
                             ErrorContext::System {
                                 name: system.name(),
@@ -823,8 +822,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."
@@ -840,7 +837,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

@@ -10,7 +10,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,
     },
@@ -50,7 +50,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.
@@ -176,8 +176,6 @@ impl SimpleExecutor {
     note = "Use SingleThreadedExecutor instead. See https://github.com/bevyengine/bevy/issues/18453 for motivation."
 )]
 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."
@@ -189,7 +187,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(),