From 844524b429ad0abba77c631e22400aebf5397617 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 12:39:50 -0500
Subject: [PATCH 001/113] Basic functionality

---
 crates/bevy_ecs/src/system/mod.rs             |   2 +
 crates/bevy_ecs/src/system/system_registry.rs | 111 ++++++++++++++++++
 2 files changed, 113 insertions(+)
 create mode 100644 crates/bevy_ecs/src/system/system_registry.rs

diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs
index 051795fd566eb..4b077855b46d1 100644
--- a/crates/bevy_ecs/src/system/mod.rs
+++ b/crates/bevy_ecs/src/system/mod.rs
@@ -112,6 +112,7 @@ mod query;
 #[allow(clippy::module_inception)]
 mod system;
 mod system_param;
+mod system_registry;
 
 use std::borrow::Cow;
 
@@ -124,6 +125,7 @@ pub use function_system::*;
 pub use query::*;
 pub use system::*;
 pub use system_param::*;
+pub use system_registry::*;
 
 use crate::world::World;
 
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
new file mode 100644
index 0000000000000..c616b51a9aea7
--- /dev/null
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -0,0 +1,111 @@
+use bevy_utils::HashMap;
+use std::any::{Any, TypeId};
+
+use crate::system::{IntoSystem, System};
+use crate::world::{Mut, World};
+
+/// A [`System`] that cannot be chained.
+///
+/// [`BoxedSystem`](crate::system::BoxedSystem) is the equivalent type alias for arbitrary `In` and `Out` types.
+pub type UnchainedSystem = Box<dyn System<In = (), Out = ()>>;
+
+/// Stores initialized [`Systems`](crate::system::System), so they can quickly be reused and run
+///
+/// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
+#[derive(Default)]
+pub struct SystemRegistry {
+    systems: HashMap<TypeId, UnchainedSystem>,
+}
+
+// User-facing methods
+impl SystemRegistry {
+    /// Runs the supplied system on the [`World`] a single time
+    ///
+    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
+    pub fn run<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        world: &mut World,
+        system: S,
+    ) {
+        // If the system is already registered and initialized, use it
+        if let Some(initialized_system) = self.systems.get_mut(&system.type_id()) {
+            initialized_system.run((), world);
+            initialized_system.apply_buffers(world);
+        // Otherwise, register and initialize it first.
+        } else {
+            let initialized_system = self.register(world, system);
+            initialized_system.run((), world);
+            initialized_system.apply_buffers(world);
+        }
+    }
+
+    /// Runs the supplied system on the [`World`] a single time, without flushing [`Commands`](crate::system::Commands)
+    #[inline]
+    pub fn run_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        world: &mut World,
+        system: S,
+    ) {
+        // If the system is already registered and initialized, use it
+        if let Some(initialized_system) = self.systems.get_mut(&system.type_id()) {
+            initialized_system.run((), world);
+        // Otherwise, register and initialize it first.
+        } else {
+            let initialized_system = self.register(world, system);
+            initialized_system.run((), world);
+        }
+    }
+}
+
+// Internals
+impl SystemRegistry {
+    #[inline]
+    fn register<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        world: &mut World,
+        system: S,
+    ) -> &mut UnchainedSystem {
+        let label = system.type_id();
+
+        let mut unchained_system: UnchainedSystem = Box::new(IntoSystem::into_system(system));
+        unchained_system.initialize(world);
+
+        self.systems.insert(label, unchained_system);
+        self.systems.get_mut(&label).unwrap()
+    }
+}
+
+impl World {
+    /// Runs the supplied system on the [`World`] a single time
+    ///
+    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
+    ///
+    /// The system's state will be cached: any future calls using the same type will use this state,
+    /// improving performance and ensuring that change detection works properly.
+    ///
+    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
+    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
+    /// at once, and want parallel execution of these systems.
+    pub fn run<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run(world, system);
+        });
+    }
+
+    /// Runs the supplied system on the [`World`] a single time, wihthout flushing [`Commands`](crate::system::Commands)
+    ///
+    /// The system's state will be cached: any future calls using the same type will use this state,
+    /// improving performance and ensuring that change detection works properly.
+    ///
+    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
+    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
+    /// at once, and want parallel execution of these systems.
+    pub fn run_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        system: S,
+    ) {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_without_flushing(world, system);
+        });
+    }
+}

From c8ddefda93271e5dcc36cd2a9a28bff722466270 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 13:11:08 -0500
Subject: [PATCH 002/113] commands.run_system

---
 crates/bevy_ecs/src/system/commands/mod.rs    | 26 ++++++++-
 crates/bevy_ecs/src/system/system_registry.rs | 56 ++++++++++++++++---
 2 files changed, 73 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 3c404a551c97e..d1a1388a05a60 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,7 +5,8 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    world::{EntityMut, FromWorld, World},
+    system::{IntoSystem, RunSystemCommand},
+    world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
 use bevy_utils::tracing::{error, info};
@@ -519,11 +520,32 @@ impl<'w, 's> Commands<'w, 's> {
         self.queue.push(RemoveResource::<R>::new());
     }
 
+    /// Calls [`World::run_system`] once [`Commands`] are flushed
+    pub fn run_system<
+        Params: Send + Sync + 'static,
+        S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+    >(
+        &mut self,
+        system: S,
+    ) {
+        self.queue.push(RunSystemCommand::new(system, true));
+    }
+
+    /// Calls [`World::run_system_without_flushing`] once [`Commands`] are flushed
+    pub fn run_system_without_flushing<
+        Params: Send + Sync + 'static,
+        S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+    >(
+        &mut self,
+        system: S,
+    ) {
+        self.queue.push(RunSystemCommand::new(system, false));
+    }
+
     /// Pushes a generic [`Command`] to the command queue.
     ///
     /// `command` can be a built-in command, custom struct that implements [`Command`] or a closure
     /// that takes [`&mut World`](World) as an argument.
-    ///
     /// # Example
     ///
     /// ```
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index c616b51a9aea7..9c7a23c2a8e37 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,7 +1,8 @@
 use bevy_utils::HashMap;
 use std::any::{Any, TypeId};
+use std::marker::PhantomData;
 
-use crate::system::{IntoSystem, System};
+use crate::system::{Command, IntoSystem, System};
 use crate::world::{Mut, World};
 
 /// A [`System`] that cannot be chained.
@@ -22,7 +23,7 @@ impl SystemRegistry {
     /// Runs the supplied system on the [`World`] a single time
     ///
     /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
-    pub fn run<Params, S: IntoSystem<(), (), Params> + 'static>(
+    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
@@ -41,7 +42,7 @@ impl SystemRegistry {
 
     /// Runs the supplied system on the [`World`] a single time, without flushing [`Commands`](crate::system::Commands)
     #[inline]
-    pub fn run_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
+    pub fn run_system_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
@@ -86,9 +87,10 @@ impl World {
     /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
-    pub fn run<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
+    #[inline]
+    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run(world, system);
+            registry.run_system(world, system);
         });
     }
 
@@ -100,12 +102,52 @@ impl World {
     /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
-    pub fn run_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
+    #[inline]
+    pub fn run_system_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         system: S,
     ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_without_flushing(world, system);
+            registry.run_system_without_flushing(world, system);
         });
     }
 }
+
+/// The [`Command`] type for [`SystemRegistry`] [`Commands`]
+#[derive(Debug, Clone)]
+pub struct RunSystemCommand<
+    Params: Send + Sync + 'static,
+    S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+> {
+    _phantom_params: PhantomData<Params>,
+    system: S,
+    flush: bool,
+}
+
+impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static>
+    RunSystemCommand<Params, S>
+{
+    /// Creates a new [`Command`] struct, which can be addeded to [`Commands`]
+    #[inline]
+    #[must_use]
+    pub fn new(system: S, flush: bool) -> Self {
+        Self {
+            _phantom_params: PhantomData::default(),
+            system,
+            flush,
+        }
+    }
+}
+
+impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static> Command
+    for RunSystemCommand<Params, S>
+{
+    #[inline]
+    fn write(self, world: &mut World) {
+        if self.flush {
+            world.run_system(self.system);
+        } else {
+            world.run_system_without_flushing(self.system);
+        }
+    }
+}

From 945c81f81d4467956e7f265550d3224ea1ea3d2a Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 13:13:04 -0500
Subject: [PATCH 003/113] Add SystemRegistry resource as part of CorePlugin

No plugin exists for bevy_ecs, so this was the best place.
---
 crates/bevy_core/src/lib.rs                   | 35 +++++++++++++++----
 crates/bevy_ecs/src/system/system_registry.rs |  2 +-
 2 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 977f01489f286..ae6c8d600badc 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -21,12 +21,12 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::prelude::*;
-use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
-use bevy_utils::{Duration, HashSet, Instant};
-use std::borrow::Cow;
-use std::ffi::OsString;
-use std::marker::PhantomData;
+use bevy_ecs::{
+    entity::Entity,
+    schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
+    system::{IntoExclusiveSystem, SystemRegistry},
+};
+use bevy_utils::HashSet;
 use std::ops::Range;
 use std::path::{Path, PathBuf};
 
@@ -40,7 +40,28 @@ pub struct TypeRegistrationPlugin;
 
 impl Plugin for TypeRegistrationPlugin {
     fn build(&self, app: &mut App) {
-        app.register_type::<Entity>().register_type::<Name>();
+        // Setup the default bevy task pools
+        app.world
+            .get_resource::<DefaultTaskPoolOptions>()
+            .cloned()
+            .unwrap_or_default()
+            .create_default_pools(&mut app.world);
+
+        app.init_resource::<Time>()
+            .init_resource::<FixedTimesteps>()
+            .init_resource::<SystemRegistry>()
+            .register_type::<HashSet<String>>()
+            .register_type::<Option<String>>()
+            .register_type::<Entity>()
+            .register_type::<Name>()
+            .register_type::<Range<f32>>()
+            .register_type::<Timer>()
+            // time system is added as an "exclusive system" to ensure it runs before other systems
+            // in CoreStage::First
+            .add_system_to_stage(
+                CoreStage::First,
+                time_system.exclusive_system().label(CoreSystem::Time),
+            );
 
         register_rust_types(app);
         register_math_types(app);
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 9c7a23c2a8e37..fbce6c2757b06 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -143,7 +143,7 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
     for RunSystemCommand<Params, S>
 {
     #[inline]
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         if self.flush {
             world.run_system(self.system);
         } else {

From 655bf2eecc67beb5e09f71b7696677edb333a591 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 14:07:20 -0500
Subject: [PATCH 004/113] Run system by TypeId

---
 crates/bevy_ecs/src/system/system_registry.rs | 82 ++++++++++---------
 1 file changed, 43 insertions(+), 39 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index fbce6c2757b06..b39c179ade13c 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -12,6 +12,9 @@ pub type UnchainedSystem = Box<dyn System<In = (), Out = ()>>;
 
 /// Stores initialized [`Systems`](crate::system::System), so they can quickly be reused and run
 ///
+/// Systems are keyed by their [`TypeId`]: repeated calls with the same function type will reuse cached state,
+/// including for change detection.
+///
 /// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
 #[derive(Default)]
 pub struct SystemRegistry {
@@ -20,59 +23,60 @@ pub struct SystemRegistry {
 
 // User-facing methods
 impl SystemRegistry {
-    /// Runs the supplied system on the [`World`] a single time
+    /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
-    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
-    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+    /// This only needs to be called manually whenn using [`run_system_by_type_id`](SystemRegistry).
+    #[inline]
+    pub fn register<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
     ) {
-        // If the system is already registered and initialized, use it
-        if let Some(initialized_system) = self.systems.get_mut(&system.type_id()) {
-            initialized_system.run((), world);
-            initialized_system.apply_buffers(world);
-        // Otherwise, register and initialize it first.
-        } else {
-            let initialized_system = self.register(world, system);
-            initialized_system.run((), world);
-            initialized_system.apply_buffers(world);
-        }
+        let label = system.type_id();
+
+        let mut unchained_system: UnchainedSystem = Box::new(IntoSystem::into_system(system));
+        unchained_system.initialize(world);
+
+        self.systems.insert(label, unchained_system);
     }
 
-    /// Runs the supplied system on the [`World`] a single time, without flushing [`Commands`](crate::system::Commands)
-    #[inline]
-    pub fn run_system_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
+    /// Is the provided `type_id` registered?
+    pub fn type_id_registered(&self, type_id: &TypeId) -> bool {
+        self.systems.contains_key(type_id)
+    }
+
+    /// Runs the system corresponding to the provided [`TypeId`] on the [`World`] a single time
+    ///
+    /// If `flush_commands` is true, any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately
+    pub fn run_system_by_type_id(
         &mut self,
         world: &mut World,
-        system: S,
+        type_id: TypeId,
+        flush_commands: bool,
     ) {
-        // If the system is already registered and initialized, use it
-        if let Some(initialized_system) = self.systems.get_mut(&system.type_id()) {
-            initialized_system.run((), world);
-        // Otherwise, register and initialize it first.
-        } else {
-            let initialized_system = self.register(world, system);
-            initialized_system.run((), world);
+        let initialized_system = self.systems.get_mut(&type_id).unwrap_or_else(||{panic!{"No system with the `TypeId` {type_id:?} was found. Did you forget to register it?"}});
+        initialized_system.run((), world);
+        if flush_commands {
+            initialized_system.apply_buffers(world);
         }
     }
-}
 
-// Internals
-impl SystemRegistry {
-    #[inline]
-    fn register<Params, S: IntoSystem<(), (), Params> + 'static>(
+    /// Runs the supplied system on the [`World`] a single time
+    ///
+    /// If `flush_commands` is true, any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately
+    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
-    ) -> &mut UnchainedSystem {
-        let label = system.type_id();
-
-        let mut unchained_system: UnchainedSystem = Box::new(IntoSystem::into_system(system));
-        unchained_system.initialize(world);
-
-        self.systems.insert(label, unchained_system);
-        self.systems.get_mut(&label).unwrap()
+        flush_commands: bool,
+    ) {
+        let type_id = TypeId::of::<S>();
+        if self.type_id_registered(&type_id) {
+            self.run_system_by_type_id(world, type_id, flush_commands);
+        } else {
+            self.register(world, system);
+            self.run_system_by_type_id(world, type_id, flush_commands);
+        }
     }
 }
 
@@ -90,7 +94,7 @@ impl World {
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system(world, system);
+            registry.run_system(world, system, true);
         });
     }
 
@@ -108,7 +112,7 @@ impl World {
         system: S,
     ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system_without_flushing(world, system);
+            registry.run_system(world, system, false);
         });
     }
 }

From 7f7bc4aa84a9c6676145aa91c7f0b35460560f9d Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 14:15:17 -0500
Subject: [PATCH 005/113] Fix doc links

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index b39c179ade13c..644afcb2f1e24 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -117,7 +117,7 @@ impl World {
     }
 }
 
-/// The [`Command`] type for [`SystemRegistry`] [`Commands`]
+/// The [`Command`] type for [`SystemRegistry`] [`Commands`](crate::system::Commands)
 #[derive(Debug, Clone)]
 pub struct RunSystemCommand<
     Params: Send + Sync + 'static,
@@ -131,7 +131,7 @@ pub struct RunSystemCommand<
 impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static>
     RunSystemCommand<Params, S>
 {
-    /// Creates a new [`Command`] struct, which can be addeded to [`Commands`]
+    /// Creates a new [`Command`] struct, which can be addeded to [`Commands`](crate::system::Commands)
     #[inline]
     #[must_use]
     pub fn new(system: S, flush: bool) -> Self {

From ac35f1956e27f860f1bc403bccaa9dc64a3e92a5 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 14:31:20 -0500
Subject: [PATCH 006/113] run_system_by_type_id for World and Commands

---
 crates/bevy_ecs/src/system/system_registry.rs | 48 +++++++++++++++++--
 1 file changed, 45 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 644afcb2f1e24..33365c6bc702a 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -27,7 +27,7 @@ impl SystemRegistry {
     ///
     /// This only needs to be called manually whenn using [`run_system_by_type_id`](SystemRegistry).
     #[inline]
-    pub fn register<Params, S: IntoSystem<(), (), Params> + 'static>(
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
@@ -74,13 +74,23 @@ impl SystemRegistry {
         if self.type_id_registered(&type_id) {
             self.run_system_by_type_id(world, type_id, flush_commands);
         } else {
-            self.register(world, system);
+            self.register_system(world, system);
             self.run_system_by_type_id(world, type_id, flush_commands);
         }
     }
 }
 
 impl World {
+    /// Registers the supplied system in the [`SystemRegistry`] resource
+    ///
+    /// This allows the system to be run by [`TypeId`] using [`World::run_system_by_type_id`]
+    #[inline]
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.register_system(world, system);
+        });
+    }
+
     /// Runs the supplied system on the [`World`] a single time
     ///
     /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
@@ -98,6 +108,25 @@ impl World {
         });
     }
 
+    /// Runs the system corresponding to the supplied `type_id` on the [`World`] a single time
+    ///
+    /// Systems must be registered before they can be run by `type_id`.
+    ///
+    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
+    ///
+    /// The system's state will be cached: any future calls using the same type will use this state,
+    /// improving performance and ensuring that change detection works properly.
+    ///
+    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
+    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
+    /// at once, and want parallel execution of these systems.
+    #[inline]
+    pub fn run_system_by_type_id(&mut self, type_id: TypeId) {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_system_by_type_id(world, type_id, true);
+        });
+    }
+
     /// Runs the supplied system on the [`World`] a single time, wihthout flushing [`Commands`](crate::system::Commands)
     ///
     /// The system's state will be cached: any future calls using the same type will use this state,
@@ -117,7 +146,7 @@ impl World {
     }
 }
 
-/// The [`Command`] type for [`SystemRegistry`] [`Commands`](crate::system::Commands)
+/// The [`Command`] type for [`SystemRegistry::run_system`]
 #[derive(Debug, Clone)]
 pub struct RunSystemCommand<
     Params: Send + Sync + 'static,
@@ -155,3 +184,16 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
         }
     }
 }
+
+/// The [`Command`] type for [`SystemRegistry::run_system_by_type_id`]
+#[derive(Debug, Clone)]
+pub struct RunSystemByTypeIdCommand {
+    pub type_id: TypeId,
+}
+
+impl Command for RunSystemByTypeIdCommand {
+    #[inline]
+    fn write(self, world: &mut World) {
+        world.run_system_by_type_id(self.type_id)
+    }
+}

From 549d2ebdcc552cde0bd05cf60aadf0da4e9956ae Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 14:38:48 -0500
Subject: [PATCH 007/113] Always flush commands from systems

Only the commands specific to this system are applied, so we should de-emphasize this choice.
---
 crates/bevy_ecs/src/system/commands/mod.rs    | 20 ++++-----
 crates/bevy_ecs/src/system/system_registry.rs | 45 ++++---------------
 2 files changed, 16 insertions(+), 49 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index d1a1388a05a60..0e3b75b24e1f1 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,7 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystemCommand},
+    system::{IntoSystem, RunSystemByTypeIdCommand, RunSystemCommand},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -13,6 +13,8 @@ use bevy_utils::tracing::{error, info};
 pub use command_queue::CommandQueue;
 pub use parallel_scope::*;
 use std::marker::PhantomData;
+use std::{any::TypeId, marker::PhantomData};
+
 
 use super::{Deferred, Resource, SystemBuffer, SystemMeta};
 
@@ -520,7 +522,7 @@ impl<'w, 's> Commands<'w, 's> {
         self.queue.push(RemoveResource::<R>::new());
     }
 
-    /// Calls [`World::run_system`] once [`Commands`] are flushed
+    /// Calls [`World::run_system`]
     pub fn run_system<
         Params: Send + Sync + 'static,
         S: IntoSystem<(), (), Params> + Send + Sync + 'static,
@@ -528,18 +530,12 @@ impl<'w, 's> Commands<'w, 's> {
         &mut self,
         system: S,
     ) {
-        self.queue.push(RunSystemCommand::new(system, true));
+        self.queue.push(RunSystemCommand::new(system));
     }
 
-    /// Calls [`World::run_system_without_flushing`] once [`Commands`] are flushed
-    pub fn run_system_without_flushing<
-        Params: Send + Sync + 'static,
-        S: IntoSystem<(), (), Params> + Send + Sync + 'static,
-    >(
-        &mut self,
-        system: S,
-    ) {
-        self.queue.push(RunSystemCommand::new(system, false));
+    /// Calls [`World::run_system_by_type_id`]
+    pub fn run_system_by_type_id(&mut self, type_id: TypeId) {
+        self.queue.push(RunSystemByTypeIdCommand { type_id });
     }
 
     /// Pushes a generic [`Command`] to the command queue.
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 33365c6bc702a..11330e3e9fae1 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -14,6 +14,7 @@ pub type UnchainedSystem = Box<dyn System<In = (), Out = ()>>;
 ///
 /// Systems are keyed by their [`TypeId`]: repeated calls with the same function type will reuse cached state,
 /// including for change detection.
+/// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
 /// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
 #[derive(Default)]
@@ -46,19 +47,10 @@ impl SystemRegistry {
     }
 
     /// Runs the system corresponding to the provided [`TypeId`] on the [`World`] a single time
-    ///
-    /// If `flush_commands` is true, any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately
-    pub fn run_system_by_type_id(
-        &mut self,
-        world: &mut World,
-        type_id: TypeId,
-        flush_commands: bool,
-    ) {
+    pub fn run_system_by_type_id(&mut self, world: &mut World, type_id: TypeId) {
         let initialized_system = self.systems.get_mut(&type_id).unwrap_or_else(||{panic!{"No system with the `TypeId` {type_id:?} was found. Did you forget to register it?"}});
         initialized_system.run((), world);
-        if flush_commands {
-            initialized_system.apply_buffers(world);
-        }
+        initialized_system.apply_buffers(world);
     }
 
     /// Runs the supplied system on the [`World`] a single time
@@ -68,14 +60,13 @@ impl SystemRegistry {
         &mut self,
         world: &mut World,
         system: S,
-        flush_commands: bool,
     ) {
         let type_id = TypeId::of::<S>();
         if self.type_id_registered(&type_id) {
-            self.run_system_by_type_id(world, type_id, flush_commands);
+            self.run_system_by_type_id(world, type_id);
         } else {
             self.register_system(world, system);
-            self.run_system_by_type_id(world, type_id, flush_commands);
+            self.run_system_by_type_id(world, type_id);
         }
     }
 }
@@ -104,7 +95,7 @@ impl World {
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system(world, system, true);
+            registry.run_system(world, system);
         });
     }
 
@@ -123,25 +114,7 @@ impl World {
     #[inline]
     pub fn run_system_by_type_id(&mut self, type_id: TypeId) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system_by_type_id(world, type_id, true);
-        });
-    }
-
-    /// Runs the supplied system on the [`World`] a single time, wihthout flushing [`Commands`](crate::system::Commands)
-    ///
-    /// The system's state will be cached: any future calls using the same type will use this state,
-    /// improving performance and ensuring that change detection works properly.
-    ///
-    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
-    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
-    /// at once, and want parallel execution of these systems.
-    #[inline]
-    pub fn run_system_without_flushing<Params, S: IntoSystem<(), (), Params> + 'static>(
-        &mut self,
-        system: S,
-    ) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system(world, system, false);
+            registry.run_system_by_type_id(world, type_id);
         });
     }
 }
@@ -154,7 +127,6 @@ pub struct RunSystemCommand<
 > {
     _phantom_params: PhantomData<Params>,
     system: S,
-    flush: bool,
 }
 
 impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static>
@@ -163,11 +135,10 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
     /// Creates a new [`Command`] struct, which can be addeded to [`Commands`](crate::system::Commands)
     #[inline]
     #[must_use]
-    pub fn new(system: S, flush: bool) -> Self {
+    pub fn new(system: S) -> Self {
         Self {
             _phantom_params: PhantomData::default(),
             system,
-            flush,
         }
     }
 }

From d6c2fd2ef04538170a97436f1c73d3eec9147f4b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 14:53:39 -0500
Subject: [PATCH 008/113] Always initialize SystemRegistry on the `World`

---
 crates/bevy_core/src/lib.rs      |  3 +--
 crates/bevy_ecs/src/world/mod.rs | 12 ++++++------
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index ae6c8d600badc..cd164f0df46a3 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -24,7 +24,7 @@ use bevy_app::prelude::*;
 use bevy_ecs::{
     entity::Entity,
     schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
-    system::{IntoExclusiveSystem, SystemRegistry},
+    system::IntoExclusiveSystem,
 };
 use bevy_utils::HashSet;
 use std::ops::Range;
@@ -49,7 +49,6 @@ impl Plugin for TypeRegistrationPlugin {
 
         app.init_resource::<Time>()
             .init_resource::<FixedTimesteps>()
-            .init_resource::<SystemRegistry>()
             .register_type::<HashSet<String>>()
             .register_type::<Option<String>>()
             .register_type::<Entity>()
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 0e79b19ce8568..3598eaaaea39f 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -14,15 +14,15 @@ pub use world_cell::*;
 use crate::{
     archetype::{ArchetypeComponentId, ArchetypeId, ArchetypeRow, Archetypes},
     bundle::{Bundle, BundleInserter, BundleSpawner, Bundles},
-    change_detection::{MutUntyped, TicksMut},
-    component::{Component, ComponentDescriptor, ComponentId, ComponentInfo, Components, Tick},
+    change_detection::{MutUntyped, TicksMut, Ticks},
+    component::{Component, ComponentDescriptor, ComponentId, ComponentInfo, ComponentTicks, Components, Tick},
     entity::{AllocAtWithoutReplacement, Entities, Entity, EntityLocation},
     event::{Event, Events},
-    query::{DebugCheckedUnwrap, QueryState, ReadOnlyWorldQuery, WorldQuery},
+    query::{DebugCheckedUnwrap, FilterFetch, QueryState, ReadOnlyWorldQuery, WorldQuery},
     removal_detection::RemovedComponentEvents,
     schedule::{Schedule, ScheduleLabel, Schedules},
-    storage::{ResourceData, Storages},
-    system::Resource,
+    storage::{Column, ResourceData, SparseSet, Storages},
+    system::{Resource, SystemRegistry},
     world::error::TryRunScheduleError,
 };
 use bevy_ptr::{OwningPtr, Ptr};
@@ -74,7 +74,7 @@ pub struct World {
 
 impl Default for World {
     fn default() -> Self {
-        Self {
+        let mut world = Self {
             id: WorldId::new().expect("More `bevy` `World`s have been created than is supported"),
             entities: Entities::new(),
             components: Default::default(),

From d39092d59394a9f16361b64171fe1696f278ec12 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 3 Mar 2022 17:46:08 -0500
Subject: [PATCH 009/113] Add test suite

---
 crates/bevy_ecs/src/system/system_registry.rs | 133 ++++++++++++++++++
 1 file changed, 133 insertions(+)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 11330e3e9fae1..59dfa5bae6bd7 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -168,3 +168,136 @@ impl Command for RunSystemByTypeIdCommand {
         world.run_system_by_type_id(self.type_id)
     }
 }
+
+mod tests {
+    use crate::prelude::*;
+
+    #[derive(Default, PartialEq, Debug)]
+    struct Counter(u8);
+
+    #[allow(dead_code)]
+    fn count_up(mut counter: ResMut<Counter>) {
+        counter.0 += 1;
+    }
+
+    #[test]
+    fn run_system() {
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        world.run_system(count_up);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+    }
+
+    #[test]
+    fn run_system_by_type_id() {
+        use std::any::Any;
+
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        world.register_system(count_up);
+        world.run_system_by_type_id(count_up.type_id());
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+    }
+
+    #[allow(dead_code)]
+    fn spawn_entity(mut commands: Commands) {
+        commands.spawn();
+    }
+
+    #[test]
+    fn command_processing() {
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(world.entities.len(), 0);
+        world.run_system(spawn_entity);
+        assert_eq!(world.entities.len(), 1);
+    }
+
+    fn non_send_count_down(mut ns: NonSendMut<Counter>) {
+        ns.0 -= 1;
+    }
+
+    #[allow(dead_code)]
+    fn trigger_non_send_count_down(mut commands: Commands) {
+        commands.run_system(non_send_count_down);
+    }
+
+    #[test]
+    fn non_send_resources() {
+        let mut world = World::new();
+        world.insert_non_send_resource(Counter(10));
+        assert_eq!(*world.non_send_resource::<Counter>(), Counter(10));
+        world.run_system(non_send_count_down);
+        assert_eq!(*world.non_send_resource::<Counter>(), Counter(9));
+        world.run_system(trigger_non_send_count_down);
+        assert_eq!(*world.non_send_resource::<Counter>(), Counter(8));
+    }
+
+    #[derive(Default)]
+    struct ChangeDetector;
+
+    #[allow(dead_code)]
+    fn count_up_iff_changed(mut commands: Commands, change_detector: ResMut<ChangeDetector>) {
+        if change_detector.is_changed() {
+            commands.run_system(count_up);
+        }
+    }
+
+    #[test]
+    fn change_detection() {
+        let mut world = World::new();
+        world.init_resource::<ChangeDetector>();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        // Resources are changed when they are first added.
+        world.run_system(count_up_iff_changed);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        // Nothing changed
+        world.run_system(count_up_iff_changed);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        // Making a change
+        world.resource_mut::<ChangeDetector>().set_changed();
+        world.run_system(count_up_iff_changed);
+        assert_eq!(*world.resource::<Counter>(), Counter(2));
+    }
+
+    #[allow(dead_code)]
+    // The `Local` begins at the default value of 0
+    fn fibonacci_counting(last_counter: Local<u8>, mut counter: ResMut<Counter>) {
+        counter.0 = *last_counter + counter.0;
+    }
+
+    #[test]
+    fn local_variables() {
+        let mut world = World::new();
+        world.insert_resource(Counter(1));
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        world.run_system(fibonacci_counting);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        world.run_system(fibonacci_counting);
+        assert_eq!(*world.resource::<Counter>(), Counter(2));
+        world.run_system(fibonacci_counting);
+        assert_eq!(*world.resource::<Counter>(), Counter(3));
+        world.run_system(fibonacci_counting);
+        assert_eq!(*world.resource::<Counter>(), Counter(5));
+    }
+
+    #[allow(dead_code)]
+    fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
+        counter.0 += 1;
+        if counter.0 < 10 {
+            commands.run_system(count_to_ten)
+        }
+    }
+
+    #[test]
+    fn system_recursion() {
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        world.run_system(count_to_ten);
+        assert_eq!(*world.resource::<Counter>(), Counter(10));
+    }
+}

From 63a0707d89965f3aebafffdd10cc85fb26963d9e Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Mon, 7 Mar 2022 11:57:51 -0500
Subject: [PATCH 010/113] Doc improvements

---
 crates/bevy_ecs/src/system/system_registry.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 59dfa5bae6bd7..11110302d753d 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -10,7 +10,7 @@ use crate::world::{Mut, World};
 /// [`BoxedSystem`](crate::system::BoxedSystem) is the equivalent type alias for arbitrary `In` and `Out` types.
 pub type UnchainedSystem = Box<dyn System<In = (), Out = ()>>;
 
-/// Stores initialized [`Systems`](crate::system::System), so they can quickly be reused and run
+/// Stores initialized [`Systems`](crate::system::System), so they can be reused and run in an ad-hoc fashion
 ///
 /// Systems are keyed by their [`TypeId`]: repeated calls with the same function type will reuse cached state,
 /// including for change detection.
@@ -22,7 +22,6 @@ pub struct SystemRegistry {
     systems: HashMap<TypeId, UnchainedSystem>,
 }
 
-// User-facing methods
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
@@ -42,6 +41,7 @@ impl SystemRegistry {
     }
 
     /// Is the provided `type_id` registered?
+    #[inline]
     pub fn type_id_registered(&self, type_id: &TypeId) -> bool {
         self.systems.contains_key(type_id)
     }
@@ -132,7 +132,7 @@ pub struct RunSystemCommand<
 impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static>
     RunSystemCommand<Params, S>
 {
-    /// Creates a new [`Command`] struct, which can be addeded to [`Commands`](crate::system::Commands)
+    /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
     #[inline]
     #[must_use]
     pub fn new(system: S) -> Self {

From 89b045cea129c326a57a6a6b144767ab72c7e51d Mon Sep 17 00:00:00 2001
From: Alice <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 02:17:30 -0400
Subject: [PATCH 011/113] Store registered systems by their system labels

---
 crates/bevy_ecs/src/system/commands/mod.rs    |   9 +-
 crates/bevy_ecs/src/system/function_system.rs |  52 ++++++
 crates/bevy_ecs/src/system/system_registry.rs | 167 +++++++++++++-----
 3 files changed, 178 insertions(+), 50 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 0e3b75b24e1f1..bfd959caabc50 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,7 +5,8 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystemByTypeIdCommand, RunSystemCommand},
+    schedule::SystemLabel,
+    system::{IntoSystem, RunSystemCommand, RunSystemsByLabelCommand},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -534,8 +535,10 @@ impl<'w, 's> Commands<'w, 's> {
     }
 
     /// Calls [`World::run_system_by_type_id`]
-    pub fn run_system_by_type_id(&mut self, type_id: TypeId) {
-        self.queue.push(RunSystemByTypeIdCommand { type_id });
+    pub fn run_systems_by_label(&mut self, label: impl SystemLabel) {
+        self.queue.push(RunSystemsByLabelCommand {
+            label: Box::new(label),
+        });
     }
 
     /// Pushes a generic [`Command`] to the command queue.
diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index e245f93716d78..b60adac06f345 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -522,6 +522,58 @@ where
     F: SystemParamFunction<Marker>,
     F::Param: ReadOnlySystemParam,
 {
+    #[inline]
+    fn default_labels(&self) -> Vec<Box<dyn SystemLabel>> {
+        vec![Box::new(self.func.as_system_label())]
+    }
+}
+
+/// A [`SystemLabel`] that was automatically generated for a system on the basis of its `TypeId`.
+pub struct SystemTypeIdLabel<T: 'static>(PhantomData<fn() -> T>);
+
+impl<T: 'static> SystemTypeIdLabel<T> {
+    /// Constructs a new copy of the [`SystemTypeIdLabel`] for the type `T`
+    ///
+    /// You can also construct this by using [`.as_system_label()](crate::system::AsSystemLabel) on a concrete instance
+    /// of your function type.
+    pub fn new() -> Self {
+        Self(PhantomData::default())
+    }
+}
+
+impl<T> Debug for SystemTypeIdLabel<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("SystemTypeIdLabel")
+            .field(&std::any::type_name::<T>())
+            .finish()
+    }
+}
+impl<T> Hash for SystemTypeIdLabel<T> {
+    fn hash<H: std::hash::Hasher>(&self, _state: &mut H) {
+        // All SystemTypeIds of a given type are the same.
+    }
+}
+impl<T> Clone for SystemTypeIdLabel<T> {
+    fn clone(&self) -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<T> Copy for SystemTypeIdLabel<T> {}
+
+impl<T> PartialEq for SystemTypeIdLabel<T> {
+    #[inline]
+    fn eq(&self, _other: &Self) -> bool {
+        // All labels of a given type are equal, as they will all have the same type id
+        true
+    }
+}
+impl<T> Eq for SystemTypeIdLabel<T> {}
+
+impl<T> SystemLabel for SystemTypeIdLabel<T> {
+    fn dyn_clone(&self) -> Box<dyn SystemLabel> {
+        Box::new(*self)
+    }
 }
 
 /// A trait implemented for all functions that can be used as [`System`]s.
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 11110302d753d..52305d505d369 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,56 +1,124 @@
 use bevy_utils::HashMap;
-use std::any::{Any, TypeId};
 use std::marker::PhantomData;
 
-use crate::system::{Command, IntoSystem, System};
+use crate::archetype::ArchetypeGeneration;
+use crate::schedule::SystemLabel;
+use crate::system::{Command, IntoSystem, System, SystemTypeIdLabel};
 use crate::world::{Mut, World};
 
-/// A [`System`] that cannot be chained.
-///
-/// [`BoxedSystem`](crate::system::BoxedSystem) is the equivalent type alias for arbitrary `In` and `Out` types.
-pub type UnchainedSystem = Box<dyn System<In = (), Out = ()>>;
-
 /// Stores initialized [`Systems`](crate::system::System), so they can be reused and run in an ad-hoc fashion
 ///
-/// Systems are keyed by their [`TypeId`]: repeated calls with the same function type will reuse cached state,
-/// including for change detection.
+/// Systems are keyed by their [`SystemLabel`]:
+///  - all systems with a given label will be run (in linear registration order) when a given label is run
+///  - repeated calls with the same function type will reuse cached state, including for change detection
+///
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
 /// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
 #[derive(Default)]
 pub struct SystemRegistry {
-    systems: HashMap<TypeId, UnchainedSystem>,
+    systems: Vec<StoredSystem>,
+    // Stores the index of all systems that match the key's label
+    labels: HashMap<Box<dyn SystemLabel>, Vec<usize>>,
+}
+
+struct StoredSystem {
+    system: Box<dyn System<In = (), Out = ()>>,
+    generation: ArchetypeGeneration,
+}
+
+impl StoredSystem {
+    /// Updates archetypes to ensure our access pointers are correct
+    ///
+    /// This logic must be run after each system is run, as each system can modify archetypes
+    // TODO: remove this method once https://github.com/bevyengine/bevy/pull/4115 is merged
+    fn update_archetypes(&mut self, world: &mut World) {
+        // This logic is borrowed directly from SingleThreadedExecutor
+        let archetypes = world.archetypes();
+        let new_generation = archetypes.generation();
+        let old_generation = std::mem::replace(&mut self.generation, new_generation);
+        self.generation = new_generation;
+
+        let archetype_index_range = old_generation.value()..new_generation.value();
+
+        for archetype in archetypes.archetypes[archetype_index_range].iter() {
+            self.system.new_archetype(archetype);
+        }
+    }
 }
 
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
-    /// This only needs to be called manually whenn using [`run_system_by_type_id`](SystemRegistry).
+    /// This method only needs to be called manually when using [`run_system_by_label`](SystemRegistry).
+    ///
+    /// If `labels` are provided, the system will be registered under those labels.
+    /// Otherwise, it will use the default labels for that system, typically its [`SystemTypeIdLabel`].
     #[inline]
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
+        labels: Option<Vec<Box<dyn SystemLabel>>>,
     ) {
-        let label = system.type_id();
+        let mut unchained_system: Box<dyn System<In = (), Out = ()>> =
+            Box::new(IntoSystem::into_system(system));
 
-        let mut unchained_system: UnchainedSystem = Box::new(IntoSystem::into_system(system));
-        unchained_system.initialize(world);
+        // If no labels are provided, use the default labels
+        let labels = labels.unwrap_or(unchained_system.default_labels());
 
-        self.systems.insert(label, unchained_system);
+        // Intialize the system's state
+        unchained_system.initialize(world);
+        // Record the archetype generation at the time of its creation
+        let archetype_generation = ArchetypeGeneration::initial();
+
+        let stored_system = StoredSystem {
+            system: unchained_system,
+            generation: archetype_generation,
+        };
+
+        // Add the system to the end of the vec
+        self.systems.push(stored_system);
+        let system_index = self.systems.len();
+
+        // For each label that the system has
+        for label in labels {
+            let maybe_label_indexes = self.labels.get_mut(&label);
+
+            // Add the index of the system in the vec to the lookup hashmap
+            // under the corresponding label key
+            if let Some(label_indexes) = maybe_label_indexes {
+                label_indexes.push(system_index);
+            } else {
+                self.labels.insert(label, vec![system_index]);
+            };
+        }
     }
 
-    /// Is the provided `type_id` registered?
-    #[inline]
-    pub fn type_id_registered(&self, type_id: &TypeId) -> bool {
-        self.systems.contains_key(type_id)
+    /// Returns true if at least one system in the [`SystemRegistry`] is associated with the provided [`SystemLabel`].
+    pub fn label_registered<L: SystemLabel>(&self, label: L) -> bool {
+        let boxed_label: Box<dyn SystemLabel> = Box::new(label);
+        self.labels.get(&boxed_label).is_some()
     }
 
-    /// Runs the system corresponding to the provided [`TypeId`] on the [`World`] a single time
-    pub fn run_system_by_type_id(&mut self, world: &mut World, type_id: TypeId) {
-        let initialized_system = self.systems.get_mut(&type_id).unwrap_or_else(||{panic!{"No system with the `TypeId` {type_id:?} was found. Did you forget to register it?"}});
-        initialized_system.run((), world);
-        initialized_system.apply_buffers(world);
+    /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time
+    ///
+    /// Systems will be run sequentially in registration order if more than one registered system matches the provided label
+    pub fn run_systems_by_label<L: SystemLabel + ?Sized>(&mut self, world: &mut World, label: &L) {
+        let boxed_label: Box<dyn SystemLabel> = label.dyn_clone();
+
+        let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {label:?} was found. Did you forget to register it?"}});
+
+        // Loop over the system in registration order
+        for &index in matching_system_indexes {
+            let ref mut stored_system = self.systems[index];
+            // Update the archetypes to make sure our data access is correct
+            stored_system.update_archetypes(world);
+            // Run the system
+            stored_system.system.run((), world);
+            // Apply any generated commands
+            stored_system.system.apply_buffers(world);
+        }
     }
 
     /// Runs the supplied system on the [`World`] a single time
@@ -61,12 +129,13 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
     ) {
-        let type_id = TypeId::of::<S>();
-        if self.type_id_registered(&type_id) {
-            self.run_system_by_type_id(world, type_id);
+        let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
+
+        if self.label_registered(automatic_system_label) {
+            self.run_systems_by_label(world, &automatic_system_label);
         } else {
-            self.register_system(world, system);
-            self.run_system_by_type_id(world, type_id);
+            self.register_system(world, system, None);
+            self.run_systems_by_label(world, &automatic_system_label);
         }
     }
 }
@@ -74,11 +143,15 @@ impl SystemRegistry {
 impl World {
     /// Registers the supplied system in the [`SystemRegistry`] resource
     ///
-    /// This allows the system to be run by [`TypeId`] using [`World::run_system_by_type_id`]
+    /// This allows the system to be run by their [`SystemLabel`] using [`World::run_systems_by_label`]
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        system: S,
+        labels: Option<Vec<Box<dyn SystemLabel>>>,
+    ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system);
+            registry.register_system(world, system, labels);
         });
     }
 
@@ -89,7 +162,7 @@ impl World {
     /// The system's state will be cached: any future calls using the same type will use this state,
     /// improving performance and ensuring that change detection works properly.
     ///
-    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
+    /// This is evaluated in a sequential, single-threaded fashion.
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
     #[inline]
@@ -99,22 +172,22 @@ impl World {
         });
     }
 
-    /// Runs the system corresponding to the supplied `type_id` on the [`World`] a single time
+    /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time
     ///
-    /// Systems must be registered before they can be run by `type_id`.
+    /// Systems must be registered before they can be run by their label.
     ///
     /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
     ///
     /// The system's state will be cached: any future calls using the same type will use this state,
     /// improving performance and ensuring that change detection works properly.
     ///
-    /// Unsurprisingly, this is evaluated in a sequential, single-threaded fashion.
+    /// This is evaluated in a sequential, single-threaded fashion.
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
     #[inline]
-    pub fn run_system_by_type_id(&mut self, type_id: TypeId) {
+    pub fn run_systems_by_label<L: SystemLabel + ?Sized>(&mut self, label: &L) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system_by_type_id(world, type_id);
+            registry.run_systems_by_label(world, label);
         });
     }
 }
@@ -156,16 +229,16 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
     }
 }
 
-/// The [`Command`] type for [`SystemRegistry::run_system_by_type_id`]
+/// The [`Command`] type for [`SystemRegistry::run_systems_by_label`]
 #[derive(Debug, Clone)]
-pub struct RunSystemByTypeIdCommand {
-    pub type_id: TypeId,
+pub struct RunSystemsByLabelCommand {
+    pub label: Box<dyn SystemLabel>,
 }
 
-impl Command for RunSystemByTypeIdCommand {
+impl Command for RunSystemsByLabelCommand {
     #[inline]
     fn write(self, world: &mut World) {
-        world.run_system_by_type_id(self.type_id)
+        world.run_systems_by_label(&*self.label)
     }
 }
 
@@ -190,14 +263,14 @@ mod tests {
     }
 
     #[test]
-    fn run_system_by_type_id() {
-        use std::any::Any;
+    fn run_system_by_label() {
+        use crate::system::AsSystemLabel;
 
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system(count_up);
-        world.run_system_by_type_id(count_up.type_id());
+        world.register_system(count_up, None);
+        world.run_systems_by_label(&count_up.as_system_label());
         assert_eq!(*world.resource::<Counter>(), Counter(1));
     }
 

From 67c27fc6fefaf85420e582bf6ebf5f984917f24c Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 15:28:24 -0400
Subject: [PATCH 012/113] Ensure that run_system always runs the system exactly
 once

---
 crates/bevy_ecs/src/system/system_registry.rs | 48 +++++++++++++------
 1 file changed, 34 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 52305d505d369..4d17abd88d4ec 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -53,7 +53,7 @@ impl SystemRegistry {
     /// This method only needs to be called manually when using [`run_system_by_label`](SystemRegistry).
     ///
     /// If `labels` are provided, the system will be registered under those labels.
-    /// Otherwise, it will use the default labels for that system, typically its [`SystemTypeIdLabel`].
+    /// Otherwise, it will use the default labels for that system: typically its [`SystemTypeIdLabel`].
     #[inline]
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
@@ -95,12 +95,38 @@ impl SystemRegistry {
         }
     }
 
+    /// Runs the system at the supplied `index` a single time
+    #[inline]
+    fn run_system_at_index(&mut self, world: &mut World, index: usize) {
+        let ref mut stored_system = self.systems[index];
+
+        // Update the archetypes to make sure our data access is correct
+        stored_system.update_archetypes(world);
+        // Run the system
+        stored_system.system.run((), world);
+        // Apply any generated commands
+        stored_system.system.apply_buffers(world);
+    }
+
     /// Returns true if at least one system in the [`SystemRegistry`] is associated with the provided [`SystemLabel`].
+    #[inline]
     pub fn label_registered<L: SystemLabel>(&self, label: L) -> bool {
         let boxed_label: Box<dyn SystemLabel> = Box::new(label);
         self.labels.get(&boxed_label).is_some()
     }
 
+    /// Returns the first matching index for systems with this label
+    ///
+    /// # Panics
+    ///
+    /// Panics if no system with the label is registered.
+    #[inline]
+    fn first_registered_index<L: SystemLabel>(&self, label: L) -> usize {
+        let boxed_label: Box<dyn SystemLabel> = Box::new(label);
+        let vec_of_indexes = self.labels.get(&boxed_label).unwrap();
+        *vec_of_indexes.iter().next().unwrap()
+    }
+
     /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided label
@@ -110,20 +136,16 @@ impl SystemRegistry {
         let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {label:?} was found. Did you forget to register it?"}});
 
         // Loop over the system in registration order
-        for &index in matching_system_indexes {
-            let ref mut stored_system = self.systems[index];
-            // Update the archetypes to make sure our data access is correct
-            stored_system.update_archetypes(world);
-            // Run the system
-            stored_system.system.run((), world);
-            // Apply any generated commands
-            stored_system.system.apply_buffers(world);
+        for index in matching_system_indexes.clone() {
+            self.run_system_at_index(world, index);
         }
     }
 
     /// Runs the supplied system on the [`World`] a single time
     ///
-    /// If `flush_commands` is true, any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately
+    /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
+    /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeIdLabel`],
+    /// only the first will be run.
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
@@ -131,12 +153,10 @@ impl SystemRegistry {
     ) {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
-        if self.label_registered(automatic_system_label) {
-            self.run_systems_by_label(world, &automatic_system_label);
-        } else {
+        if !self.label_registered(automatic_system_label) {
             self.register_system(world, system, None);
-            self.run_systems_by_label(world, &automatic_system_label);
         }
+        self.run_system_at_index(world, self.first_registered_index(automatic_system_label));
     }
 }
 

From 3e205aa8aec6921d770d9afc0f9cfac2f999655a Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 15:54:54 -0400
Subject: [PATCH 013/113] Advertise SystemRegistry in SystemState docs

---
 crates/bevy_ecs/src/system/function_system.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index b60adac06f345..23e72c62fd501 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -60,8 +60,10 @@ impl SystemMeta {
 // (to avoid the need for unwrapping to retrieve SystemMeta)
 /// Holds on to persistent state required to drive [`SystemParam`] for a [`System`].
 ///
-/// This is a very powerful and convenient tool for working with exclusive world access,
+/// This is a powerful and convenient tool for working with exclusive world access,
 /// allowing you to fetch data from the [`World`] as if you were running a [`System`].
+/// However, simply calling `world::run_system(my_system)` using a [`SystemRegistry`](crate::system::SystemRegistry)
+/// can be significantly simpler and more reliable.
 ///
 /// Borrow-checking is handled for you, allowing you to mutably access multiple compatible system parameters at once,
 /// and arbitrary system parameters (like [`EventWriter`](crate::event::EventWriter)) can be conveniently fetched.
@@ -77,6 +79,8 @@ impl SystemMeta {
 /// - [`Local`](crate::system::Local) variables that hold state
 /// - [`EventReader`](crate::event::EventReader) system parameters, which rely on a [`Local`](crate::system::Local) to track which events have been seen
 ///
+/// Note that this is automatically handled for you when using a [`SystemRegistry`](crate::system::SystemRegistry).
+///
 /// # Example
 ///
 /// Basic usage:

From c16fab690a0c735c3d5e0c5e839ed135c924412c Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 17:24:43 -0400
Subject: [PATCH 014/113] Doc tests for SystemRegistry

---
 crates/bevy_ecs/src/system/system_registry.rs | 112 +++++++++++++++++-
 1 file changed, 106 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 4d17abd88d4ec..20d9372a521f5 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -15,6 +15,101 @@ use crate::world::{Mut, World};
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
 /// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
+///
+/// # Examples
+///
+/// You can run a single system directly on the World,
+/// applying its effect and caching its state for the next time
+/// you call this method (internally, this is based on [`SystemTypeIdLabel`]).
+///
+/// ```rust
+/// use bevy_ecs::prelude::*;
+///
+/// let mut world = World::new();  
+///
+/// #[derive(Default, PartialEq, Debug)]
+/// struct Counter(u8);
+///
+/// fn count_up(mut counter: ResMut<Counter>){
+///     counter.0 += 1;
+/// }
+///
+/// world.init_resource::<Counter>();
+/// world.run_system(count_up);
+///
+/// assert_eq!(Counter(1), *world.resource());
+/// ```
+///
+/// These systems immediately apply commands and cache state,
+/// ensuring that change detection and [`Local`](crate::system::Local) variables work correctly.
+///
+/// ```rust
+/// use bevy_ecs::prelude::*;
+///
+/// let mut world = World::new();
+///
+/// #[derive(Component)]
+/// struct Marker;
+///
+/// fn spawn_7_entities(mut commands: Commands) {
+///     for _ in 0..7 {
+///         commands.spawn().insert(Marker);
+///     }
+///     
+///     // You can even run systems via commands,
+///     // which will take effect the next time commands are applied
+///     commands.run_system(assert_7_spawned)
+/// }
+///
+/// fn assert_7_spawned(query: Query<(), Added<Marker>>){
+///     let n_spawned = query.iter().count();
+///     assert_eq!(n_spawned, 7);
+/// }
+///
+/// world.run_system(spawn_7_entities);
+/// ```
+///
+/// ```rust
+/// use bevy_ecs::prelude::*;
+/// use bevy_ecs::system::SystemRegistry;
+///
+/// let mut world = World::new();
+/// // The `SystemRegistry` type is automatically included as a resource in every World
+/// let mut system_registry: Mut<SystemRegistry> = world.resource_mut();
+///
+/// #[derive(SystemLabel, Debug, PartialEq, Eq, Hash, Clone)]
+/// enum ManualSystems {
+///     Hello,
+///     Goodbye,
+/// }
+///
+/// fn hello(){
+///     println!("Hello!")
+/// }
+///
+/// fn goodbye(){
+///     println!("Goodbye <3")
+/// }
+///
+/// fn have_a_nice_day(){
+///     println!("Have a nice day, and enjoy using Bevy!")
+/// }
+///
+/// // You can register systems by their label
+/// system_registry.register_system(&mut world, hello, vec![ManualSystems::Hello]);
+///
+/// // And run them by their label as well
+/// system_registry.run_systems_by_label(&mut world, &ManualSystems::Hello);
+///
+/// // All systems registered under that label will be run, in registration order
+/// system_registry.register_system(&mut world, hello, vec![ManualSystems::Hello]);
+/// system_registry.run_systems_by_label(&mut world, &ManualSystems::Hello);
+///
+/// // All methods on this type are also exposed on the `World` for convenience
+/// world.register_system(goodbye, vec![ManualSystems::Goodbye]);
+/// world.register_system(have_a_nice_day, vec![ManualSystems::Goodbye]);
+/// world.run_systems_by_label(&ManualSystems::Goodbye);
+/// ```
 #[derive(Default)]
 pub struct SystemRegistry {
     systems: Vec<StoredSystem>,
@@ -59,13 +154,17 @@ impl SystemRegistry {
         &mut self,
         world: &mut World,
         system: S,
-        labels: Option<Vec<Box<dyn SystemLabel>>>,
+        labels: Vec<Box<dyn SystemLabel>>,
     ) {
         let mut unchained_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
         // If no labels are provided, use the default labels
-        let labels = labels.unwrap_or(unchained_system.default_labels());
+        let labels = if labels.is_empty() {
+            unchained_system.default_labels()
+        } else {
+            labels
+        };
 
         // Intialize the system's state
         unchained_system.initialize(world);
@@ -154,7 +253,7 @@ impl SystemRegistry {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
         if !self.label_registered(automatic_system_label) {
-            self.register_system(world, system, None);
+            self.register_system(world, system, Vec::default());
         }
         self.run_system_at_index(world, self.first_registered_index(automatic_system_label));
     }
@@ -168,7 +267,7 @@ impl World {
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         system: S,
-        labels: Option<Vec<Box<dyn SystemLabel>>>,
+        labels: Vec<Box<dyn SystemLabel>>,
     ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry.register_system(world, system, labels);
@@ -289,9 +388,10 @@ mod tests {
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system(count_up, None);
+        world.register_system(count_up, Vec::default());
+        world.register_system(count_up, Vec::default());
         world.run_systems_by_label(&count_up.as_system_label());
-        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
     #[allow(dead_code)]

From 6cabe3e62691267425f1d0b21d5c57ccd769662b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 18:25:33 -0400
Subject: [PATCH 015/113] Improve ergonomics of the register_system API

---
 crates/bevy_ecs/src/system/system_registry.rs | 33 +++++++++++++------
 1 file changed, 23 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 20d9372a521f5..6082d1eda9208 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -154,25 +154,35 @@ impl SystemRegistry {
         &mut self,
         world: &mut World,
         system: S,
-        labels: Vec<Box<dyn SystemLabel>>,
+        labels: impl IntoIterator<Item = Box<dyn SystemLabel>>,
     ) {
-        let mut unchained_system: Box<dyn System<In = (), Out = ()>> =
+        let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
+        let mut labels: Vec<Box<dyn SystemLabel>> = labels.into_iter().collect();
+
         // If no labels are provided, use the default labels
-        let labels = if labels.is_empty() {
-            unchained_system.default_labels()
-        } else {
-            labels
-        };
+        if labels.is_empty() {
+            labels = boxed_system.default_labels()
+        }
 
+        self.register_boxed_system_by_labels(world, boxed_system, labels);
+    }
+
+    /// A more effecient but less ergonomic version of `register_system`
+    pub fn register_boxed_system_by_labels(
+        &mut self,
+        world: &mut World,
+        mut boxed_system: Box<dyn System<In = (), Out = ()>>,
+        labels: Vec<Box<dyn SystemLabel>>,
+    ) {
         // Intialize the system's state
-        unchained_system.initialize(world);
+        boxed_system.initialize(world);
         // Record the archetype generation at the time of its creation
         let archetype_generation = ArchetypeGeneration::initial();
 
         let stored_system = StoredSystem {
-            system: unchained_system,
+            system: boxed_system,
             generation: archetype_generation,
         };
 
@@ -253,7 +263,10 @@ impl SystemRegistry {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
         if !self.label_registered(automatic_system_label) {
-            self.register_system(world, system, Vec::default());
+            let boxed_system: Box<dyn System<In = (), Out = ()>> =
+                Box::new(IntoSystem::into_system(system));
+            let labels = boxed_system.default_labels();
+            self.register_boxed_system_by_labels(world, boxed_system, labels);
         }
         self.run_system_at_index(world, self.first_registered_index(automatic_system_label));
     }

From 157d48a23880dd34212873073384242e68c45104 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 19:10:27 -0400
Subject: [PATCH 016/113] Improve run_by_label API ergonomics

---
 crates/bevy_ecs/src/system/system_registry.rs | 36 ++++++++++++-------
 1 file changed, 24 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 6082d1eda9208..29e5013d58ae4 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -96,19 +96,20 @@ use crate::world::{Mut, World};
 /// }
 ///
 /// // You can register systems by their label
-/// system_registry.register_system(&mut world, hello, vec![ManualSystems::Hello]);
+/// system_registry.register_system(&mut world, hello, ManualSystems::Hello);
 ///
 /// // And run them by their label as well
-/// system_registry.run_systems_by_label(&mut world, &ManualSystems::Hello);
+/// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
+///
+/// // You can register systems under multiple labels
+/// system_registry.register_system(&mut world, have_a_nice_day, [ManualSystems::Hello, ManualSystems::Goodbye]);
 ///
 /// // All systems registered under that label will be run, in registration order
-/// system_registry.register_system(&mut world, hello, vec![ManualSystems::Hello]);
-/// system_registry.run_systems_by_label(&mut world, &ManualSystems::Hello);
+/// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
 ///
 /// // All methods on this type are also exposed on the `World` for convenience
-/// world.register_system(goodbye, vec![ManualSystems::Goodbye]);
-/// world.register_system(have_a_nice_day, vec![ManualSystems::Goodbye]);
-/// world.run_systems_by_label(&ManualSystems::Goodbye);
+/// world.register_system(goodbye, ManualSystems::Goodbye);
+/// world.run_systems_by_label(ManualSystems::Goodbye);
 /// ```
 #[derive(Default)]
 pub struct SystemRegistry {
@@ -239,10 +240,19 @@ impl SystemRegistry {
     /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided label
-    pub fn run_systems_by_label<L: SystemLabel + ?Sized>(&mut self, world: &mut World, label: &L) {
+    pub fn run_systems_by_label<L: SystemLabel>(&mut self, world: &mut World, label: L) {
         let boxed_label: Box<dyn SystemLabel> = label.dyn_clone();
+        self.run_systems_by_boxed_label(world, boxed_label);
+    }
 
-        let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {label:?} was found. Did you forget to register it?"}});
+    /// A less ergonomic version of `run_systems_by_label` that allows you to pass in a boxed `SystemLabel`
+    #[inline]
+    pub fn run_systems_by_boxed_label(
+        &mut self,
+        world: &mut World,
+        boxed_label: Box<dyn SystemLabel>,
+    ) {
+        let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {boxed_label:?} was found. Did you forget to register it?"}});
 
         // Loop over the system in registration order
         for index in matching_system_indexes.clone() {
@@ -317,7 +327,7 @@ impl World {
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
     #[inline]
-    pub fn run_systems_by_label<L: SystemLabel + ?Sized>(&mut self, label: &L) {
+    pub fn run_systems_by_label<L: SystemLabel>(&mut self, label: L) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry.run_systems_by_label(world, label);
         });
@@ -370,7 +380,9 @@ pub struct RunSystemsByLabelCommand {
 impl Command for RunSystemsByLabelCommand {
     #[inline]
     fn write(self, world: &mut World) {
-        world.run_systems_by_label(&*self.label)
+        world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_systems_by_boxed_label(world, self.label.dyn_clone())
+        });
     }
 }
 
@@ -403,7 +415,7 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(0));
         world.register_system(count_up, Vec::default());
         world.register_system(count_up, Vec::default());
-        world.run_systems_by_label(&count_up.as_system_label());
+        world.run_systems_by_label(count_up.as_system_label());
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 

From b96c695faee1c51ee4101b456f9274069aa355f2 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 19:44:43 -0400
Subject: [PATCH 017/113] Improve ergonomics of registering systems

---
 crates/bevy_ecs/src/system/system_registry.rs | 74 ++++++++++++++-----
 1 file changed, 55 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 29e5013d58ae4..94c779ac1dd6a 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -102,7 +102,7 @@ use crate::world::{Mut, World};
 /// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
 ///
 /// // You can register systems under multiple labels
-/// system_registry.register_system(&mut world, have_a_nice_day, [ManualSystems::Hello, ManualSystems::Goodbye]);
+/// system_registry.register_system_with_labels(&mut world, have_a_nice_day, [ManualSystems::Hello, ManualSystems::Goodbye]);
 ///
 /// // All systems registered under that label will be run, in registration order
 /// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
@@ -151,26 +151,47 @@ impl SystemRegistry {
     /// If `labels` are provided, the system will be registered under those labels.
     /// Otherwise, it will use the default labels for that system: typically its [`SystemTypeIdLabel`].
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
         &mut self,
         world: &mut World,
         system: S,
-        labels: impl IntoIterator<Item = Box<dyn SystemLabel>>,
+        label: L,
     ) {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
-        let mut labels: Vec<Box<dyn SystemLabel>> = labels.into_iter().collect();
+        self.register_boxed_system_by_labels(world, boxed_system, vec![Box::new(label)]);
+    }
 
-        // If no labels are provided, use the default labels
-        if labels.is_empty() {
-            labels = boxed_system.default_labels()
-        }
+    /// Register system a system with any number of [`SystemLabel`]
+    ///
+    /// This allows the system to be run whenever any of its labels are run using `run_systems_by_label`.
+    pub fn register_system_with_labels<
+        Params,
+        S: IntoSystem<(), (), Params> + 'static,
+        LI: IntoIterator<Item = L>,
+        L: SystemLabel,
+    >(
+        &mut self,
+        world: &mut World,
+        system: S,
+        labels: LI,
+    ) {
+        let boxed_system: Box<dyn System<In = (), Out = ()>> =
+            Box::new(IntoSystem::into_system(system));
+
+        let collected_labels = labels
+            .into_iter()
+            .map(|label| {
+                let boxed_label: Box<dyn SystemLabel> = Box::new(label);
+                boxed_label
+            })
+            .collect();
 
-        self.register_boxed_system_by_labels(world, boxed_system, labels);
+        self.register_boxed_system_by_labels(world, boxed_system, collected_labels);
     }
 
-    /// A more effecient but less ergonomic version of `register_system`
+    /// A more efficient but less ergonomic version of `register_system_with_labels`
     pub fn register_boxed_system_by_labels(
         &mut self,
         world: &mut World,
@@ -285,15 +306,32 @@ impl SystemRegistry {
 impl World {
     /// Registers the supplied system in the [`SystemRegistry`] resource
     ///
-    /// This allows the system to be run by their [`SystemLabel`] using [`World::run_systems_by_label`]
+    /// This allows the system to be run by their [`SystemLabel`] using [`World::run_systems_by_label`].
+    /// If you are using [`World::run_system`] directly, manual registration is not needed.
+    /// The system will be automatically registered under its [`SystemTypeIdLabel`] the first time it is run.
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
         &mut self,
         system: S,
-        labels: Vec<Box<dyn SystemLabel>>,
+        label: L,
     ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system, labels);
+            registry.register_system(world, system, label);
+        });
+    }
+
+    pub fn register_system_with_labels<
+        Params,
+        S: IntoSystem<(), (), Params> + 'static,
+        LI: IntoIterator<Item = L>,
+        L: SystemLabel,
+    >(
+        &mut self,
+        system: S,
+        labels: LI,
+    ) {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.register_system_with_labels(world, system, labels);
         });
     }
 
@@ -408,14 +446,12 @@ mod tests {
 
     #[test]
     fn run_system_by_label() {
-        use crate::system::AsSystemLabel;
-
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system(count_up, Vec::default());
-        world.register_system(count_up, Vec::default());
-        world.run_systems_by_label(count_up.as_system_label());
+        world.register_system(count_up, "count");
+        world.register_system(count_up, "count");
+        world.run_systems_by_label("count");
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 

From 8df48ee89f2f6c60cb2533a24d758574483d9723 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sat, 26 Mar 2022 20:09:41 -0400
Subject: [PATCH 018/113] Note limitations

---
 crates/bevy_ecs/src/system/system_registry.rs | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 94c779ac1dd6a..0f578d606bac3 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -14,7 +14,15 @@ use crate::world::{Mut, World};
 ///
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
-/// Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
+/// This type is stored as a [`Resource`](crate::system::Resource) on each [`World`], initialized by default.
+/// However, it will likely be easier to use the corresponding methods on [`World`],
+/// to avoid having to worry about split mutable borrows yourself.
+///
+/// # Limitations
+///
+///  - stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
+///  - stored systems cannot recurse: they cannot run other systems via the [`SystemRegistry`] methods on `World` or `Commands`.
+///  - exclusive systems cannot be used.
 ///
 /// # Examples
 ///
@@ -55,10 +63,6 @@ use crate::world::{Mut, World};
 ///     for _ in 0..7 {
 ///         commands.spawn().insert(Marker);
 ///     }
-///     
-///     // You can even run systems via commands,
-///     // which will take effect the next time commands are applied
-///     commands.run_system(assert_7_spawned)
 /// }
 ///
 /// fn assert_7_spawned(query: Query<(), Added<Marker>>){
@@ -67,6 +71,7 @@ use crate::world::{Mut, World};
 /// }
 ///
 /// world.run_system(spawn_7_entities);
+/// world.run_system(assert_7_spawned);
 /// ```
 ///
 /// ```rust

From f3d15b00049e859f8658fd694e36e2d7f5715e97 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sun, 17 Apr 2022 22:48:07 -0400
Subject: [PATCH 019/113] Remove the need to manually update archetypes

---
 crates/bevy_ecs/src/system/system_registry.rs | 27 -------------------
 1 file changed, 27 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 0f578d606bac3..b81065e74c13f 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,7 +1,6 @@
 use bevy_utils::HashMap;
 use std::marker::PhantomData;
 
-use crate::archetype::ArchetypeGeneration;
 use crate::schedule::SystemLabel;
 use crate::system::{Command, IntoSystem, System, SystemTypeIdLabel};
 use crate::world::{Mut, World};
@@ -125,27 +124,6 @@ pub struct SystemRegistry {
 
 struct StoredSystem {
     system: Box<dyn System<In = (), Out = ()>>,
-    generation: ArchetypeGeneration,
-}
-
-impl StoredSystem {
-    /// Updates archetypes to ensure our access pointers are correct
-    ///
-    /// This logic must be run after each system is run, as each system can modify archetypes
-    // TODO: remove this method once https://github.com/bevyengine/bevy/pull/4115 is merged
-    fn update_archetypes(&mut self, world: &mut World) {
-        // This logic is borrowed directly from SingleThreadedExecutor
-        let archetypes = world.archetypes();
-        let new_generation = archetypes.generation();
-        let old_generation = std::mem::replace(&mut self.generation, new_generation);
-        self.generation = new_generation;
-
-        let archetype_index_range = old_generation.value()..new_generation.value();
-
-        for archetype in archetypes.archetypes[archetype_index_range].iter() {
-            self.system.new_archetype(archetype);
-        }
-    }
 }
 
 impl SystemRegistry {
@@ -205,12 +183,9 @@ impl SystemRegistry {
     ) {
         // Intialize the system's state
         boxed_system.initialize(world);
-        // Record the archetype generation at the time of its creation
-        let archetype_generation = ArchetypeGeneration::initial();
 
         let stored_system = StoredSystem {
             system: boxed_system,
-            generation: archetype_generation,
         };
 
         // Add the system to the end of the vec
@@ -236,8 +211,6 @@ impl SystemRegistry {
     fn run_system_at_index(&mut self, world: &mut World, index: usize) {
         let ref mut stored_system = self.systems[index];
 
-        // Update the archetypes to make sure our data access is correct
-        stored_system.update_archetypes(world);
         // Run the system
         stored_system.system.run((), world);
         // Apply any generated commands

From 6c59d39c6627fb8484b01bae0af6fd2fa48e13d6 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sun, 17 Apr 2022 23:24:01 -0400
Subject: [PATCH 020/113] Move SystemRegistry to a field on `World`

---
 crates/bevy_ecs/src/system/system_registry.rs | 21 +++++++------------
 crates/bevy_ecs/src/world/mod.rs              |  7 ++++++-
 2 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index b81065e74c13f..89a2dbae5734f 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -13,8 +13,8 @@ use crate::world::{Mut, World};
 ///
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
-/// This type is stored as a [`Resource`](crate::system::Resource) on each [`World`], initialized by default.
-/// However, it will likely be easier to use the corresponding methods on [`World`],
+/// This type is stored as a field on each [`World`].
+/// Geneerally speaking, you should use the corresponding methods on [`World`],
 /// to avoid having to worry about split mutable borrows yourself.
 ///
 /// # Limitations
@@ -293,9 +293,7 @@ impl World {
         system: S,
         label: L,
     ) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system, label);
-        });
+        self.system_registry.register_system(self, system, label);
     }
 
     pub fn register_system_with_labels<
@@ -308,9 +306,8 @@ impl World {
         system: S,
         labels: LI,
     ) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system_with_labels(world, system, labels);
-        });
+        self.system_registry
+            .register_system_with_labels(self, system, labels);
     }
 
     /// Runs the supplied system on the [`World`] a single time
@@ -325,9 +322,7 @@ impl World {
     /// at once, and want parallel execution of these systems.
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system(world, system);
-        });
+        self.system_registry.run_system(self, system);
     }
 
     /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time
@@ -344,9 +339,7 @@ impl World {
     /// at once, and want parallel execution of these systems.
     #[inline]
     pub fn run_systems_by_label<L: SystemLabel>(&mut self, label: L) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_label(world, label);
-        });
+        self.system_registry.run_systems_by_label(self, label);
     }
 }
 
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 3598eaaaea39f..dca1843d61b81 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -70,11 +70,15 @@ pub struct World {
     pub(crate) change_tick: AtomicU32,
     pub(crate) last_change_tick: Tick,
     pub(crate) last_check_tick: Tick,
+    /// Stores the systems associated with this [`World`],
+    ///
+    /// These system can be manually run using [`World::run_system`].
+    pub system_registry: SystemRegistry,
 }
 
 impl Default for World {
     fn default() -> Self {
-        let mut world = Self {
+        World {
             id: WorldId::new().expect("More `bevy` `World`s have been created than is supported"),
             entities: Entities::new(),
             components: Default::default(),
@@ -88,6 +92,7 @@ impl Default for World {
             change_tick: AtomicU32::new(1),
             last_change_tick: Tick::new(0),
             last_check_tick: Tick::new(0),
+            system_registry: Default::default(),
         }
     }
 }

From 1ecf7d40560187794ec963423167e2bfac45ebf7 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Sun, 17 Apr 2022 23:24:01 -0400
Subject: [PATCH 021/113] Revert "Move SystemRegistry to a field on `World`"

This reverts commit ba66966ffaf65557efadbb2e26e353d4b9cd6863.
---
 crates/bevy_ecs/src/system/system_registry.rs | 21 ++++++++++++-------
 crates/bevy_ecs/src/world/mod.rs              |  6 ++++--
 2 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 89a2dbae5734f..b81065e74c13f 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -13,8 +13,8 @@ use crate::world::{Mut, World};
 ///
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
-/// This type is stored as a field on each [`World`].
-/// Geneerally speaking, you should use the corresponding methods on [`World`],
+/// This type is stored as a [`Resource`](crate::system::Resource) on each [`World`], initialized by default.
+/// However, it will likely be easier to use the corresponding methods on [`World`],
 /// to avoid having to worry about split mutable borrows yourself.
 ///
 /// # Limitations
@@ -293,7 +293,9 @@ impl World {
         system: S,
         label: L,
     ) {
-        self.system_registry.register_system(self, system, label);
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.register_system(world, system, label);
+        });
     }
 
     pub fn register_system_with_labels<
@@ -306,8 +308,9 @@ impl World {
         system: S,
         labels: LI,
     ) {
-        self.system_registry
-            .register_system_with_labels(self, system, labels);
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.register_system_with_labels(world, system, labels);
+        });
     }
 
     /// Runs the supplied system on the [`World`] a single time
@@ -322,7 +325,9 @@ impl World {
     /// at once, and want parallel execution of these systems.
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
-        self.system_registry.run_system(self, system);
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_system(world, system);
+        });
     }
 
     /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time
@@ -339,7 +344,9 @@ impl World {
     /// at once, and want parallel execution of these systems.
     #[inline]
     pub fn run_systems_by_label<L: SystemLabel>(&mut self, label: L) {
-        self.system_registry.run_systems_by_label(self, label);
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_systems_by_label(world, label);
+        });
     }
 }
 
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index dca1843d61b81..818e862f9d30c 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -78,7 +78,7 @@ pub struct World {
 
 impl Default for World {
     fn default() -> Self {
-        World {
+        let mut world = Self {
             id: WorldId::new().expect("More `bevy` `World`s have been created than is supported"),
             entities: Entities::new(),
             components: Default::default(),
@@ -92,8 +92,10 @@ impl Default for World {
             change_tick: AtomicU32::new(1),
             last_change_tick: Tick::new(0),
             last_check_tick: Tick::new(0),
-            system_registry: Default::default(),
         }
+       // This resource is required by bevy_ecs itself, so cannot be included in a plugin
+        world.init_resource::<SystemRegistry>();
+        world
     }
 }
 

From 6efb44a095e778535fe2b583d37bd4fbe9a3db31 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 15:34:39 -0400
Subject: [PATCH 022/113] Clippy fixes

---
 crates/bevy_ecs/src/system/function_system.rs | 3 ++-
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 23e72c62fd501..c4d494185689d 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -533,12 +533,13 @@ where
 }
 
 /// A [`SystemLabel`] that was automatically generated for a system on the basis of its `TypeId`.
+#[derive(Default)]
 pub struct SystemTypeIdLabel<T: 'static>(PhantomData<fn() -> T>);
 
 impl<T: 'static> SystemTypeIdLabel<T> {
     /// Constructs a new copy of the [`SystemTypeIdLabel`] for the type `T`
     ///
-    /// You can also construct this by using [`.as_system_label()](crate::system::AsSystemLabel) on a concrete instance
+    /// You can also construct this by using [`.as_system_label()`](crate::system::AsSystemLabel) on a concrete instance
     /// of your function type.
     pub fn new() -> Self {
         Self(PhantomData::default())
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index b81065e74c13f..9b8b09c2402fd 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -209,7 +209,7 @@ impl SystemRegistry {
     /// Runs the system at the supplied `index` a single time
     #[inline]
     fn run_system_at_index(&mut self, world: &mut World, index: usize) {
-        let ref mut stored_system = self.systems[index];
+        let stored_system = &mut self.systems[index];
 
         // Run the system
         stored_system.system.run((), world);
@@ -498,7 +498,7 @@ mod tests {
     #[allow(dead_code)]
     // The `Local` begins at the default value of 0
     fn fibonacci_counting(last_counter: Local<u8>, mut counter: ResMut<Counter>) {
-        counter.0 = *last_counter + counter.0;
+        counter.0 += *last_counter;
     }
 
     #[test]

From 29021bb012cadc0402f422d284be47fe5b4c0677 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 15:48:40 -0400
Subject: [PATCH 023/113] Clippy fix

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 9b8b09c2402fd..ccf238f3ad588 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -397,7 +397,7 @@ impl Command for RunSystemsByLabelCommand {
     #[inline]
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_boxed_label(world, self.label.dyn_clone())
+            registry.run_systems_by_boxed_label(world, self.label.dyn_clone());
         });
     }
 }
@@ -520,7 +520,7 @@ mod tests {
     fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
         counter.0 += 1;
         if counter.0 < 10 {
-            commands.run_system(count_to_ten)
+            commands.run_system(count_to_ten);
         }
     }
 

From a7d0260cd26466ead107ba49176c07b43d10c140 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 15:53:36 -0400
Subject: [PATCH 024/113] System recursion should fail

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index ccf238f3ad588..f342129500f5b 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -525,6 +525,10 @@ mod tests {
     }
 
     #[test]
+    // This is a known limitation;
+    // if this test passes the docs must be updated to reflect this
+    // added functionality
+    #[should_panic]
     fn system_recursion() {
         let mut world = World::new();
         world.init_resource::<Counter>();

From 07e7caa3bc0ffd8bdeeba8a5f25b64160060e52d Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 16:25:32 -0400
Subject: [PATCH 025/113] Documentation improvements

---
 crates/bevy_ecs/src/system/system_registry.rs | 59 +++++++++++--------
 1 file changed, 34 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index f342129500f5b..deb69454611c9 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -19,9 +19,9 @@ use crate::world::{Mut, World};
 ///
 /// # Limitations
 ///
-///  - stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
-///  - stored systems cannot recurse: they cannot run other systems via the [`SystemRegistry`] methods on `World` or `Commands`.
-///  - exclusive systems cannot be used.
+///  - stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values
+///  - stored systems cannot recurse: they cannot run other systems via the [`SystemRegistry`] methods on `World` or `Commands`
+///  - exclusive systems cannot be used
 ///
 /// # Examples
 ///
@@ -73,13 +73,15 @@ use crate::world::{Mut, World};
 /// world.run_system(assert_7_spawned);
 /// ```
 ///
+/// Systems can also be manually registered using [`SystemLabel`] types
+/// and then run via those labels, enabling more sophisticated control flows.
+///
 /// ```rust
 /// use bevy_ecs::prelude::*;
 /// use bevy_ecs::system::SystemRegistry;
 ///
 /// let mut world = World::new();
-/// // The `SystemRegistry` type is automatically included as a resource in every World
-/// let mut system_registry: Mut<SystemRegistry> = world.resource_mut();
+/// let mut system_registry = SystemRegistry::default();
 ///
 /// #[derive(SystemLabel, Debug, PartialEq, Eq, Hash, Clone)]
 /// enum ManualSystems {
@@ -111,7 +113,7 @@ use crate::world::{Mut, World};
 /// // All systems registered under that label will be run, in registration order
 /// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
 ///
-/// // All methods on this type are also exposed on the `World` for convenience
+/// // The methods on this type are also exposed on the `World` for convenience
 /// world.register_system(goodbye, ManualSystems::Goodbye);
 /// world.run_systems_by_label(ManualSystems::Goodbye);
 /// ```
@@ -129,10 +131,13 @@ struct StoredSystem {
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
-    /// This method only needs to be called manually when using [`run_system_by_label`](SystemRegistry).
+    /// Ordinarily, systems are automatically registered when [`run_system`](SystemRegistry::run_system) is called.
+    /// However, manual registration allows you to provide one or more labels for the system.
+    ///
+    /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
+    /// all registered systems that match that label will be evaluated.
     ///
-    /// If `labels` are provided, the system will be registered under those labels.
-    /// Otherwise, it will use the default labels for that system: typically its [`SystemTypeIdLabel`].
+    /// To provide multiple labels, use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
         &mut self,
@@ -143,12 +148,12 @@ impl SystemRegistry {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
-        self.register_boxed_system_by_labels(world, boxed_system, vec![Box::new(label)]);
+        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)]);
     }
 
-    /// Register system a system with any number of [`SystemLabel`]
+    /// Register system a system with any number of [`SystemLabel`]s.
     ///
-    /// This allows the system to be run whenever any of its labels are run using `run_systems_by_label`.
+    /// This allows the system to be run whenever any of its labels are run using [`run_systems_by_label`](SystemRegistry::run_systems_by_label).
     pub fn register_system_with_labels<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
@@ -171,11 +176,15 @@ impl SystemRegistry {
             })
             .collect();
 
-        self.register_boxed_system_by_labels(world, boxed_system, collected_labels);
+        self.register_boxed_system_with_labels(world, boxed_system, collected_labels);
     }
 
-    /// A more efficient but less ergonomic version of `register_system_with_labels`
-    pub fn register_boxed_system_by_labels(
+    /// A more exacting version of [`register_system_with_labels`](Self::register_system_with_labels).
+    ///
+    /// This can be useful when you have a boxed system or boxed labels,
+    /// as the corresponding traits are not implemented for boxed trait objects
+    /// to avoid indefinite nesting.
+    pub fn register_boxed_system_with_labels(
         &mut self,
         world: &mut World,
         mut boxed_system: Box<dyn System<In = (), Out = ()>>,
@@ -217,9 +226,9 @@ impl SystemRegistry {
         stored_system.system.apply_buffers(world);
     }
 
-    /// Returns true if at least one system in the [`SystemRegistry`] is associated with the provided [`SystemLabel`].
+    /// Is at least one system in the [`SystemRegistry`] is associated with the provided [`SystemLabel`]?
     #[inline]
-    pub fn label_registered<L: SystemLabel>(&self, label: L) -> bool {
+    pub fn is_label_registered<L: SystemLabel>(&self, label: L) -> bool {
         let boxed_label: Box<dyn SystemLabel> = Box::new(label);
         self.labels.get(&boxed_label).is_some()
     }
@@ -244,13 +253,13 @@ impl SystemRegistry {
         self.run_systems_by_boxed_label(world, boxed_label);
     }
 
-    /// A less ergonomic version of `run_systems_by_label` that allows you to pass in a boxed `SystemLabel`
+    /// A more exacting version of [`run_systems_by_label`](Self::run_systems_by_label).
+    ///
+    /// This can be useful when you have boxed labels,
+    /// as [`SystemLabel`] is not implemented for boxed trait objects
+    /// to avoid indefinite nesting.
     #[inline]
-    pub fn run_systems_by_boxed_label(
-        &mut self,
-        world: &mut World,
-        boxed_label: Box<dyn SystemLabel>,
-    ) {
+    fn run_systems_by_boxed_label(&mut self, world: &mut World, boxed_label: Box<dyn SystemLabel>) {
         let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {boxed_label:?} was found. Did you forget to register it?"}});
 
         // Loop over the system in registration order
@@ -271,11 +280,11 @@ impl SystemRegistry {
     ) {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
-        if !self.label_registered(automatic_system_label) {
+        if !self.is_label_registered(automatic_system_label) {
             let boxed_system: Box<dyn System<In = (), Out = ()>> =
                 Box::new(IntoSystem::into_system(system));
             let labels = boxed_system.default_labels();
-            self.register_boxed_system_by_labels(world, boxed_system, labels);
+            self.register_boxed_system_with_labels(world, boxed_system, labels);
         }
         self.run_system_at_index(world, self.first_registered_index(automatic_system_label));
     }

From 23b0768c64b081f2f7880aff6c8d3fee230a6e03 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 22:13:38 -0400
Subject: [PATCH 026/113] Nicer error handling

---
 crates/bevy_ecs/src/system/system_registry.rs | 73 +++++++++++++------
 1 file changed, 50 insertions(+), 23 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index deb69454611c9..d7003289bb2e7 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -233,24 +233,24 @@ impl SystemRegistry {
         self.labels.get(&boxed_label).is_some()
     }
 
-    /// Returns the first matching index for systems with this label
-    ///
-    /// # Panics
-    ///
-    /// Panics if no system with the label is registered.
+    /// Returns the first matching index for systems with this label if any
     #[inline]
-    fn first_registered_index<L: SystemLabel>(&self, label: L) -> usize {
+    fn first_registered_index<L: SystemLabel>(&self, label: L) -> Option<usize> {
         let boxed_label: Box<dyn SystemLabel> = Box::new(label);
-        let vec_of_indexes = self.labels.get(&boxed_label).unwrap();
-        *vec_of_indexes.iter().next().unwrap()
+        let vec_of_indexes = self.labels.get(&boxed_label)?;
+        vec_of_indexes.iter().next().copied()
     }
 
     /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided label
-    pub fn run_systems_by_label<L: SystemLabel>(&mut self, world: &mut World, label: L) {
+    pub fn run_systems_by_label<L: SystemLabel>(
+        &mut self,
+        world: &mut World,
+        label: L,
+    ) -> Result<(), SystemRegistryError> {
         let boxed_label: Box<dyn SystemLabel> = label.dyn_clone();
-        self.run_systems_by_boxed_label(world, boxed_label);
+        self.run_systems_by_boxed_label(world, boxed_label)
     }
 
     /// A more exacting version of [`run_systems_by_label`](Self::run_systems_by_label).
@@ -259,12 +259,21 @@ impl SystemRegistry {
     /// as [`SystemLabel`] is not implemented for boxed trait objects
     /// to avoid indefinite nesting.
     #[inline]
-    fn run_systems_by_boxed_label(&mut self, world: &mut World, boxed_label: Box<dyn SystemLabel>) {
-        let matching_system_indexes = self.labels.get(&boxed_label).unwrap_or_else(||{panic!{"No system with the `SystemLabel` {boxed_label:?} was found. Did you forget to register it?"}});
-
-        // Loop over the system in registration order
-        for index in matching_system_indexes.clone() {
-            self.run_system_at_index(world, index);
+    fn run_systems_by_boxed_label(
+        &mut self,
+        world: &mut World,
+        boxed_label: Box<dyn SystemLabel>,
+    ) -> Result<(), SystemRegistryError> {
+        match self.labels.get(&boxed_label) {
+            Some(matching_indexes) => {
+                // Loop over the system in registration order
+                for index in matching_indexes.clone() {
+                    self.run_system_at_index(world, index);
+                }
+
+                Ok(())
+            }
+            None => Err(SystemRegistryError::LabelNotFound(boxed_label)),
         }
     }
 
@@ -279,14 +288,16 @@ impl SystemRegistry {
         system: S,
     ) {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
-
         if !self.is_label_registered(automatic_system_label) {
             let boxed_system: Box<dyn System<In = (), Out = ()>> =
                 Box::new(IntoSystem::into_system(system));
             let labels = boxed_system.default_labels();
             self.register_boxed_system_with_labels(world, boxed_system, labels);
         }
-        self.run_system_at_index(world, self.first_registered_index(automatic_system_label));
+        // System was registered above, so we can unwrap safely
+        let index = self.first_registered_index(automatic_system_label).unwrap();
+
+        self.run_system_at_index(world, index);
     }
 }
 
@@ -352,10 +363,13 @@ impl World {
     /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
     /// at once, and want parallel execution of these systems.
     #[inline]
-    pub fn run_systems_by_label<L: SystemLabel>(&mut self, label: L) {
+    pub fn run_systems_by_label<L: SystemLabel>(
+        &mut self,
+        label: L,
+    ) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_label(world, label);
-        });
+            return registry.run_systems_by_label(world, label);
+        })
     }
 }
 
@@ -406,11 +420,24 @@ impl Command for RunSystemsByLabelCommand {
     #[inline]
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_boxed_label(world, self.label.dyn_clone());
+            registry
+                .run_systems_by_boxed_label(world, self.label.dyn_clone())
+                // Ideally this error should be handled more gracefully,
+                // but that's blocked on a full error handling solution for commands
+                .unwrap();
         });
     }
 }
 
+/// An operation on a [`SystemRegistry`] failed
+#[derive(Debug)]
+pub enum SystemRegistryError {
+    /// A system was run by label, but no system with that label was found.
+    ///
+    /// Did you forget to register it?
+    LabelNotFound(Box<dyn SystemLabel>),
+}
+
 mod tests {
     use crate::prelude::*;
 
@@ -438,7 +465,7 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(0));
         world.register_system(count_up, "count");
         world.register_system(count_up, "count");
-        world.run_systems_by_label("count");
+        world.run_systems_by_label("count").unwrap();
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 

From 273113bd369b353d345891d983a83566e6174381 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 22:25:27 -0400
Subject: [PATCH 027/113] Return index from register system methods

---
 crates/bevy_ecs/src/system/system_registry.rs | 35 +++++++++++++------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index d7003289bb2e7..5b501891fa215 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -132,10 +132,15 @@ impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
     /// Ordinarily, systems are automatically registered when [`run_system`](SystemRegistry::run_system) is called.
+    /// When this occurs, they will be registered using their [`SystemTypeIdLabel`].
     /// However, manual registration allows you to provide one or more labels for the system.
+    /// This also allows you to register multiple distinct copies of the system under distinct labels.
     ///
     /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
-    /// all registered systems that match that label will be evaluated.
+    /// all registered systems that match that label will be evaluated (in insertion order).
+    ///
+    /// Returns the index in the vector of systems that this new system is stored at.
+    /// This is only useful for debugging as an external user of this method.
     ///
     /// To provide multiple labels, use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
@@ -144,15 +149,18 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
         label: L,
-    ) {
+    ) -> usize {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
-        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)]);
+        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)])
     }
 
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
+    /// Returns the index in the vector of systems that this new system is stored at.
+    /// This is only useful for debugging as an external user of this method.
+    ///
     /// This allows the system to be run whenever any of its labels are run using [`run_systems_by_label`](SystemRegistry::run_systems_by_label).
     pub fn register_system_with_labels<
         Params,
@@ -164,7 +172,7 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
         labels: LI,
-    ) {
+    ) -> usize {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
@@ -176,11 +184,14 @@ impl SystemRegistry {
             })
             .collect();
 
-        self.register_boxed_system_with_labels(world, boxed_system, collected_labels);
+        self.register_boxed_system_with_labels(world, boxed_system, collected_labels)
     }
 
     /// A more exacting version of [`register_system_with_labels`](Self::register_system_with_labels).
     ///
+    /// Returns the index in the vector of systems that this new system is stored at.
+    /// This is only useful for debugging as an external user of this method.
+    ///
     /// This can be useful when you have a boxed system or boxed labels,
     /// as the corresponding traits are not implemented for boxed trait objects
     /// to avoid indefinite nesting.
@@ -189,7 +200,7 @@ impl SystemRegistry {
         world: &mut World,
         mut boxed_system: Box<dyn System<In = (), Out = ()>>,
         labels: Vec<Box<dyn SystemLabel>>,
-    ) {
+    ) -> usize {
         // Intialize the system's state
         boxed_system.initialize(world);
 
@@ -213,6 +224,8 @@ impl SystemRegistry {
                 self.labels.insert(label, vec![system_index]);
             };
         }
+
+        system_index
     }
 
     /// Runs the system at the supplied `index` a single time
@@ -288,14 +301,14 @@ impl SystemRegistry {
         system: S,
     ) {
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
-        if !self.is_label_registered(automatic_system_label) {
+        let index = if self.is_label_registered(automatic_system_label) {
+            self.first_registered_index(automatic_system_label).unwrap()
+        } else {
             let boxed_system: Box<dyn System<In = (), Out = ()>> =
                 Box::new(IntoSystem::into_system(system));
             let labels = boxed_system.default_labels();
-            self.register_boxed_system_with_labels(world, boxed_system, labels);
-        }
-        // System was registered above, so we can unwrap safely
-        let index = self.first_registered_index(automatic_system_label).unwrap();
+            self.register_boxed_system_with_labels(world, boxed_system, labels)
+        };
 
         self.run_system_at_index(world, index);
     }

From bbe6dc6f4a3cd9415ea9655f09e297b574ed6bd0 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 22:34:03 -0400
Subject: [PATCH 028/113] Fix off by one error

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 5b501891fa215..7ccdcc87e528c 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -209,8 +209,8 @@ impl SystemRegistry {
         };
 
         // Add the system to the end of the vec
-        self.systems.push(stored_system);
         let system_index = self.systems.len();
+        self.systems.push(stored_system);
 
         // For each label that the system has
         for label in labels {

From 0c4bfb517af4b03e64254097610a30dfd3adcd3b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 22:43:10 -0400
Subject: [PATCH 029/113] Reduce noisy returns

---
 crates/bevy_ecs/src/system/system_registry.rs | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 7ccdcc87e528c..833567c2c0788 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -139,9 +139,6 @@ impl SystemRegistry {
     /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
     /// all registered systems that match that label will be evaluated (in insertion order).
     ///
-    /// Returns the index in the vector of systems that this new system is stored at.
-    /// This is only useful for debugging as an external user of this method.
-    ///
     /// To provide multiple labels, use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
@@ -149,18 +146,15 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
         label: L,
-    ) -> usize {
+    ) {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
-        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)])
+        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)]);
     }
 
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
-    /// Returns the index in the vector of systems that this new system is stored at.
-    /// This is only useful for debugging as an external user of this method.
-    ///
     /// This allows the system to be run whenever any of its labels are run using [`run_systems_by_label`](SystemRegistry::run_systems_by_label).
     pub fn register_system_with_labels<
         Params,
@@ -172,7 +166,7 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
         labels: LI,
-    ) -> usize {
+    ) {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
 
@@ -184,7 +178,7 @@ impl SystemRegistry {
             })
             .collect();
 
-        self.register_boxed_system_with_labels(world, boxed_system, collected_labels)
+        self.register_boxed_system_with_labels(world, boxed_system, collected_labels);
     }
 
     /// A more exacting version of [`register_system_with_labels`](Self::register_system_with_labels).
@@ -381,7 +375,7 @@ impl World {
         label: L,
     ) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            return registry.run_systems_by_label(world, label);
+            registry.run_systems_by_label(world, label)
         })
     }
 }

From 6e45a31ee5d94d0e3df5f2d689dc12355dbc211c Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 23:09:50 -0400
Subject: [PATCH 030/113] Fix broken tests

---
 crates/bevy_ecs/src/system/system_registry.rs | 95 ++++++++++---------
 1 file changed, 52 insertions(+), 43 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 833567c2c0788..5bf48a3af03c2 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -465,6 +465,19 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(1));
     }
 
+    #[test]
+    /// We need to ensure that the system registry is accessible
+    /// even after being used once.
+    fn run_two_systems() {
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        world.run_system(count_up);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        world.run_system(count_up);
+        assert_eq!(*world.resource::<Counter>(), Counter(2));
+    }
+
     #[test]
     fn run_system_by_label() {
         let mut world = World::new();
@@ -473,6 +486,7 @@ mod tests {
         world.register_system(count_up, "count");
         world.register_system(count_up, "count");
         world.run_systems_by_label("count").unwrap();
+        // All systems matching the label will be run.
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
@@ -490,38 +504,34 @@ mod tests {
         assert_eq!(world.entities.len(), 1);
     }
 
-    fn non_send_count_down(mut ns: NonSendMut<Counter>) {
-        ns.0 -= 1;
-    }
-
-    #[allow(dead_code)]
-    fn trigger_non_send_count_down(mut commands: Commands) {
-        commands.run_system(non_send_count_down);
-    }
-
     #[test]
     fn non_send_resources() {
+        fn non_send_count_down(mut ns: NonSendMut<Counter>) {
+            ns.0 -= 1;
+        }
+
         let mut world = World::new();
         world.insert_non_send_resource(Counter(10));
         assert_eq!(*world.non_send_resource::<Counter>(), Counter(10));
         world.run_system(non_send_count_down);
         assert_eq!(*world.non_send_resource::<Counter>(), Counter(9));
-        world.run_system(trigger_non_send_count_down);
-        assert_eq!(*world.non_send_resource::<Counter>(), Counter(8));
-    }
-
-    #[derive(Default)]
-    struct ChangeDetector;
-
-    #[allow(dead_code)]
-    fn count_up_iff_changed(mut commands: Commands, change_detector: ResMut<ChangeDetector>) {
-        if change_detector.is_changed() {
-            commands.run_system(count_up);
-        }
     }
 
     #[test]
     fn change_detection() {
+        #[derive(Default)]
+        struct ChangeDetector;
+
+        #[allow(dead_code)]
+        fn count_up_iff_changed(
+            mut counter: ResMut<Counter>,
+            change_detector: ResMut<ChangeDetector>,
+        ) {
+            if change_detector.is_changed() {
+                counter.0 += 1;
+            }
+        }
+
         let mut world = World::new();
         world.init_resource::<ChangeDetector>();
         world.init_resource::<Counter>();
@@ -538,41 +548,40 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
-    #[allow(dead_code)]
-    // The `Local` begins at the default value of 0
-    fn fibonacci_counting(last_counter: Local<u8>, mut counter: ResMut<Counter>) {
-        counter.0 += *last_counter;
-    }
-
     #[test]
     fn local_variables() {
+        // The `Local` begins at the default value of 0
+        fn doubling(mut last_counter: Local<Counter>, mut counter: ResMut<Counter>) {
+            counter.0 += last_counter.0;
+            last_counter.0 = counter.0;
+        }
+
         let mut world = World::new();
         world.insert_resource(Counter(1));
         assert_eq!(*world.resource::<Counter>(), Counter(1));
-        world.run_system(fibonacci_counting);
+        world.run_system(doubling);
         assert_eq!(*world.resource::<Counter>(), Counter(1));
-        world.run_system(fibonacci_counting);
+        world.run_system(doubling);
         assert_eq!(*world.resource::<Counter>(), Counter(2));
-        world.run_system(fibonacci_counting);
-        assert_eq!(*world.resource::<Counter>(), Counter(3));
-        world.run_system(fibonacci_counting);
-        assert_eq!(*world.resource::<Counter>(), Counter(5));
-    }
-
-    #[allow(dead_code)]
-    fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
-        counter.0 += 1;
-        if counter.0 < 10 {
-            commands.run_system(count_to_ten);
-        }
+        world.run_system(doubling);
+        assert_eq!(*world.resource::<Counter>(), Counter(4));
+        world.run_system(doubling);
+        assert_eq!(*world.resource::<Counter>(), Counter(8));
     }
 
     #[test]
     // This is a known limitation;
-    // if this test passes the docs must be updated to reflect this
-    // added functionality
+    // if this test passes the docs must be updated
+    // to reflect the ability to chain run_system commands
     #[should_panic]
     fn system_recursion() {
+        fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
+            counter.0 += 1;
+            if counter.0 < 10 {
+                commands.run_system(count_to_ten);
+            }
+        }
+
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));

From 085a21d460a7900aacc26c5f94b6f301526780df Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 23:55:48 -0400
Subject: [PATCH 031/113] Add example

---
 Cargo.toml                       | 10 ++++
 examples/README.md               | 14 +++++
 examples/ecs/one_shot_systems.rs | 98 ++++++++++++++++++++++++++++++++
 3 files changed, 122 insertions(+)
 create mode 100644 examples/ecs/one_shot_systems.rs

diff --git a/Cargo.toml b/Cargo.toml
index 35a675b62f244..eed62f7deef76 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1254,6 +1254,16 @@ description = "Shows how to iterate over combinations of query results"
 category = "ECS (Entity Component System)"
 wasm = true
 
+[[example]]
+name = "one_shot_systems"
+path = "examples/ecs/one_shot_systems.rs"
+
+[package.metadata.example.one_shot_systems]
+name = "One Shot Systems"
+description = "Shows how to flexibly run systems without scheduling them"
+category = "ECS (Entity Component System)"
+wasm = false
+
 [[example]]
 name = "parallel_query"
 path = "examples/ecs/parallel_query.rs"
diff --git a/examples/README.md b/examples/README.md
index 6f53c34f7048c..05a0969f38faa 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -57,6 +57,19 @@ git checkout v0.4.0
   - [Transforms](#transforms)
   - [UI (User Interface)](#ui-user-interface)
   - [Window](#window)
+- [Tests](#tests)
+- [Platform-Specific Examples](#platform-specific-examples)
+  - [Android](#android)
+    - [Setup](#setup)
+    - [Build & Run](#build--run)
+    - [Old phones](#old-phones)
+  - [iOS](#ios)
+    - [Setup](#setup-1)
+    - [Build & Run](#build--run-1)
+  - [WASM](#wasm)
+    - [Setup](#setup-2)
+    - [Build & Run](#build--run-2)
+    - [Loading Assets](#loading-assets)
 
 - [Tests](#tests)
 - [Platform-Specific Examples](#platform-specific-examples)
@@ -220,6 +233,7 @@ Example | Description
 [Hierarchy](../examples/ecs/hierarchy.rs) | Creates a hierarchy of parents and children entities
 [Iter Combinations](../examples/ecs/iter_combinations.rs) | Shows how to iterate over combinations of query results
 [Nondeterministic System Order](../examples/ecs/nondeterministic_system_order.rs) | Systems run in parallel, but their order isn't always deterministic. Here's how to detect and fix this.
+[One Shot Systems](../examples/ecs/one_shot_systems.rs) | Shows how to flexibly run systems without scheduling them
 [Parallel Query](../examples/ecs/parallel_query.rs) | Illustrates parallel queries with `ParallelIterator`
 [Removal Detection](../examples/ecs/removal_detection.rs) | Query for entities that had a specific component removed earlier in the current frame
 [Run Conditions](../examples/ecs/run_conditions.rs) | Run systems only when one or multiple conditions are met
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
new file mode 100644
index 0000000000000..5a815d2c33a66
--- /dev/null
+++ b/examples/ecs/one_shot_systems.rs
@@ -0,0 +1,98 @@
+//! Demonstrates the use of "one-shot systems", which run once when triggered
+//!
+//! These can be useful to help structure your logic in a push-based fashion,
+//! reducing the overhead of running extremely rarely run systems
+//! and improving schedule flexibility.
+//!
+//! See the [`SystemRegistry`](bevy::ecs::SystemRegistry) docs for more details.
+
+use bevy::ecs::schedule::IntoSystemDescriptor;
+use bevy::ecs::system::SystemTypeIdLabel;
+use bevy::prelude::*;
+
+fn main() {
+    App::new()
+        .add_startup_system(setup)
+        // One shot systems are interchangeable with ordinarily scheduled systems.
+        // Change detection, Local and NonSend all work as expected
+        .add_system_to_stage(CoreStage::PostUpdate, count_entities)
+        // Registered systems can be called dynamically by their label
+        // These must be registered in advance, or commands.run_system will panic
+        // as no matching system was found
+        .register_system(button_pressed)
+        .register_system(slider_toggled)
+        // One-shot systems can be used to build complex abstractions
+        // to match the needs of your design.
+        // Here, we model a very simple system-powered callback architecture.
+        .add_system(trigger_callbacks)
+        .add_system(evaluate_callbacks.after(trigger_callbacks))
+        .run();
+}
+
+// Any ordinary system can be run via commands.run_system or world.run_system
+//
+// Chained systems, exclusive systems and systems which themselves run systems cannot be called in this way.
+fn count_entities(all_entities: Query<()>) {
+    dbg!(all_entities.iter().count());
+}
+
+fn setup(mut commands: Commands) {
+    // commands.run_system is evaluated in sequence
+    commands.run_system(count_entities); // Reports 0 entities
+    commands.spawn().insert(Callback::new(button_pressed));
+    commands.spawn().insert(Callback::new(slider_toggled));
+    commands.run_system(count_entities); // Reports 2 entities, as the previous command will be processed by the time this has evaluated
+}
+
+fn button_pressed() {
+    println!("A button was pressed!")
+}
+
+fn slider_toggled() {
+    println!("A slider was toggled!")
+}
+
+// When creating abstractions built on one-shot systems,
+// storing system labels is the way to go.
+// Don't try to store boxed System trait objects!
+#[derive(Component)]
+struct Callback {
+    triggered: bool,
+    label: Box<dyn SystemLabel>,
+}
+
+impl Callback {
+    // We can pass in a system as our function argument to automatically generate the correct label.
+    // Alternatively, you can create an API that takes an explicit `SystemLabel`, and users can control
+    // exactly how the system should be called.
+    fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(system: S) -> Self {
+        Callback {
+            triggered: false,
+            label: Box::new(SystemTypeIdLabel::<S>::new()),
+        }
+    }
+}
+
+// These callbacks could easily be triggered via events, button interactions or so on
+// or even stored directly in the event type
+fn trigger_callbacks(query: Query<&mut Callback>) {
+    for mut callback in query.iter_mut() {
+        callback.triggered = true;
+    }
+}
+
+/// Runs the systems associated with each Callback component
+///
+/// This could also be done in an exclusive system,
+/// but the borrow checker is more frustrating
+fn evaluate_callbacks(query: Query<&Callback>, mut commands: Commands) {
+    for callback in query.iter() {
+        if callback.triggered {
+            // Because we don't have access to the type information of the callbacks
+            // we have to use the layer of indirection provided by system labels
+            // Note that if we had registered multiple systems with the same label,
+            // they would all be evaluated here.
+            commands.run_systems_by_label(callback.label);
+        }
+    }
+}

From 2316077cf17dc5f998fd3a35472d52837c82f21e Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:12:08 -0400
Subject: [PATCH 032/113] Improve ergonomics of register_system method

---
 crates/bevy_ecs/src/system/system_registry.rs | 66 +++++++++----------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 5bf48a3af03c2..7b50ef36190fc 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,3 +1,4 @@
+use bevy_utils::tracing::warn;
 use bevy_utils::HashMap;
 use std::marker::PhantomData;
 
@@ -131,6 +132,9 @@ struct StoredSystem {
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
+    /// This allows the system to be run by their [`SystemTypeIdLabel`] using the `run_systems_by_label` method.
+    /// Repeatedly registering a system will have no effect.
+    ///
     /// Ordinarily, systems are automatically registered when [`run_system`](SystemRegistry::run_system) is called.
     /// When this occurs, they will be registered using their [`SystemTypeIdLabel`].
     /// However, manual registration allows you to provide one or more labels for the system.
@@ -139,23 +143,38 @@ impl SystemRegistry {
     /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
     /// all registered systems that match that label will be evaluated (in insertion order).
     ///
-    /// To provide multiple labels, use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
+    /// To provide explicit label(s), use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
-        label: L,
     ) {
         let boxed_system: Box<dyn System<In = (), Out = ()>> =
             Box::new(IntoSystem::into_system(system));
+        let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
-        self.register_boxed_system_with_labels(world, boxed_system, vec![Box::new(label)]);
+        // This avoids nasty surprising behavior in case systems are registered twice
+        if !self.is_label_registered(automatic_system_label) {
+            self.register_boxed_system_with_labels(
+                world,
+                boxed_system,
+                vec![Box::new(automatic_system_label)],
+            );
+        } else {
+            let type_name = std::any::type_name::<S>();
+            warn!("A system of type {type_name} was registered more than once!");
+        };
     }
 
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
     /// This allows the system to be run whenever any of its labels are run using [`run_systems_by_label`](SystemRegistry::run_systems_by_label).
+    ///
+    /// # Warning
+    ///
+    /// Unlike the `register_system` method, duplicate systems may be added;
+    /// each copy will be called seperately if they share a label.
     pub fn register_system_with_labels<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
@@ -311,20 +330,17 @@ impl SystemRegistry {
 impl World {
     /// Registers the supplied system in the [`SystemRegistry`] resource
     ///
-    /// This allows the system to be run by their [`SystemLabel`] using [`World::run_systems_by_label`].
-    /// If you are using [`World::run_system`] directly, manual registration is not needed.
-    /// The system will be automatically registered under its [`SystemTypeIdLabel`] the first time it is run.
+    /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static, L: SystemLabel>(
-        &mut self,
-        system: S,
-        label: L,
-    ) {
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system, label);
+            registry.register_system(world, system);
         });
     }
 
+    /// Register system a system with any number of [`SystemLabel`]s.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`].
     pub fn register_system_with_labels<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
@@ -342,14 +358,7 @@ impl World {
 
     /// Runs the supplied system on the [`World`] a single time
     ///
-    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
-    ///
-    /// The system's state will be cached: any future calls using the same type will use this state,
-    /// improving performance and ensuring that change detection works properly.
-    ///
-    /// This is evaluated in a sequential, single-threaded fashion.
-    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
-    /// at once, and want parallel execution of these systems.
+    /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
@@ -359,16 +368,7 @@ impl World {
 
     /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time
     ///
-    /// Systems must be registered before they can be run by their label.
-    ///
-    /// Any [`Commands`](crate::system::Commands) generated will also be applied to the world immediately.
-    ///
-    /// The system's state will be cached: any future calls using the same type will use this state,
-    /// improving performance and ensuring that change detection works properly.
-    ///
-    /// This is evaluated in a sequential, single-threaded fashion.
-    /// Consider creating and running a [`Schedule`](crate::schedule::Schedule) if you need to execute large groups of systems
-    /// at once, and want parallel execution of these systems.
+    /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
     pub fn run_systems_by_label<L: SystemLabel>(
         &mut self,
@@ -483,8 +483,8 @@ mod tests {
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system(count_up, "count");
-        world.register_system(count_up, "count");
+        world.register_system_with_labels(count_up, ["count"]);
+        world.register_system_with_labels(count_up, ["count"]);
         world.run_systems_by_label("count").unwrap();
         // All systems matching the label will be run.
         assert_eq!(*world.resource::<Counter>(), Counter(2));

From ccbe49f3078614802461e357a9fab60f0ce8de2f Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:19:29 -0400
Subject: [PATCH 033/113] Formatting

---
 crates/bevy_ecs/src/system/system_registry.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 7b50ef36190fc..9d8b6afdc1a53 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -241,7 +241,7 @@ impl SystemRegistry {
         system_index
     }
 
-    /// Runs the system at the supplied `index` a single time
+    /// Runs the system at the supplied `index` a single time.
     #[inline]
     fn run_system_at_index(&mut self, world: &mut World, index: usize) {
         let stored_system = &mut self.systems[index];
@@ -259,7 +259,7 @@ impl SystemRegistry {
         self.labels.get(&boxed_label).is_some()
     }
 
-    /// Returns the first matching index for systems with this label if any
+    /// Returns the first matching index for systems with this label if any.
     #[inline]
     fn first_registered_index<L: SystemLabel>(&self, label: L) -> Option<usize> {
         let boxed_label: Box<dyn SystemLabel> = Box::new(label);
@@ -267,9 +267,9 @@ impl SystemRegistry {
         vec_of_indexes.iter().next().copied()
     }
 
-    /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time
+    /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time.
     ///
-    /// Systems will be run sequentially in registration order if more than one registered system matches the provided label
+    /// Systems will be run sequentially in registration order if more than one registered system matches the provided label.
     pub fn run_systems_by_label<L: SystemLabel>(
         &mut self,
         world: &mut World,
@@ -303,7 +303,7 @@ impl SystemRegistry {
         }
     }
 
-    /// Runs the supplied system on the [`World`] a single time
+    /// Runs the supplied system on the [`World`] a single time.
     ///
     /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
     /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeIdLabel`],
@@ -328,7 +328,7 @@ impl SystemRegistry {
 }
 
 impl World {
-    /// Registers the supplied system in the [`SystemRegistry`] resource
+    /// Registers the supplied system in the [`SystemRegistry`] resource.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
@@ -356,7 +356,7 @@ impl World {
         });
     }
 
-    /// Runs the supplied system on the [`World`] a single time
+    /// Runs the supplied system on the [`World`] a single time.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
@@ -366,7 +366,7 @@ impl World {
         });
     }
 
-    /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time
+    /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]

From f9d03483e4ea6bd3f3ca8c93758283adfc635703 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:23:16 -0400
Subject: [PATCH 034/113] Expose run_systems_by_boxed_label method

---
 crates/bevy_ecs/src/system/commands/mod.rs    | 16 ++++++++++++--
 crates/bevy_ecs/src/system/system_registry.rs | 21 +++++++++++++++----
 examples/ecs/one_shot_systems.rs              |  2 +-
 3 files changed, 32 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index bfd959caabc50..52704dcc28a6f 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -523,7 +523,9 @@ impl<'w, 's> Commands<'w, 's> {
         self.queue.push(RemoveResource::<R>::new());
     }
 
-    /// Calls [`World::run_system`]
+    /// Runs the supplied system on the [`World`] a single time.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
     pub fn run_system<
         Params: Send + Sync + 'static,
         S: IntoSystem<(), (), Params> + Send + Sync + 'static,
@@ -534,13 +536,23 @@ impl<'w, 's> Commands<'w, 's> {
         self.queue.push(RunSystemCommand::new(system));
     }
 
-    /// Calls [`World::run_system_by_type_id`]
+    /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
     pub fn run_systems_by_label(&mut self, label: impl SystemLabel) {
         self.queue.push(RunSystemsByLabelCommand {
             label: Box::new(label),
         });
     }
 
+    /// A trait-object compatible version of `run_systems_by_label`.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
+    pub fn run_systems_by_boxed_label(&mut self, boxed_label: Box<dyn SystemLabel>) {
+        self.queue
+            .push(RunSystemsByLabelCommand { label: boxed_label });
+    }
+
     /// Pushes a generic [`Command`] to the command queue.
     ///
     /// `command` can be a built-in command, custom struct that implements [`Command`] or a closure
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 9d8b6afdc1a53..aaad3b1a98290 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -279,13 +279,13 @@ impl SystemRegistry {
         self.run_systems_by_boxed_label(world, boxed_label)
     }
 
-    /// A more exacting version of [`run_systems_by_label`](Self::run_systems_by_label).
+    /// A trait-object compatible version of `run_systems_by_label`.
     ///
-    /// This can be useful when you have boxed labels,
+    /// This can be useful for more abstract designs that rely on boxed labels,
     /// as [`SystemLabel`] is not implemented for boxed trait objects
     /// to avoid indefinite nesting.
     #[inline]
-    fn run_systems_by_boxed_label(
+    pub fn run_systems_by_boxed_label(
         &mut self,
         world: &mut World,
         boxed_label: Box<dyn SystemLabel>,
@@ -366,7 +366,7 @@ impl World {
         });
     }
 
-    /// Runs the system corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
+    /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
@@ -378,6 +378,19 @@ impl World {
             registry.run_systems_by_label(world, label)
         })
     }
+
+    /// A trait-object compatible version of `run_systems_by_label`.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`].
+    #[inline]
+    pub fn run_systems_by_boxed_label(
+        &mut self,
+        boxed_label: Box<dyn SystemLabel>,
+    ) -> Result<(), SystemRegistryError> {
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_systems_by_boxed_label(world, boxed_label)
+        })
+    }
 }
 
 /// The [`Command`] type for [`SystemRegistry::run_system`]
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 5a815d2c33a66..52d9735138c4e 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -92,7 +92,7 @@ fn evaluate_callbacks(query: Query<&Callback>, mut commands: Commands) {
             // we have to use the layer of indirection provided by system labels
             // Note that if we had registered multiple systems with the same label,
             // they would all be evaluated here.
-            commands.run_systems_by_label(callback.label);
+            commands.run_systems_by_boxed_label(callback.label);
         }
     }
 }

From 184cd6baba3da2b018358ee0d5d3f6b155508356 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:31:30 -0400
Subject: [PATCH 035/113] Create matching methods on App

---
 crates/bevy_app/src/lib.rs             |  1 +
 crates/bevy_app/src/system_registry.rs | 68 ++++++++++++++++++++++++++
 2 files changed, 69 insertions(+)
 create mode 100644 crates/bevy_app/src/system_registry.rs

diff --git a/crates/bevy_app/src/lib.rs b/crates/bevy_app/src/lib.rs
index 3439620a46633..e317086a452c6 100644
--- a/crates/bevy_app/src/lib.rs
+++ b/crates/bevy_app/src/lib.rs
@@ -8,6 +8,7 @@ mod main_schedule;
 mod plugin;
 mod plugin_group;
 mod schedule_runner;
+mod system_registry;
 
 #[cfg(feature = "bevy_ci_testing")]
 pub mod ci_testing;
diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
new file mode 100644
index 0000000000000..2941b91d3fa3c
--- /dev/null
+++ b/crates/bevy_app/src/system_registry.rs
@@ -0,0 +1,68 @@
+use crate::App;
+use bevy_ecs::prelude::*;
+use bevy_ecs::system::SystemRegistryError;
+
+impl App {
+    /// Registers the supplied system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry) resource.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    #[inline]
+    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        system: S,
+    ) -> &mut Self {
+        self.world.register_system(system);
+        self
+    }
+
+    /// Register system a system with any number of [`SystemLabel`]s.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`].
+    pub fn register_system_with_labels<
+        Params,
+        S: IntoSystem<(), (), Params> + 'static,
+        LI: IntoIterator<Item = L>,
+        L: SystemLabel,
+    >(
+        &mut self,
+        system: S,
+        labels: LI,
+    ) -> &mut Self {
+        self.world.register_system_with_labels(system, labels);
+        self
+    }
+
+    /// Runs the supplied system on the [`World`] a single time.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    #[inline]
+    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+        &mut self,
+        system: S,
+    ) -> &mut Self {
+        self.world.run_system(system);
+        self
+    }
+
+    /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    #[inline]
+    pub fn run_systems_by_label<L: SystemLabel>(
+        &mut self,
+        label: L,
+    ) -> Result<(), SystemRegistryError> {
+        self.world.run_systems_by_label(label)
+    }
+
+    /// A trait-object compatible version of `run_systems_by_label`.
+    ///
+    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    #[inline]
+    pub fn run_systems_by_boxed_label(
+        &mut self,
+        boxed_label: Box<dyn SystemLabel>,
+    ) -> Result<(), SystemRegistryError> {
+        self.world.run_systems_by_boxed_label(boxed_label)
+    }
+}

From 45bba7db41a81f4ba2f2d6235f7746d2cb67a978 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:40:28 -0400
Subject: [PATCH 036/113] Polish example

---
 examples/ecs/one_shot_systems.rs | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 52d9735138c4e..09ca8c93fef52 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -12,6 +12,7 @@ use bevy::prelude::*;
 
 fn main() {
     App::new()
+        .add_startup_system(count_entities)
         .add_startup_system(setup)
         // One shot systems are interchangeable with ordinarily scheduled systems.
         // Change detection, Local and NonSend all work as expected
@@ -37,19 +38,17 @@ fn count_entities(all_entities: Query<()>) {
 }
 
 fn setup(mut commands: Commands) {
-    // commands.run_system is evaluated in sequence
-    commands.run_system(count_entities); // Reports 0 entities
     commands.spawn().insert(Callback::new(button_pressed));
     commands.spawn().insert(Callback::new(slider_toggled));
-    commands.run_system(count_entities); // Reports 2 entities, as the previous command will be processed by the time this has evaluated
+    commands.run_system(count_entities);
 }
 
 fn button_pressed() {
-    println!("A button was pressed!")
+    println!("A button was pressed!");
 }
 
 fn slider_toggled() {
-    println!("A slider was toggled!")
+    println!("A slider was toggled!");
 }
 
 // When creating abstractions built on one-shot systems,
@@ -65,7 +64,7 @@ impl Callback {
     // We can pass in a system as our function argument to automatically generate the correct label.
     // Alternatively, you can create an API that takes an explicit `SystemLabel`, and users can control
     // exactly how the system should be called.
-    fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(system: S) -> Self {
+    fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(_system: S) -> Self {
         Callback {
             triggered: false,
             label: Box::new(SystemTypeIdLabel::<S>::new()),
@@ -75,7 +74,7 @@ impl Callback {
 
 // These callbacks could easily be triggered via events, button interactions or so on
 // or even stored directly in the event type
-fn trigger_callbacks(query: Query<&mut Callback>) {
+fn trigger_callbacks(mut query: Query<&mut Callback>) {
     for mut callback in query.iter_mut() {
         callback.triggered = true;
     }
@@ -92,7 +91,7 @@ fn evaluate_callbacks(query: Query<&Callback>, mut commands: Commands) {
             // we have to use the layer of indirection provided by system labels
             // Note that if we had registered multiple systems with the same label,
             // they would all be evaluated here.
-            commands.run_systems_by_boxed_label(callback.label);
+            commands.run_systems_by_boxed_label(callback.label.clone());
         }
     }
 }

From f63b2213c37552f6745a10601f3fb746898ded6a Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:51:07 -0400
Subject: [PATCH 037/113] Update examples README per CI

---
 examples/README.md | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/examples/README.md b/examples/README.md
index 05a0969f38faa..9f3626935291e 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -57,19 +57,6 @@ git checkout v0.4.0
   - [Transforms](#transforms)
   - [UI (User Interface)](#ui-user-interface)
   - [Window](#window)
-- [Tests](#tests)
-- [Platform-Specific Examples](#platform-specific-examples)
-  - [Android](#android)
-    - [Setup](#setup)
-    - [Build & Run](#build--run)
-    - [Old phones](#old-phones)
-  - [iOS](#ios)
-    - [Setup](#setup-1)
-    - [Build & Run](#build--run-1)
-  - [WASM](#wasm)
-    - [Setup](#setup-2)
-    - [Build & Run](#build--run-2)
-    - [Loading Assets](#loading-assets)
 
 - [Tests](#tests)
 - [Platform-Specific Examples](#platform-specific-examples)

From 4e21f4b255219362d761fdbf74263ebd496d9917 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 00:53:31 -0400
Subject: [PATCH 038/113] Simplify system_registry doc tests

---
 crates/bevy_ecs/src/system/system_registry.rs | 45 -------------------
 1 file changed, 45 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index aaad3b1a98290..0a49afe5d56d6 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -73,51 +73,6 @@ use crate::world::{Mut, World};
 /// world.run_system(spawn_7_entities);
 /// world.run_system(assert_7_spawned);
 /// ```
-///
-/// Systems can also be manually registered using [`SystemLabel`] types
-/// and then run via those labels, enabling more sophisticated control flows.
-///
-/// ```rust
-/// use bevy_ecs::prelude::*;
-/// use bevy_ecs::system::SystemRegistry;
-///
-/// let mut world = World::new();
-/// let mut system_registry = SystemRegistry::default();
-///
-/// #[derive(SystemLabel, Debug, PartialEq, Eq, Hash, Clone)]
-/// enum ManualSystems {
-///     Hello,
-///     Goodbye,
-/// }
-///
-/// fn hello(){
-///     println!("Hello!")
-/// }
-///
-/// fn goodbye(){
-///     println!("Goodbye <3")
-/// }
-///
-/// fn have_a_nice_day(){
-///     println!("Have a nice day, and enjoy using Bevy!")
-/// }
-///
-/// // You can register systems by their label
-/// system_registry.register_system(&mut world, hello, ManualSystems::Hello);
-///
-/// // And run them by their label as well
-/// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
-///
-/// // You can register systems under multiple labels
-/// system_registry.register_system_with_labels(&mut world, have_a_nice_day, [ManualSystems::Hello, ManualSystems::Goodbye]);
-///
-/// // All systems registered under that label will be run, in registration order
-/// system_registry.run_systems_by_label(&mut world, ManualSystems::Hello);
-///
-/// // The methods on this type are also exposed on the `World` for convenience
-/// world.register_system(goodbye, ManualSystems::Goodbye);
-/// world.run_systems_by_label(ManualSystems::Goodbye);
-/// ```
 #[derive(Default)]
 pub struct SystemRegistry {
     systems: Vec<StoredSystem>,

From 46e7092b4aa1db548bf6e3f8d4431482a95dec36 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 11:30:15 -0400
Subject: [PATCH 039/113] Fix broken link

Co-authored-by: Federico Rinaldi <gisquerin@gmail.com>
---
 crates/bevy_app/src/system_registry.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 2941b91d3fa3c..dfbaeaa7bb3fc 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -18,6 +18,8 @@ impl App {
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
+    ///
+    /// [`SystemRegistry`]: bevy_ecs::system::SystemRegistry
     pub fn register_system_with_labels<
         Params,
         S: IntoSystem<(), (), Params> + 'static,

From 5d275ff50d0580db45f6579be50e7cae89f601d4 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:08:04 -0400
Subject: [PATCH 040/113] Add Callback type to bevy_ecs itself

---
 crates/bevy_ecs/src/system/system_registry.rs | 74 ++++++++++++++++++-
 examples/ecs/one_shot_systems.rs              | 68 ++++++-----------
 2 files changed, 95 insertions(+), 47 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 0a49afe5d56d6..d43e0ebf9cb42 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -2,7 +2,7 @@ use bevy_utils::tracing::warn;
 use bevy_utils::HashMap;
 use std::marker::PhantomData;
 
-use crate::schedule::SystemLabel;
+use crate::schedule::{IntoSystemDescriptor, SystemLabel};
 use crate::system::{Command, IntoSystem, System, SystemTypeIdLabel};
 use crate::world::{Mut, World};
 
@@ -404,6 +404,78 @@ impl Command for RunSystemsByLabelCommand {
     }
 }
 
+/// A struct that stores a boxed [`SystemLabel`], used to cause a [`SystemRegistry`] to run systems.
+///
+/// This might be stored as a component, used as an event, or arranged in a queue stored in a resource.
+/// Unless you need to inspect the list of events or add additional information,
+/// prefer the simpler `commands.run_system` over storing callbacks as events,
+///
+/// When working with callbacks, consider your architecture carefully.
+/// Callbacks are typically harder to reason about and debug than scheduled systems,
+/// and it's easy to get into a tangled mess if you don't consider the system as a whole before starting.
+///
+/// Systems must be registered via the `register_system` methods on [`SystemRegistry`], [`World`] or `App`
+/// before they can be run by their label using a callback.
+///
+/// # Example
+///
+/// ```rust
+/// use bevy_ecs::prelude::*;
+/// use bevy_ecs::system::callback;
+///
+/// let mut world = World::new();
+/// // When working with `App`, use app.add_event
+/// // to get automatic event cleanup
+/// world.init_resource::<Events<Callback>>();
+///
+/// struct PlayerName(String);
+/// world.add_resource(PlayerName("Cart"));
+///
+/// fn report_player_name(player_name: Res<PlayerName>){
+///     println!("Hello {}", player_name.0);
+/// }
+/// // Remember to register any systems you intend to use as a `Callback`
+/// world.register_system(hello_world);
+///
+/// // Generating some callbacks
+/// fn generate_callback_events(mut callbacks: EventWriter<Callback>){
+///   // This will have no effect if you forgot to register the system in question
+///   callbacks.send(Callback::new(hello_world));
+/// }
+///
+/// world.run_system(generate_callback_events);
+///
+/// // Reading and then applying some callbacks
+/// fn process_callback_events(mut callbacks: EventReader<Callback>) {
+///    for callback in callbacks.iter(){
+///       commands.run_system_by_boxed_label(callback.label);
+///    }
+/// }
+///
+/// // Say hi to Cart!
+/// world.run_system(process_callback_events);
+/// ```
+use crate as bevy_ecs;
+#[derive(Debug, crate::prelude::Component, Clone)]
+pub struct Callback {
+    /// The label of the system(s) to be run.
+    ///
+    /// By default, this is set to the [`SystemTypeIdLabel`]
+    /// of the system passed in via [`Callback::new()`].
+    pub label: Box<dyn SystemLabel>,
+}
+
+impl Callback {
+    /// Creates a new callback from a function that can be used as a system.
+    ///
+    /// Remember that you must register your systems with the `App` / [`World`] before they can be run as callbacks!
+    pub fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(_system: S) -> Self {
+        Callback {
+            label: Box::new(SystemTypeIdLabel::<S>::new()),
+        }
+    }
+}
+
 /// An operation on a [`SystemRegistry`] failed
 #[derive(Debug)]
 pub enum SystemRegistryError {
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 09ca8c93fef52..99e70fd3ea907 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -6,8 +6,7 @@
 //!
 //! See the [`SystemRegistry`](bevy::ecs::SystemRegistry) docs for more details.
 
-use bevy::ecs::schedule::IntoSystemDescriptor;
-use bevy::ecs::system::SystemTypeIdLabel;
+use bevy::ecs::system::Callback;
 use bevy::prelude::*;
 
 fn main() {
@@ -24,9 +23,8 @@ fn main() {
         .register_system(slider_toggled)
         // One-shot systems can be used to build complex abstractions
         // to match the needs of your design.
-        // Here, we model a very simple system-powered callback architecture.
-        .add_system(trigger_callbacks)
-        .add_system(evaluate_callbacks.after(trigger_callbacks))
+        // Here, we model a very simple component-linked callback architecture.
+        .add_system(evaluate_callbacks)
         .run();
 }
 
@@ -37,8 +35,18 @@ fn count_entities(all_entities: Query<()>) {
     dbg!(all_entities.iter().count());
 }
 
+#[derive(Component)]
+struct Triggered;
+
 fn setup(mut commands: Commands) {
-    commands.spawn().insert(Callback::new(button_pressed));
+    commands
+        .spawn()
+        // The Callback component is defined in bevy_ecs,
+        // but wrapping this (or making your own customized variant) is easy.
+        // Just stored a boxed SystemLabel!
+        .insert(Callback::new(button_pressed))
+        .insert(Triggered);
+    // This entity does not have a Triggered component, so its callback won't run
     commands.spawn().insert(Callback::new(slider_toggled));
     commands.run_system(count_entities);
 }
@@ -51,47 +59,15 @@ fn slider_toggled() {
     println!("A slider was toggled!");
 }
 
-// When creating abstractions built on one-shot systems,
-// storing system labels is the way to go.
-// Don't try to store boxed System trait objects!
-#[derive(Component)]
-struct Callback {
-    triggered: bool,
-    label: Box<dyn SystemLabel>,
-}
-
-impl Callback {
-    // We can pass in a system as our function argument to automatically generate the correct label.
-    // Alternatively, you can create an API that takes an explicit `SystemLabel`, and users can control
-    // exactly how the system should be called.
-    fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(_system: S) -> Self {
-        Callback {
-            triggered: false,
-            label: Box::new(SystemTypeIdLabel::<S>::new()),
-        }
-    }
-}
-
-// These callbacks could easily be triggered via events, button interactions or so on
-// or even stored directly in the event type
-fn trigger_callbacks(mut query: Query<&mut Callback>) {
-    for mut callback in query.iter_mut() {
-        callback.triggered = true;
-    }
-}
-
-/// Runs the systems associated with each Callback component
+/// Runs the systems associated with each `Callback` component if the entity also has a Triggered component
 ///
-/// This could also be done in an exclusive system,
-/// but the borrow checker is more frustrating
-fn evaluate_callbacks(query: Query<&Callback>, mut commands: Commands) {
+/// This could be done in an exclusive system rather than using `Commands` if preferred
+fn evaluate_callbacks(query: Query<&Callback, With<Triggered>>, mut commands: Commands) {
     for callback in query.iter() {
-        if callback.triggered {
-            // Because we don't have access to the type information of the callbacks
-            // we have to use the layer of indirection provided by system labels
-            // Note that if we had registered multiple systems with the same label,
-            // they would all be evaluated here.
-            commands.run_systems_by_boxed_label(callback.label.clone());
-        }
+        // Because we don't have access to the type information of the callbacks
+        // we have to use the layer of indirection provided by system labels
+        // Note that if we had registered multiple systems with the same label,
+        // they would all be evaluated here.
+        commands.run_systems_by_boxed_label(callback.label.clone());
     }
 }

From 24508d1bad3c109b4fcfa75b0e29d77ad24a2168 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:14:36 -0400
Subject: [PATCH 041/113] Implement PartialEq and Eq for Callback

---
 crates/bevy_ecs/src/system/system_registry.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index d43e0ebf9cb42..72dbe258dea16 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -456,7 +456,7 @@ impl Command for RunSystemsByLabelCommand {
 /// world.run_system(process_callback_events);
 /// ```
 use crate as bevy_ecs;
-#[derive(Debug, crate::prelude::Component, Clone)]
+#[derive(Debug, crate::prelude::Component, Clone, Eq)]
 pub struct Callback {
     /// The label of the system(s) to be run.
     ///
@@ -476,6 +476,12 @@ impl Callback {
     }
 }
 
+impl PartialEq for Callback {
+    fn eq(&self, other: &Self) -> bool {
+        self.label.dyn_eq(other.label.as_dyn_eq())
+    }
+}
+
 /// An operation on a [`SystemRegistry`] failed
 #[derive(Debug)]
 pub enum SystemRegistryError {

From 0855a0f7a52469b9fececbc9bebdcbccb2bff57a Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:21:33 -0400
Subject: [PATCH 042/113] Implement Hash for Callback

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 72dbe258dea16..787f965241a07 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -456,7 +456,7 @@ impl Command for RunSystemsByLabelCommand {
 /// world.run_system(process_callback_events);
 /// ```
 use crate as bevy_ecs;
-#[derive(Debug, crate::prelude::Component, Clone, Eq)]
+#[derive(Debug, crate::prelude::Component, Clone, Eq, Hash)]
 pub struct Callback {
     /// The label of the system(s) to be run.
     ///

From 8effb5b38b542b1b281fa48e210232edf4116c9d Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:33:41 -0400
Subject: [PATCH 043/113] Change run_system_by_boxed_label to run_callback

---
 crates/bevy_app/src/system_registry.rs        | 11 ++----
 crates/bevy_ecs/src/system/commands/mod.rs    | 13 ++++---
 crates/bevy_ecs/src/system/system_registry.rs | 38 ++++++++++---------
 examples/ecs/one_shot_systems.rs              |  2 +-
 4 files changed, 33 insertions(+), 31 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index dfbaeaa7bb3fc..26cb236c7f315 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -1,6 +1,6 @@
 use crate::App;
 use bevy_ecs::prelude::*;
-use bevy_ecs::system::SystemRegistryError;
+use bevy_ecs::system::{Callback, SystemRegistryError};
 
 impl App {
     /// Registers the supplied system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry) resource.
@@ -57,14 +57,11 @@ impl App {
         self.world.run_systems_by_label(label)
     }
 
-    /// A trait-object compatible version of `run_systems_by_label`.
+    /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
     #[inline]
-    pub fn run_systems_by_boxed_label(
-        &mut self,
-        boxed_label: Box<dyn SystemLabel>,
-    ) -> Result<(), SystemRegistryError> {
-        self.world.run_systems_by_boxed_label(boxed_label)
+    pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
+        self.world.run_callback(callback)
     }
 }
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 52704dcc28a6f..4d32d9b36a2ca 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -6,7 +6,7 @@ use crate::{
     bundle::Bundle,
     entity::{Entities, Entity},
     schedule::SystemLabel,
-    system::{IntoSystem, RunSystemCommand, RunSystemsByLabelCommand},
+    system::{Callback, IntoSystem, RunSystemCommand, RunSystemsByLabelCommand},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -541,16 +541,17 @@ impl<'w, 's> Commands<'w, 's> {
     /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
     pub fn run_systems_by_label(&mut self, label: impl SystemLabel) {
         self.queue.push(RunSystemsByLabelCommand {
-            label: Box::new(label),
+            callback: Callback {
+                label: Box::new(label),
+            },
         });
     }
 
-    /// A trait-object compatible version of `run_systems_by_label`.
+    /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
-    pub fn run_systems_by_boxed_label(&mut self, boxed_label: Box<dyn SystemLabel>) {
-        self.queue
-            .push(RunSystemsByLabelCommand { label: boxed_label });
+    pub fn run_callback(&mut self, callback: Callback) {
+        self.queue.push(RunSystemsByLabelCommand { callback });
     }
 
     /// Pushes a generic [`Command`] to the command queue.
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 787f965241a07..76a85579dd6f5 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -230,21 +230,28 @@ impl SystemRegistry {
         world: &mut World,
         label: L,
     ) -> Result<(), SystemRegistryError> {
-        let boxed_label: Box<dyn SystemLabel> = label.dyn_clone();
-        self.run_systems_by_boxed_label(world, boxed_label)
+        self.run_callback(
+            world,
+            Callback {
+                label: label.dyn_clone(),
+            },
+        )
     }
 
-    /// A trait-object compatible version of `run_systems_by_label`.
+    /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
-    /// This can be useful for more abstract designs that rely on boxed labels,
-    /// as [`SystemLabel`] is not implemented for boxed trait objects
-    /// to avoid indefinite nesting.
+    /// Systems must be registered before they can be run by their label,
+    /// including via this method.
+    ///
+    /// Systems will be run sequentially in registration order if more than one registered system matches the provided label.
     #[inline]
-    pub fn run_systems_by_boxed_label(
+    pub fn run_callback(
         &mut self,
         world: &mut World,
-        boxed_label: Box<dyn SystemLabel>,
+        callback: Callback,
     ) -> Result<(), SystemRegistryError> {
+        let boxed_label = callback.label;
+
         match self.labels.get(&boxed_label) {
             Some(matching_indexes) => {
                 // Loop over the system in registration order
@@ -334,16 +341,13 @@ impl World {
         })
     }
 
-    /// A trait-object compatible version of `run_systems_by_label`.
+    /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     #[inline]
-    pub fn run_systems_by_boxed_label(
-        &mut self,
-        boxed_label: Box<dyn SystemLabel>,
-    ) -> Result<(), SystemRegistryError> {
+    pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_boxed_label(world, boxed_label)
+            registry.run_callback(world, callback)
         })
     }
 }
@@ -388,7 +392,7 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
 /// The [`Command`] type for [`SystemRegistry::run_systems_by_label`]
 #[derive(Debug, Clone)]
 pub struct RunSystemsByLabelCommand {
-    pub label: Box<dyn SystemLabel>,
+    pub callback: Callback,
 }
 
 impl Command for RunSystemsByLabelCommand {
@@ -396,7 +400,7 @@ impl Command for RunSystemsByLabelCommand {
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry
-                .run_systems_by_boxed_label(world, self.label.dyn_clone())
+                .run_callback(world, self.callback)
                 // Ideally this error should be handled more gracefully,
                 // but that's blocked on a full error handling solution for commands
                 .unwrap();
@@ -448,7 +452,7 @@ impl Command for RunSystemsByLabelCommand {
 /// // Reading and then applying some callbacks
 /// fn process_callback_events(mut callbacks: EventReader<Callback>) {
 ///    for callback in callbacks.iter(){
-///       commands.run_system_by_boxed_label(callback.label);
+///       commands.run_callback(callback);
 ///    }
 /// }
 ///
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 99e70fd3ea907..a8c3c0272d27b 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -68,6 +68,6 @@ fn evaluate_callbacks(query: Query<&Callback, With<Triggered>>, mut commands: Co
         // we have to use the layer of indirection provided by system labels
         // Note that if we had registered multiple systems with the same label,
         // they would all be evaluated here.
-        commands.run_systems_by_boxed_label(callback.label.clone());
+        commands.run_callback(callback.clone());
     }
 }

From 9191f122bf54feafc7ba96102917ffce7e86c395 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:47:23 -0400
Subject: [PATCH 044/113] Fix doc example

---
 crates/bevy_ecs/src/system/system_registry.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 76a85579dd6f5..867b9f01e42c4 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -439,12 +439,13 @@ impl Command for RunSystemsByLabelCommand {
 ///     println!("Hello {}", player_name.0);
 /// }
 /// // Remember to register any systems you intend to use as a `Callback`
-/// world.register_system(hello_world);
+/// world.register_system(report_player_name);
 ///
 /// // Generating some callbacks
 /// fn generate_callback_events(mut callbacks: EventWriter<Callback>){
-///   // This will have no effect if you forgot to register the system in question
-///   callbacks.send(Callback::new(hello_world));
+///   // The callback will have no effect when evaluated
+///   // if you forgot to register the system in question
+///   callbacks.send(Callback::new(report_player_name));
 /// }
 ///
 /// world.run_system(generate_callback_events);

From 973be534822b8b4e83319e673851fe42fa7386da Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 16:53:54 -0400
Subject: [PATCH 045/113] Manually implement Hash

---
 crates/bevy_ecs/src/system/system_registry.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 867b9f01e42c4..583833f26460a 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,5 +1,6 @@
 use bevy_utils::tracing::warn;
 use bevy_utils::HashMap;
+use std::hash::Hash;
 use std::marker::PhantomData;
 
 use crate::schedule::{IntoSystemDescriptor, SystemLabel};
@@ -461,7 +462,7 @@ impl Command for RunSystemsByLabelCommand {
 /// world.run_system(process_callback_events);
 /// ```
 use crate as bevy_ecs;
-#[derive(Debug, crate::prelude::Component, Clone, Eq, Hash)]
+#[derive(Debug, crate::prelude::Component, Clone, Eq)]
 pub struct Callback {
     /// The label of the system(s) to be run.
     ///
@@ -487,6 +488,12 @@ impl PartialEq for Callback {
     }
 }
 
+impl Hash for Callback {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.label.dyn_hash(state);
+    }
+}
+
 /// An operation on a [`SystemRegistry`] failed
 #[derive(Debug)]
 pub enum SystemRegistryError {

From aedd75b04a93014a449efa82fa057d4011ce302b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 17:14:50 -0400
Subject: [PATCH 046/113] Fix doc example (for real?)

---
 crates/bevy_ecs/src/system/system_registry.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 583833f26460a..29f51e936b7cd 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -426,7 +426,7 @@ impl Command for RunSystemsByLabelCommand {
 ///
 /// ```rust
 /// use bevy_ecs::prelude::*;
-/// use bevy_ecs::system::callback;
+/// use bevy_ecs::system::Callback;
 ///
 /// let mut world = World::new();
 /// // When working with `App`, use app.add_event
@@ -434,7 +434,7 @@ impl Command for RunSystemsByLabelCommand {
 /// world.init_resource::<Events<Callback>>();
 ///
 /// struct PlayerName(String);
-/// world.add_resource(PlayerName("Cart"));
+/// world.add_resource(PlayerName("Cart".to_string()));
 ///
 /// fn report_player_name(player_name: Res<PlayerName>){
 ///     println!("Hello {}", player_name.0);
@@ -452,9 +452,9 @@ impl Command for RunSystemsByLabelCommand {
 /// world.run_system(generate_callback_events);
 ///
 /// // Reading and then applying some callbacks
-/// fn process_callback_events(mut callbacks: EventReader<Callback>) {
+/// fn process_callback_events(mut callbacks: EventReader<Callback>, mut commands: Commands) {
 ///    for callback in callbacks.iter(){
-///       commands.run_callback(callback);
+///       commands.run_callback(&callback);
 ///    }
 /// }
 ///

From 69e803980040bd420521a749f2f820af90d0e0a5 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 18:43:24 -0400
Subject: [PATCH 047/113] Avoid box allocation

Co-authored-by: MinerSebas <66798382+MinerSebas@users.noreply.github.com>
---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 29f51e936b7cd..4204edefe4bf1 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -106,12 +106,12 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
     ) {
-        let boxed_system: Box<dyn System<In = (), Out = ()>> =
-            Box::new(IntoSystem::into_system(system));
         let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
 
         // This avoids nasty surprising behavior in case systems are registered twice
         if !self.is_label_registered(automatic_system_label) {
+        	let boxed_system: Box<dyn System<In = (), Out = ()>> =
+            	Box::new(IntoSystem::into_system(system));
             self.register_boxed_system_with_labels(
                 world,
                 boxed_system,

From f2b398ab9c834bc554f6ae2342dbd204c0838c01 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 21:36:29 -0400
Subject: [PATCH 048/113] Mostly fix doc example

---
 crates/bevy_ecs/src/system/system_registry.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 4204edefe4bf1..c3251a03d8d01 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -6,6 +6,9 @@ use std::marker::PhantomData;
 use crate::schedule::{IntoSystemDescriptor, SystemLabel};
 use crate::system::{Command, IntoSystem, System, SystemTypeIdLabel};
 use crate::world::{Mut, World};
+// Needed for derive(Component) macro
+use crate as bevy_ecs;
+use bevy_ecs_macros::Component;
 
 /// Stores initialized [`Systems`](crate::system::System), so they can be reused and run in an ad-hoc fashion
 ///
@@ -110,8 +113,8 @@ impl SystemRegistry {
 
         // This avoids nasty surprising behavior in case systems are registered twice
         if !self.is_label_registered(automatic_system_label) {
-        	let boxed_system: Box<dyn System<In = (), Out = ()>> =
-            	Box::new(IntoSystem::into_system(system));
+            let boxed_system: Box<dyn System<In = (), Out = ()>> =
+                Box::new(IntoSystem::into_system(system));
             self.register_boxed_system_with_labels(
                 world,
                 boxed_system,
@@ -426,6 +429,7 @@ impl Command for RunSystemsByLabelCommand {
 ///
 /// ```rust
 /// use bevy_ecs::prelude::*;
+/// use bevy_ecs::event::Events;
 /// use bevy_ecs::system::Callback;
 ///
 /// let mut world = World::new();
@@ -434,7 +438,7 @@ impl Command for RunSystemsByLabelCommand {
 /// world.init_resource::<Events<Callback>>();
 ///
 /// struct PlayerName(String);
-/// world.add_resource(PlayerName("Cart".to_string()));
+/// world.insert_resource(PlayerName("Cart".to_string()));
 ///
 /// fn report_player_name(player_name: Res<PlayerName>){
 ///     println!("Hello {}", player_name.0);
@@ -454,15 +458,14 @@ impl Command for RunSystemsByLabelCommand {
 /// // Reading and then applying some callbacks
 /// fn process_callback_events(mut callbacks: EventReader<Callback>, mut commands: Commands) {
 ///    for callback in callbacks.iter(){
-///       commands.run_callback(&callback);
+///       commands.run_callback(callback.clone());
 ///    }
 /// }
 ///
 /// // Say hi to Cart!
 /// world.run_system(process_callback_events);
 /// ```
-use crate as bevy_ecs;
-#[derive(Debug, crate::prelude::Component, Clone, Eq)]
+#[derive(Debug, Component, Clone, Eq)]
 pub struct Callback {
     /// The label of the system(s) to be run.
     ///

From 98ed955ef6649c98bc00a1a368d0c1f8804fa62d Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Thu, 30 Jun 2022 21:45:52 -0400
Subject: [PATCH 049/113] Remove frustrating doc example

---
 crates/bevy_ecs/src/system/system_registry.rs | 41 -------------------
 1 file changed, 41 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index c3251a03d8d01..0db1e816a36ba 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -424,47 +424,6 @@ impl Command for RunSystemsByLabelCommand {
 ///
 /// Systems must be registered via the `register_system` methods on [`SystemRegistry`], [`World`] or `App`
 /// before they can be run by their label using a callback.
-///
-/// # Example
-///
-/// ```rust
-/// use bevy_ecs::prelude::*;
-/// use bevy_ecs::event::Events;
-/// use bevy_ecs::system::Callback;
-///
-/// let mut world = World::new();
-/// // When working with `App`, use app.add_event
-/// // to get automatic event cleanup
-/// world.init_resource::<Events<Callback>>();
-///
-/// struct PlayerName(String);
-/// world.insert_resource(PlayerName("Cart".to_string()));
-///
-/// fn report_player_name(player_name: Res<PlayerName>){
-///     println!("Hello {}", player_name.0);
-/// }
-/// // Remember to register any systems you intend to use as a `Callback`
-/// world.register_system(report_player_name);
-///
-/// // Generating some callbacks
-/// fn generate_callback_events(mut callbacks: EventWriter<Callback>){
-///   // The callback will have no effect when evaluated
-///   // if you forgot to register the system in question
-///   callbacks.send(Callback::new(report_player_name));
-/// }
-///
-/// world.run_system(generate_callback_events);
-///
-/// // Reading and then applying some callbacks
-/// fn process_callback_events(mut callbacks: EventReader<Callback>, mut commands: Commands) {
-///    for callback in callbacks.iter(){
-///       commands.run_callback(callback.clone());
-///    }
-/// }
-///
-/// // Say hi to Cart!
-/// world.run_system(process_callback_events);
-/// ```
 #[derive(Debug, Component, Clone, Eq)]
 pub struct Callback {
     /// The label of the system(s) to be run.

From 747669591515369e897f1859a7faa8bdb69a3622 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:45:15 -0400
Subject: [PATCH 050/113] Typo fix

Co-authored-by: Aevyrie <aevyrie@gmail.com>
---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 0db1e816a36ba..5c64b2c388cf7 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -211,7 +211,7 @@ impl SystemRegistry {
         stored_system.system.apply_buffers(world);
     }
 
-    /// Is at least one system in the [`SystemRegistry`] is associated with the provided [`SystemLabel`]?
+    /// Is at least one system in the [`SystemRegistry`] associated with the provided [`SystemLabel`]?
     #[inline]
     pub fn is_label_registered<L: SystemLabel>(&self, label: L) -> bool {
         let boxed_label: Box<dyn SystemLabel> = Box::new(label);

From 4756690aa272f180ab7d93e608497dc2c0bd0ff3 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:46:03 -0400
Subject: [PATCH 051/113] Clarify drawbacks of SystemState

---
 crates/bevy_ecs/src/system/function_system.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index c4d494185689d..1b1467dde9de5 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -63,7 +63,7 @@ impl SystemMeta {
 /// This is a powerful and convenient tool for working with exclusive world access,
 /// allowing you to fetch data from the [`World`] as if you were running a [`System`].
 /// However, simply calling `world::run_system(my_system)` using a [`SystemRegistry`](crate::system::SystemRegistry)
-/// can be significantly simpler and more reliable.
+/// can be significantly simpler and ensures that change detection and command flushing work as expected.
 ///
 /// Borrow-checking is handled for you, allowing you to mutably access multiple compatible system parameters at once,
 /// and arbitrary system parameters (like [`EventWriter`](crate::event::EventWriter)) can be conveniently fetched.

From 56d09f51e40cedac14c4d712b4f7b37d84601e84 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:47:47 -0400
Subject: [PATCH 052/113] Punctuation

Co-authored-by: Federico Rinaldi <gisquerin@gmail.com>
---
 crates/bevy_ecs/src/system/system_registry.rs |  2 +-
 examples/ecs/one_shot_systems.rs              | 18 +++++++++---------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 5c64b2c388cf7..ce74e8cee44af 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -10,7 +10,7 @@ use crate::world::{Mut, World};
 use crate as bevy_ecs;
 use bevy_ecs_macros::Component;
 
-/// Stores initialized [`Systems`](crate::system::System), so they can be reused and run in an ad-hoc fashion
+/// Stores initialized [`System`]s, so they can be reused and run in an ad-hoc fashion.
 ///
 /// Systems are keyed by their [`SystemLabel`]:
 ///  - all systems with a given label will be run (in linear registration order) when a given label is run
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index a8c3c0272d27b..abed2a5b88cb8 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -1,4 +1,4 @@
-//! Demonstrates the use of "one-shot systems", which run once when triggered
+//! Demonstrates the use of "one-shot systems", which run once when triggered.
 //!
 //! These can be useful to help structure your logic in a push-based fashion,
 //! reducing the overhead of running extremely rarely run systems
@@ -14,11 +14,11 @@ fn main() {
         .add_startup_system(count_entities)
         .add_startup_system(setup)
         // One shot systems are interchangeable with ordinarily scheduled systems.
-        // Change detection, Local and NonSend all work as expected
+        // Change detection, Local and NonSend all work as expected.
         .add_system_to_stage(CoreStage::PostUpdate, count_entities)
-        // Registered systems can be called dynamically by their label
+        // Registered systems can be called dynamically by their label.
         // These must be registered in advance, or commands.run_system will panic
-        // as no matching system was found
+        // as no matching system was found.
         .register_system(button_pressed)
         .register_system(slider_toggled)
         // One-shot systems can be used to build complex abstractions
@@ -28,7 +28,7 @@ fn main() {
         .run();
 }
 
-// Any ordinary system can be run via commands.run_system or world.run_system
+// Any ordinary system can be run via commands.run_system or world.run_system.
 //
 // Chained systems, exclusive systems and systems which themselves run systems cannot be called in this way.
 fn count_entities(all_entities: Query<()>) {
@@ -46,7 +46,7 @@ fn setup(mut commands: Commands) {
         // Just stored a boxed SystemLabel!
         .insert(Callback::new(button_pressed))
         .insert(Triggered);
-    // This entity does not have a Triggered component, so its callback won't run
+    // This entity does not have a Triggered component, so its callback won't run.
     commands.spawn().insert(Callback::new(slider_toggled));
     commands.run_system(count_entities);
 }
@@ -59,13 +59,13 @@ fn slider_toggled() {
     println!("A slider was toggled!");
 }
 
-/// Runs the systems associated with each `Callback` component if the entity also has a Triggered component
+/// Runs the systems associated with each `Callback` component if the entity also has a Triggered component.
 ///
-/// This could be done in an exclusive system rather than using `Commands` if preferred
+/// This could be done in an exclusive system rather than using `Commands` if preferred.
 fn evaluate_callbacks(query: Query<&Callback, With<Triggered>>, mut commands: Commands) {
     for callback in query.iter() {
         // Because we don't have access to the type information of the callbacks
-        // we have to use the layer of indirection provided by system labels
+        // we have to use the layer of indirection provided by system labels.
         // Note that if we had registered multiple systems with the same label,
         // they would all be evaluated here.
         commands.run_callback(callback.clone());

From bf42626b4c36d056091b533b09aa299cdb71f89b Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:48:53 -0400
Subject: [PATCH 053/113] Typo

Co-authored-by: Aevyrie <aevyrie@gmail.com>
---
 crates/bevy_app/src/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 26cb236c7f315..daf56a0258dd2 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -15,7 +15,7 @@ impl App {
         self
     }
 
-    /// Register system a system with any number of [`SystemLabel`]s.
+    /// Register a system with any number of [`SystemLabel`]s.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     ///

From d553b1eddb1957bc66ace982e987c5c6a416b050 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:52:01 -0400
Subject: [PATCH 054/113] Fix mistake from merge conflict

---
 crates/bevy_ecs/src/system/function_system.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 1b1467dde9de5..abb7a0a88fb3f 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -527,8 +527,8 @@ where
     F::Param: ReadOnlySystemParam,
 {
     #[inline]
-    fn default_labels(&self) -> Vec<Box<dyn SystemLabel>> {
-        vec![Box::new(self.func.as_system_label())]
+    fn default_labels(&self) -> Vec<SystemLabelId> {
+        vec![self.func.as_system_label().as_label()]
     }
 }
 
@@ -546,6 +546,13 @@ impl<T: 'static> SystemTypeIdLabel<T> {
     }
 }
 
+impl<T: 'static> SystemLabel for SystemTypeIdLabel<T> {
+    #[inline]
+    fn as_str(&self) -> &'static str {
+        std::any::type_name::<T>()
+    }
+}
+
 impl<T> Debug for SystemTypeIdLabel<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_tuple("SystemTypeIdLabel")

From 3ec4643d6d3abbdb2b420daea85a5de4a32d2055 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:55:25 -0400
Subject: [PATCH 055/113] Remove vague warning about callbacks

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index ce74e8cee44af..c52463a157934 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -418,10 +418,6 @@ impl Command for RunSystemsByLabelCommand {
 /// Unless you need to inspect the list of events or add additional information,
 /// prefer the simpler `commands.run_system` over storing callbacks as events,
 ///
-/// When working with callbacks, consider your architecture carefully.
-/// Callbacks are typically harder to reason about and debug than scheduled systems,
-/// and it's easy to get into a tangled mess if you don't consider the system as a whole before starting.
-///
 /// Systems must be registered via the `register_system` methods on [`SystemRegistry`], [`World`] or `App`
 /// before they can be run by their label using a callback.
 #[derive(Debug, Component, Clone, Eq)]

From 6a49a8332c202beedd96f28f5e55e4b2b3f8ad66 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 16:58:50 -0400
Subject: [PATCH 056/113] Add Send and Sync bounds to label traits

---
 crates/bevy_utils/src/label.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_utils/src/label.rs b/crates/bevy_utils/src/label.rs
index 6eff79c0bb389..9cd3fc216b0c2 100644
--- a/crates/bevy_utils/src/label.rs
+++ b/crates/bevy_utils/src/label.rs
@@ -179,7 +179,7 @@ macro_rules! define_label {
         }
 
         $(#[$label_attr])*
-        pub trait $label_name: 'static {
+        pub trait $label_name: Send + Sync + 'static {
             /// Converts this type into an opaque, strongly-typed label.
             fn as_label(&self) -> $id_name {
                 let id = self.type_id();

From d60b6cfbd2969041aee3fd3388add318f1022830 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 17:07:14 -0400
Subject: [PATCH 057/113] Clean up docs and naming around system registration

---
 crates/bevy_ecs/src/system/system_registry.rs | 40 +++++++++----------
 1 file changed, 18 insertions(+), 22 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index c52463a157934..87e1ae5077659 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -94,17 +94,12 @@ impl SystemRegistry {
     /// This allows the system to be run by their [`SystemTypeIdLabel`] using the `run_systems_by_label` method.
     /// Repeatedly registering a system will have no effect.
     ///
-    /// Ordinarily, systems are automatically registered when [`run_system`](SystemRegistry::run_system) is called.
-    /// When this occurs, they will be registered using their [`SystemTypeIdLabel`].
-    /// However, manual registration allows you to provide one or more labels for the system.
-    /// This also allows you to register multiple distinct copies of the system under distinct labels.
-    ///
     /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
     /// all registered systems that match that label will be evaluated (in insertion order).
     ///
     /// To provide explicit label(s), use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
+    fn register_system_with_type_label<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
@@ -115,26 +110,23 @@ impl SystemRegistry {
         if !self.is_label_registered(automatic_system_label) {
             let boxed_system: Box<dyn System<In = (), Out = ()>> =
                 Box::new(IntoSystem::into_system(system));
-            self.register_boxed_system_with_labels(
-                world,
-                boxed_system,
-                vec![Box::new(automatic_system_label)],
-            );
+            self.register_boxed_system(world, boxed_system, vec![Box::new(automatic_system_label)]);
         } else {
             let type_name = std::any::type_name::<S>();
             warn!("A system of type {type_name} was registered more than once!");
         };
     }
 
-    /// Register system a system with any number of [`SystemLabel`]s.
+    /// Register a system so that it may be run by any of their [`SystemLabel`]s.
     ///
-    /// This allows the system to be run whenever any of its labels are run using [`run_systems_by_label`](SystemRegistry::run_systems_by_label).
+    /// This is only needed if you want to run a system by a particular label;
+    /// the `run_system` label will automatically register systems under their [`SystemTypeIdLabel`] when first used.
     ///
     /// # Warning
     ///
-    /// Unlike the `register_system` method, duplicate systems may be added;
-    /// each copy will be called seperately if they share a label.
-    pub fn register_system_with_labels<
+    /// Duplicate systems may be added if this method is called repeatedly.
+    /// Each copy will be called seperately if they share a label.
+    pub fn register_system<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
         LI: IntoIterator<Item = L>,
@@ -156,10 +148,10 @@ impl SystemRegistry {
             })
             .collect();
 
-        self.register_boxed_system_with_labels(world, boxed_system, collected_labels);
+        self.register_boxed_system(world, boxed_system, collected_labels);
     }
 
-    /// A more exacting version of [`register_system_with_labels`](Self::register_system_with_labels).
+    /// A less generic version of [`register_system`](Self::register_system_with_labels).
     ///
     /// Returns the index in the vector of systems that this new system is stored at.
     /// This is only useful for debugging as an external user of this method.
@@ -167,7 +159,7 @@ impl SystemRegistry {
     /// This can be useful when you have a boxed system or boxed labels,
     /// as the corresponding traits are not implemented for boxed trait objects
     /// to avoid indefinite nesting.
-    pub fn register_boxed_system_with_labels(
+    pub fn register_boxed_system(
         &mut self,
         world: &mut World,
         mut boxed_system: Box<dyn System<In = (), Out = ()>>,
@@ -271,7 +263,11 @@ impl SystemRegistry {
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
+    /// You do not need to register systems before they are run in this way.
+    /// Instead, systems will be automatically registered according to their [`SystemTypeIdLabel`] the first time this method is called on them.
+    ///
     /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
+    ///
     /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeIdLabel`],
     /// only the first will be run.
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
@@ -286,7 +282,7 @@ impl SystemRegistry {
             let boxed_system: Box<dyn System<In = (), Out = ()>> =
                 Box::new(IntoSystem::into_system(system));
             let labels = boxed_system.default_labels();
-            self.register_boxed_system_with_labels(world, boxed_system, labels)
+            self.register_boxed_system(world, boxed_system, labels)
         };
 
         self.run_system_at_index(world, index);
@@ -300,7 +296,7 @@ impl World {
     #[inline]
     pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system);
+            registry.register_system_with_type_label(world, system);
         });
     }
 
@@ -318,7 +314,7 @@ impl World {
         labels: LI,
     ) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system_with_labels(world, system, labels);
+            registry.register_system(world, system, labels);
         });
     }
 

From e1b5ccd37b467370372b9acaa2c9db81118e6536 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 17:16:10 -0400
Subject: [PATCH 058/113] Make App and World APIs consistent

---
 crates/bevy_app/src/system_registry.rs        | 16 ++--------------
 crates/bevy_ecs/src/system/system_registry.rs | 16 +++-------------
 2 files changed, 5 insertions(+), 27 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index daf56a0258dd2..a83b824ca9f45 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -3,24 +3,12 @@ use bevy_ecs::prelude::*;
 use bevy_ecs::system::{Callback, SystemRegistryError};
 
 impl App {
-    /// Registers the supplied system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry) resource.
-    ///
-    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
-    #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(
-        &mut self,
-        system: S,
-    ) -> &mut Self {
-        self.world.register_system(system);
-        self
-    }
-
     /// Register a system with any number of [`SystemLabel`]s.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
     ///
     /// [`SystemRegistry`]: bevy_ecs::system::SystemRegistry
-    pub fn register_system_with_labels<
+    pub fn register_system<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
         LI: IntoIterator<Item = L>,
@@ -30,7 +18,7 @@ impl App {
         system: S,
         labels: LI,
     ) -> &mut Self {
-        self.world.register_system_with_labels(system, labels);
+        self.world.register_system(system, labels);
         self
     }
 
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 87e1ae5077659..72e30984d57e7 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -290,20 +290,10 @@ impl SystemRegistry {
 }
 
 impl World {
-    /// Registers the supplied system in the [`SystemRegistry`] resource.
-    ///
-    /// Calls the method of the same name on [`SystemRegistry`].
-    #[inline]
-    pub fn register_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system_with_type_label(world, system);
-        });
-    }
-
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
     /// Calls the method of the same name on [`SystemRegistry`].
-    pub fn register_system_with_labels<
+    pub fn register_system<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
         LI: IntoIterator<Item = L>,
@@ -495,8 +485,8 @@ mod tests {
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system_with_labels(count_up, ["count"]);
-        world.register_system_with_labels(count_up, ["count"]);
+        world.register_system(count_up, ["count"]);
+        world.register_system(count_up, ["count"]);
         world.run_systems_by_label("count").unwrap();
         // All systems matching the label will be run.
         assert_eq!(*world.resource::<Counter>(), Counter(2));

From 2f3e570681418db78c8b5a7b9954ef4210e9f83e Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Fri, 29 Jul 2022 17:20:26 -0400
Subject: [PATCH 059/113] Make doc links on higher level methods more useful

---
 crates/bevy_app/src/system_registry.rs        | 10 ++++------
 crates/bevy_ecs/src/system/commands/mod.rs    |  6 +++---
 crates/bevy_ecs/src/system/system_registry.rs |  8 ++++----
 3 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index a83b824ca9f45..ecccb0a67bbd3 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -5,9 +5,7 @@ use bevy_ecs::system::{Callback, SystemRegistryError};
 impl App {
     /// Register a system with any number of [`SystemLabel`]s.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`].
-    ///
-    /// [`SystemRegistry`]: bevy_ecs::system::SystemRegistry
+    /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register_system).
     pub fn register_system<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
@@ -24,7 +22,7 @@ impl App {
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_system`](bevy_ecs::system::SystemRegistry::run_system).
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
         &mut self,
@@ -36,7 +34,7 @@ impl App {
 
     /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_systems_by_label`](bevy_ecs::system::SystemRegistry::run_systems_by_label).
     #[inline]
     pub fn run_systems_by_label<L: SystemLabel>(
         &mut self,
@@ -47,7 +45,7 @@ impl App {
 
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_callback`](bevy_ecs::system::SystemRegistry::run_callback).
     #[inline]
     pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
         self.world.run_callback(callback)
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 4d32d9b36a2ca..b60cc7ab2199c 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -525,7 +525,7 @@ impl<'w, 's> Commands<'w, 's> {
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_system`](crate::SystemRegistry::run_system).
     pub fn run_system<
         Params: Send + Sync + 'static,
         S: IntoSystem<(), (), Params> + Send + Sync + 'static,
@@ -538,7 +538,7 @@ impl<'w, 's> Commands<'w, 's> {
 
     /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_systems_by_label`](crate::SystemRegistry::run_systems_by_label).
     pub fn run_systems_by_label(&mut self, label: impl SystemLabel) {
         self.queue.push(RunSystemsByLabelCommand {
             callback: Callback {
@@ -549,7 +549,7 @@ impl<'w, 's> Commands<'w, 's> {
 
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
-    /// Calls the method of the same name on [`SystemRegistry`](crate::system::SystemRegistry).
+    /// Calls [`SystemRegistry::run_callback`](crate::SystemRegistry::run_callback).
     pub fn run_callback(&mut self, callback: Callback) {
         self.queue.push(RunSystemsByLabelCommand { callback });
     }
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 72e30984d57e7..a8519970ef1f9 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -292,7 +292,7 @@ impl SystemRegistry {
 impl World {
     /// Register system a system with any number of [`SystemLabel`]s.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`].
+    /// Calls [`SystemRegistry::register_system`].
     pub fn register_system<
         Params,
         S: IntoSystem<(), (), Params> + 'static,
@@ -310,7 +310,7 @@ impl World {
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`].
+    /// Calls [`SystemRegistry::run_system`].
     #[inline]
     pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
@@ -320,7 +320,7 @@ impl World {
 
     /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
     ///
-    /// Calls the method of the same name on [`SystemRegistry`].
+    /// Calls [`SystemRegistry::run_systems_by_label`].
     #[inline]
     pub fn run_systems_by_label<L: SystemLabel>(
         &mut self,
@@ -333,7 +333,7 @@ impl World {
 
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
-    /// Calls the method of the same name on [`SystemRegistry`].
+    /// Calls [`SystemRegistry::run_callback`].
     #[inline]
     pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {

From aa43356d27e5657a3cdbc593d5535f0ef72bc673 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Thu, 9 Mar 2023 18:51:04 +0100
Subject: [PATCH 060/113] fix doc tests

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index a8519970ef1f9..963a2b46e3767 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -65,7 +65,7 @@ use bevy_ecs_macros::Component;
 ///
 /// fn spawn_7_entities(mut commands: Commands) {
 ///     for _ in 0..7 {
-///         commands.spawn().insert(Marker);
+///         commands.spawn(Marker);
 ///     }
 /// }
 ///

From 7a2b873b9167b598b8121dc4a73d56b3ab9e610b Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Fri, 10 Mar 2023 12:37:47 +0100
Subject: [PATCH 061/113] remove run_systems_by_set

---
 crates/bevy_app/src/system_registry.rs        |  26 +-
 crates/bevy_ecs/src/schedule/set.rs           |   1 +
 crates/bevy_ecs/src/system/system_registry.rs | 256 ++++--------------
 3 files changed, 52 insertions(+), 231 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index ecccb0a67bbd3..23ec10917d1fb 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -6,17 +6,11 @@ impl App {
     /// Register a system with any number of [`SystemLabel`]s.
     ///
     /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register_system).
-    pub fn register_system<
-        Params,
-        S: IntoSystem<(), (), Params> + 'static,
-        LI: IntoIterator<Item = L>,
-        L: SystemLabel,
-    >(
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         system: S,
-        labels: LI,
     ) -> &mut Self {
-        self.world.register_system(system, labels);
+        self.world.register_system(system);
         self
     }
 
@@ -24,25 +18,11 @@ impl App {
     ///
     /// Calls [`SystemRegistry::run_system`](bevy_ecs::system::SystemRegistry::run_system).
     #[inline]
-    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
-        &mut self,
-        system: S,
-    ) -> &mut Self {
+    pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> &mut Self {
         self.world.run_system(system);
         self
     }
 
-    /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
-    ///
-    /// Calls [`SystemRegistry::run_systems_by_label`](bevy_ecs::system::SystemRegistry::run_systems_by_label).
-    #[inline]
-    pub fn run_systems_by_label<L: SystemLabel>(
-        &mut self,
-        label: L,
-    ) -> Result<(), SystemRegistryError> {
-        self.world.run_systems_by_label(label)
-    }
-
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls [`SystemRegistry::run_callback`](bevy_ecs::system::SystemRegistry::run_callback).
diff --git a/crates/bevy_ecs/src/schedule/set.rs b/crates/bevy_ecs/src/schedule/set.rs
index 1277f4b54dc2b..9330c0e8db63f 100644
--- a/crates/bevy_ecs/src/schedule/set.rs
+++ b/crates/bevy_ecs/src/schedule/set.rs
@@ -81,6 +81,7 @@ impl<T> Hash for SystemTypeSet<T> {
         // all systems of a given type are the same
     }
 }
+
 impl<T> Clone for SystemTypeSet<T> {
     fn clone(&self) -> Self {
         *self
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 963a2b46e3767..6160da09f98d9 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,10 +1,10 @@
 use bevy_utils::tracing::warn;
-use bevy_utils::HashMap;
+use bevy_utils::{Entry, HashMap};
 use std::hash::Hash;
 use std::marker::PhantomData;
 
-use crate::schedule::{IntoSystemDescriptor, SystemLabel};
-use crate::system::{Command, IntoSystem, System, SystemTypeIdLabel};
+use crate::schedule::{BoxedSystemSet, IntoSystemConfig, SystemTypeSet};
+use crate::system::{BoxedSystem, Command, IntoSystem};
 use crate::world::{Mut, World};
 // Needed for derive(Component) macro
 use crate as bevy_ecs;
@@ -79,13 +79,7 @@ use bevy_ecs_macros::Component;
 /// ```
 #[derive(Default)]
 pub struct SystemRegistry {
-    systems: Vec<StoredSystem>,
-    // Stores the index of all systems that match the key's label
-    labels: HashMap<Box<dyn SystemLabel>, Vec<usize>>,
-}
-
-struct StoredSystem {
-    system: Box<dyn System<In = (), Out = ()>>,
+    systems: HashMap<BoxedSystemSet, BoxedSystem>,
 }
 
 impl SystemRegistry {
@@ -99,139 +93,50 @@ impl SystemRegistry {
     ///
     /// To provide explicit label(s), use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
-    fn register_system_with_type_label<Params, S: IntoSystem<(), (), Params> + 'static>(
+    fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
     ) {
-        let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
-
+        let boxed_set: BoxedSystemSet = Box::new(SystemTypeSet::<S>::new());
         // This avoids nasty surprising behavior in case systems are registered twice
-        if !self.is_label_registered(automatic_system_label) {
-            let boxed_system: Box<dyn System<In = (), Out = ()>> =
-                Box::new(IntoSystem::into_system(system));
-            self.register_boxed_system(world, boxed_system, vec![Box::new(automatic_system_label)]);
+        if !self.systems.contains_key(&boxed_set) {
+            // Initialize the system's state
+            let mut boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
+            boxed_system.initialize(world);
+            // Insert they system keyed by its set
+            self.systems.insert(boxed_set, boxed_system);
         } else {
             let type_name = std::any::type_name::<S>();
             warn!("A system of type {type_name} was registered more than once!");
         };
     }
 
-    /// Register a system so that it may be run by any of their [`SystemLabel`]s.
+    /// Runs the supplied system on the [`World`] a single time.
     ///
-    /// This is only needed if you want to run a system by a particular label;
-    /// the `run_system` label will automatically register systems under their [`SystemTypeIdLabel`] when first used.
+    /// You do not need to register systems before they are run in this way.
+    /// Instead, systems will be automatically registered according to their [`SystemTypeSet`] the first time this method is called on them.
     ///
-    /// # Warning
+    /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
     ///
-    /// Duplicate systems may be added if this method is called repeatedly.
-    /// Each copy will be called seperately if they share a label.
-    pub fn register_system<
-        Params,
-        S: IntoSystem<(), (), Params> + 'static,
-        LI: IntoIterator<Item = L>,
-        L: SystemLabel,
-    >(
+    /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeSet`],
+    /// only the first will be run.
+    pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         world: &mut World,
         system: S,
-        labels: LI,
     ) {
-        let boxed_system: Box<dyn System<In = (), Out = ()>> =
-            Box::new(IntoSystem::into_system(system));
-
-        let collected_labels = labels
-            .into_iter()
-            .map(|label| {
-                let boxed_label: Box<dyn SystemLabel> = Box::new(label);
-                boxed_label
-            })
-            .collect();
-
-        self.register_boxed_system(world, boxed_system, collected_labels);
-    }
-
-    /// A less generic version of [`register_system`](Self::register_system_with_labels).
-    ///
-    /// Returns the index in the vector of systems that this new system is stored at.
-    /// This is only useful for debugging as an external user of this method.
-    ///
-    /// This can be useful when you have a boxed system or boxed labels,
-    /// as the corresponding traits are not implemented for boxed trait objects
-    /// to avoid indefinite nesting.
-    pub fn register_boxed_system(
-        &mut self,
-        world: &mut World,
-        mut boxed_system: Box<dyn System<In = (), Out = ()>>,
-        labels: Vec<Box<dyn SystemLabel>>,
-    ) -> usize {
-        // Intialize the system's state
-        boxed_system.initialize(world);
-
-        let stored_system = StoredSystem {
-            system: boxed_system,
+        let boxed_set = Box::new(SystemTypeSet::<S>::new());
+        let matching_system = match self.systems.entry(boxed_set) {
+            Entry::Occupied(o) => o.into_mut(),
+            Entry::Vacant(v) => {
+                let mut boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
+                boxed_system.initialize(world);
+                v.insert(boxed_system)
+            }
         };
-
-        // Add the system to the end of the vec
-        let system_index = self.systems.len();
-        self.systems.push(stored_system);
-
-        // For each label that the system has
-        for label in labels {
-            let maybe_label_indexes = self.labels.get_mut(&label);
-
-            // Add the index of the system in the vec to the lookup hashmap
-            // under the corresponding label key
-            if let Some(label_indexes) = maybe_label_indexes {
-                label_indexes.push(system_index);
-            } else {
-                self.labels.insert(label, vec![system_index]);
-            };
-        }
-
-        system_index
-    }
-
-    /// Runs the system at the supplied `index` a single time.
-    #[inline]
-    fn run_system_at_index(&mut self, world: &mut World, index: usize) {
-        let stored_system = &mut self.systems[index];
-
-        // Run the system
-        stored_system.system.run((), world);
-        // Apply any generated commands
-        stored_system.system.apply_buffers(world);
-    }
-
-    /// Is at least one system in the [`SystemRegistry`] associated with the provided [`SystemLabel`]?
-    #[inline]
-    pub fn is_label_registered<L: SystemLabel>(&self, label: L) -> bool {
-        let boxed_label: Box<dyn SystemLabel> = Box::new(label);
-        self.labels.get(&boxed_label).is_some()
-    }
-
-    /// Returns the first matching index for systems with this label if any.
-    #[inline]
-    fn first_registered_index<L: SystemLabel>(&self, label: L) -> Option<usize> {
-        let boxed_label: Box<dyn SystemLabel> = Box::new(label);
-        let vec_of_indexes = self.labels.get(&boxed_label)?;
-        vec_of_indexes.iter().next().copied()
-    }
-
-    /// Runs the set of systems corresponding to the provided [`SystemLabel`] on the [`World`] a single time.
-    ///
-    /// Systems will be run sequentially in registration order if more than one registered system matches the provided label.
-    pub fn run_systems_by_label<L: SystemLabel>(
-        &mut self,
-        world: &mut World,
-        label: L,
-    ) -> Result<(), SystemRegistryError> {
-        self.run_callback(
-            world,
-            Callback {
-                label: label.dyn_clone(),
-            },
-        )
+        matching_system.run((), world);
+        matching_system.apply_buffers(world);
     }
 
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
@@ -246,65 +151,25 @@ impl SystemRegistry {
         world: &mut World,
         callback: Callback,
     ) -> Result<(), SystemRegistryError> {
-        let boxed_label = callback.label;
-
-        match self.labels.get(&boxed_label) {
-            Some(matching_indexes) => {
-                // Loop over the system in registration order
-                for index in matching_indexes.clone() {
-                    self.run_system_at_index(world, index);
-                }
-
+        let boxed_set = callback.set;
+        match self.systems.get_mut(&boxed_set) {
+            Some(matching_system) => {
+                matching_system.run((), world);
+                matching_system.apply_buffers(world);
                 Ok(())
             }
             None => Err(SystemRegistryError::LabelNotFound(boxed_label)),
         }
     }
-
-    /// Runs the supplied system on the [`World`] a single time.
-    ///
-    /// You do not need to register systems before they are run in this way.
-    /// Instead, systems will be automatically registered according to their [`SystemTypeIdLabel`] the first time this method is called on them.
-    ///
-    /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
-    ///
-    /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeIdLabel`],
-    /// only the first will be run.
-    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(
-        &mut self,
-        world: &mut World,
-        system: S,
-    ) {
-        let automatic_system_label: SystemTypeIdLabel<S> = SystemTypeIdLabel::new();
-        let index = if self.is_label_registered(automatic_system_label) {
-            self.first_registered_index(automatic_system_label).unwrap()
-        } else {
-            let boxed_system: Box<dyn System<In = (), Out = ()>> =
-                Box::new(IntoSystem::into_system(system));
-            let labels = boxed_system.default_labels();
-            self.register_boxed_system(world, boxed_system, labels)
-        };
-
-        self.run_system_at_index(world, index);
-    }
 }
 
 impl World {
-    /// Register system a system with any number of [`SystemLabel`]s.
+    /// Register a system with its [`SystemTypeSet`].
     ///
-    /// Calls [`SystemRegistry::register_system`].
-    pub fn register_system<
-        Params,
-        S: IntoSystem<(), (), Params> + 'static,
-        LI: IntoIterator<Item = L>,
-        L: SystemLabel,
-    >(
-        &mut self,
-        system: S,
-        labels: LI,
-    ) {
+    /// Calls [`SystemRegistry::register_system_with_type_set`].
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system, labels);
+            registry.register_system(world, system);
         });
     }
 
@@ -312,26 +177,13 @@ impl World {
     ///
     /// Calls [`SystemRegistry::run_system`].
     #[inline]
-    pub fn run_system<Params, S: IntoSystem<(), (), Params> + 'static>(&mut self, system: S) {
+    pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry.run_system(world, system);
         });
     }
 
-    /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
-    ///
-    /// Calls [`SystemRegistry::run_systems_by_label`].
-    #[inline]
-    pub fn run_systems_by_label<L: SystemLabel>(
-        &mut self,
-        label: L,
-    ) -> Result<(), SystemRegistryError> {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_systems_by_label(world, label)
-        })
-    }
-
-    /// Run the systems corresponding to the label stored in the provided [`Callback`]
+    /// Run the systems corresponding to the set stored in the provided [`Callback`]
     ///
     /// Calls [`SystemRegistry::run_callback`].
     #[inline]
@@ -345,15 +197,15 @@ impl World {
 /// The [`Command`] type for [`SystemRegistry::run_system`]
 #[derive(Debug, Clone)]
 pub struct RunSystemCommand<
-    Params: Send + Sync + 'static,
-    S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+    M: Send + Sync + 'static,
+    S: IntoSystem<(), (), M> + Send + Sync + 'static,
 > {
-    _phantom_params: PhantomData<Params>,
+    _phantom_params: PhantomData<M>,
     system: S,
 }
 
-impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static>
-    RunSystemCommand<Params, S>
+impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
+    RunSystemCommand<M, S>
 {
     /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
     #[inline]
@@ -366,8 +218,8 @@ impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync
     }
 }
 
-impl<Params: Send + Sync + 'static, S: IntoSystem<(), (), Params> + Send + Sync + 'static> Command
-    for RunSystemCommand<Params, S>
+impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> Command
+    for RunSystemCommand<M, S>
 {
     #[inline]
     fn apply(self, world: &mut World) {
@@ -419,7 +271,7 @@ impl Callback {
     /// Creates a new callback from a function that can be used as a system.
     ///
     /// Remember that you must register your systems with the `App` / [`World`] before they can be run as callbacks!
-    pub fn new<S: IntoSystemDescriptor<Params> + 'static, Params>(_system: S) -> Self {
+    pub fn new<S: IntoSystemConfig<M> + 'static, M>(_system: S) -> Self {
         Callback {
             label: Box::new(SystemTypeIdLabel::<S>::new()),
         }
@@ -480,18 +332,6 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
-    #[test]
-    fn run_system_by_label() {
-        let mut world = World::new();
-        world.init_resource::<Counter>();
-        assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.register_system(count_up, ["count"]);
-        world.register_system(count_up, ["count"]);
-        world.run_systems_by_label("count").unwrap();
-        // All systems matching the label will be run.
-        assert_eq!(*world.resource::<Counter>(), Counter(2));
-    }
-
     #[allow(dead_code)]
     fn spawn_entity(mut commands: Commands) {
         commands.spawn();

From ffdbd9ba7c7d7ea538afde75f8cf7dcfd18c2d92 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Fri, 10 Mar 2023 12:50:17 +0100
Subject: [PATCH 062/113] remove run_systems_by_label from Commands

---
 crates/bevy_ecs/src/system/commands/mod.rs    | 21 +++++--------------
 crates/bevy_ecs/src/system/system_registry.rs |  4 ++--
 2 files changed, 7 insertions(+), 18 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index b60cc7ab2199c..740933932c451 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,8 +5,8 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    schedule::SystemLabel,
-    system::{Callback, IntoSystem, RunSystemCommand, RunSystemsByLabelCommand},
+    schedule::SystemSet,
+    system::{Callback, IntoSystem, RunCallback, RunSystemCommand},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -527,8 +527,8 @@ impl<'w, 's> Commands<'w, 's> {
     ///
     /// Calls [`SystemRegistry::run_system`](crate::SystemRegistry::run_system).
     pub fn run_system<
-        Params: Send + Sync + 'static,
-        S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+        M: Send + Sync + 'static,
+        S: IntoSystem<(), (), M> + Send + Sync + 'static,
     >(
         &mut self,
         system: S,
@@ -536,22 +536,11 @@ impl<'w, 's> Commands<'w, 's> {
         self.queue.push(RunSystemCommand::new(system));
     }
 
-    /// Runs the systems corresponding to the supplied [`SystemLabel`] on the [`World`] a single time.
-    ///
-    /// Calls [`SystemRegistry::run_systems_by_label`](crate::SystemRegistry::run_systems_by_label).
-    pub fn run_systems_by_label(&mut self, label: impl SystemLabel) {
-        self.queue.push(RunSystemsByLabelCommand {
-            callback: Callback {
-                label: Box::new(label),
-            },
-        });
-    }
-
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls [`SystemRegistry::run_callback`](crate::SystemRegistry::run_callback).
     pub fn run_callback(&mut self, callback: Callback) {
-        self.queue.push(RunSystemsByLabelCommand { callback });
+        self.queue.push(RunCallback { callback });
     }
 
     /// Pushes a generic [`Command`] to the command queue.
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 6160da09f98d9..936e1ddf0bbf4 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -233,11 +233,11 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 
 /// The [`Command`] type for [`SystemRegistry::run_systems_by_label`]
 #[derive(Debug, Clone)]
-pub struct RunSystemsByLabelCommand {
+pub struct RunCallback {
     pub callback: Callback,
 }
 
-impl Command for RunSystemsByLabelCommand {
+impl Command for RunCallback {
     #[inline]
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {

From eea7e1658e4e02251660900a106d00f2faa75dd7 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Fri, 10 Mar 2023 13:08:51 +0100
Subject: [PATCH 063/113] rename params to marker

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 936e1ddf0bbf4..b26913a6d63e8 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -200,7 +200,7 @@ pub struct RunSystemCommand<
     M: Send + Sync + 'static,
     S: IntoSystem<(), (), M> + Send + Sync + 'static,
 > {
-    _phantom_params: PhantomData<M>,
+    _phantom_marker: PhantomData<M>,
     system: S,
 }
 
@@ -212,7 +212,7 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
     #[must_use]
     pub fn new(system: S) -> Self {
         Self {
-            _phantom_params: PhantomData::default(),
+            _phantom_marker: PhantomData::default(),
             system,
         }
     }

From 95efbb0d389045ccefe091067cec531b8b55dcb6 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Mon, 13 Mar 2023 16:58:35 +0100
Subject: [PATCH 064/113] key systems by SystemId

---
 crates/bevy_app/src/system_registry.rs        |  10 +-
 crates/bevy_ecs/src/system/commands/mod.rs    |   9 +-
 crates/bevy_ecs/src/system/system_registry.rs | 167 +++++++-----------
 examples/ecs/one_shot_systems.rs              |  30 ++--
 4 files changed, 92 insertions(+), 124 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 23ec10917d1fb..83514afa7b706 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -1,6 +1,8 @@
 use crate::App;
-use bevy_ecs::prelude::*;
-use bevy_ecs::system::{Callback, SystemRegistryError};
+use bevy_ecs::{
+    prelude::*,
+    system::{SystemId, SystemRegistryError},
+};
 
 impl App {
     /// Register a system with any number of [`SystemLabel`]s.
@@ -27,7 +29,7 @@ impl App {
     ///
     /// Calls [`SystemRegistry::run_callback`](bevy_ecs::system::SystemRegistry::run_callback).
     #[inline]
-    pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
-        self.world.run_callback(callback)
+    pub fn run_system_by_id(&mut self, system_id: SystemId) -> Result<(), SystemRegistryError> {
+        self.world.run_system_by_id(system_id)
     }
 }
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 740933932c451..9e58496c81294 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,8 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    schedule::SystemSet,
-    system::{Callback, IntoSystem, RunCallback, RunSystemCommand},
+    system::{IntoSystem, RunSystem, RunSystemById, SystemId},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -533,14 +532,14 @@ impl<'w, 's> Commands<'w, 's> {
         &mut self,
         system: S,
     ) {
-        self.queue.push(RunSystemCommand::new(system));
+        self.queue.push(RunSystem::new(system));
     }
 
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls [`SystemRegistry::run_callback`](crate::SystemRegistry::run_callback).
-    pub fn run_callback(&mut self, callback: Callback) {
-        self.queue.push(RunCallback { callback });
+    pub fn run_system_by_id(&mut self, system_id: SystemId) {
+        self.queue.push(RunSystemById::new(system_id));
     }
 
     /// Pushes a generic [`Command`] to the command queue.
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index b26913a6d63e8..be946c9f10c81 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,14 +1,12 @@
-use bevy_utils::tracing::warn;
-use bevy_utils::{Entry, HashMap};
+use std::any::TypeId;
 use std::hash::Hash;
 use std::marker::PhantomData;
 
-use crate::schedule::{BoxedSystemSet, IntoSystemConfig, SystemTypeSet};
 use crate::system::{BoxedSystem, Command, IntoSystem};
 use crate::world::{Mut, World};
 // Needed for derive(Component) macro
-use crate as bevy_ecs;
-use bevy_ecs_macros::Component;
+use crate::{self as bevy_ecs, TypeIdMap};
+use bevy_ecs_macros::Resource;
 
 /// Stores initialized [`System`]s, so they can be reused and run in an ad-hoc fashion.
 ///
@@ -79,7 +77,8 @@ use bevy_ecs_macros::Component;
 /// ```
 #[derive(Default)]
 pub struct SystemRegistry {
-    systems: HashMap<BoxedSystemSet, BoxedSystem>,
+    systems: Vec<(bool, BoxedSystem)>,
+    indices: TypeIdMap<usize>,
 }
 
 impl SystemRegistry {
@@ -93,23 +92,20 @@ impl SystemRegistry {
     ///
     /// To provide explicit label(s), use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
-    fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
-        world: &mut World,
         system: S,
-    ) {
-        let boxed_set: BoxedSystemSet = Box::new(SystemTypeSet::<S>::new());
-        // This avoids nasty surprising behavior in case systems are registered twice
-        if !self.systems.contains_key(&boxed_set) {
-            // Initialize the system's state
-            let mut boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
-            boxed_system.initialize(world);
-            // Insert they system keyed by its set
-            self.systems.insert(boxed_set, boxed_system);
-        } else {
-            let type_name = std::any::type_name::<S>();
-            warn!("A system of type {type_name} was registered more than once!");
-        };
+    ) -> SystemId {
+        let type_id = TypeId::of::<S>();
+
+        let index = *self.indices.entry(type_id).or_insert_with(|| {
+            let index = self.systems.len();
+            self.systems
+                .push((false, Box::new(IntoSystem::into_system(system))));
+            index
+        });
+
+        SystemId::new(index)
     }
 
     /// Runs the supplied system on the [`World`] a single time.
@@ -126,17 +122,9 @@ impl SystemRegistry {
         world: &mut World,
         system: S,
     ) {
-        let boxed_set = Box::new(SystemTypeSet::<S>::new());
-        let matching_system = match self.systems.entry(boxed_set) {
-            Entry::Occupied(o) => o.into_mut(),
-            Entry::Vacant(v) => {
-                let mut boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
-                boxed_system.initialize(world);
-                v.insert(boxed_system)
-            }
-        };
-        matching_system.run((), world);
-        matching_system.apply_buffers(world);
+        let id = self.register_system(system);
+        self.run_system_by_id(world, id)
+            .expect("System was registered before running");
     }
 
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
@@ -146,31 +134,49 @@ impl SystemRegistry {
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided label.
     #[inline]
-    pub fn run_callback(
+    pub fn run_system_by_id(
         &mut self,
         world: &mut World,
-        callback: Callback,
+        id: SystemId,
     ) -> Result<(), SystemRegistryError> {
-        let boxed_set = callback.set;
-        match self.systems.get_mut(&boxed_set) {
-            Some(matching_system) => {
+        match self.systems.get_mut(id.index()) {
+            Some((initialized, matching_system)) => {
+                if !*initialized {
+                    matching_system.initialize(world);
+                    *initialized = true;
+                }
                 matching_system.run((), world);
                 matching_system.apply_buffers(world);
                 Ok(())
             }
-            None => Err(SystemRegistryError::LabelNotFound(boxed_label)),
+            None => Err(SystemRegistryError::SystemIdNotRegistered(id)),
         }
     }
 }
 
+#[derive(Debug, Copy, Clone, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub struct SystemId(usize);
+
+impl SystemId {
+    #[inline]
+    pub const fn new(index: usize) -> SystemId {
+        SystemId(index)
+    }
+
+    #[inline]
+    pub fn index(self) -> usize {
+        self.0
+    }
+}
+
 impl World {
-    /// Register a system with its [`SystemTypeSet`].
-    ///
-    /// Calls [`SystemRegistry::register_system_with_type_set`].
-    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.register_system(world, system);
-        });
+    #[inline]
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
+        &mut self,
+        system: S,
+    ) -> SystemId {
+        self.resource_mut::<SystemRegistry>()
+            .register_system(system)
     }
 
     /// Runs the supplied system on the [`World`] a single time.
@@ -187,26 +193,21 @@ impl World {
     ///
     /// Calls [`SystemRegistry::run_callback`].
     #[inline]
-    pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
+    pub fn run_system_by_id(&mut self, id: SystemId) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_callback(world, callback)
+            registry.run_system_by_id(world, id)
         })
     }
 }
 
 /// The [`Command`] type for [`SystemRegistry::run_system`]
 #[derive(Debug, Clone)]
-pub struct RunSystemCommand<
-    M: Send + Sync + 'static,
-    S: IntoSystem<(), (), M> + Send + Sync + 'static,
-> {
+pub struct RunSystem<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> {
     _phantom_marker: PhantomData<M>,
     system: S,
 }
 
-impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
-    RunSystemCommand<M, S>
-{
+impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> RunSystem<M, S> {
     /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
     #[inline]
     #[must_use]
@@ -219,7 +220,7 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 }
 
 impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> Command
-    for RunSystemCommand<M, S>
+    for RunSystem<M, S>
 {
     #[inline]
     fn apply(self, world: &mut World) {
@@ -233,16 +234,22 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 
 /// The [`Command`] type for [`SystemRegistry::run_systems_by_label`]
 #[derive(Debug, Clone)]
-pub struct RunCallback {
-    pub callback: Callback,
+pub struct RunSystemById {
+    pub system_id: SystemId,
 }
 
-impl Command for RunCallback {
+impl RunSystemById {
+    pub fn new(system_id: SystemId) -> Self {
+        Self { system_id }
+    }
+}
+
+impl Command for RunSystemById {
     #[inline]
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry
-                .run_callback(world, self.callback)
+                .run_system_by_id(world, self.system_id)
                 // Ideally this error should be handled more gracefully,
                 // but that's blocked on a full error handling solution for commands
                 .unwrap();
@@ -250,53 +257,13 @@ impl Command for RunCallback {
     }
 }
 
-/// A struct that stores a boxed [`SystemLabel`], used to cause a [`SystemRegistry`] to run systems.
-///
-/// This might be stored as a component, used as an event, or arranged in a queue stored in a resource.
-/// Unless you need to inspect the list of events or add additional information,
-/// prefer the simpler `commands.run_system` over storing callbacks as events,
-///
-/// Systems must be registered via the `register_system` methods on [`SystemRegistry`], [`World`] or `App`
-/// before they can be run by their label using a callback.
-#[derive(Debug, Component, Clone, Eq)]
-pub struct Callback {
-    /// The label of the system(s) to be run.
-    ///
-    /// By default, this is set to the [`SystemTypeIdLabel`]
-    /// of the system passed in via [`Callback::new()`].
-    pub label: Box<dyn SystemLabel>,
-}
-
-impl Callback {
-    /// Creates a new callback from a function that can be used as a system.
-    ///
-    /// Remember that you must register your systems with the `App` / [`World`] before they can be run as callbacks!
-    pub fn new<S: IntoSystemConfig<M> + 'static, M>(_system: S) -> Self {
-        Callback {
-            label: Box::new(SystemTypeIdLabel::<S>::new()),
-        }
-    }
-}
-
-impl PartialEq for Callback {
-    fn eq(&self, other: &Self) -> bool {
-        self.label.dyn_eq(other.label.as_dyn_eq())
-    }
-}
-
-impl Hash for Callback {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.label.dyn_hash(state);
-    }
-}
-
 /// An operation on a [`SystemRegistry`] failed
 #[derive(Debug)]
 pub enum SystemRegistryError {
     /// A system was run by label, but no system with that label was found.
     ///
     /// Did you forget to register it?
-    LabelNotFound(Box<dyn SystemLabel>),
+    SystemIdNotRegistered(SystemId),
 }
 
 mod tests {
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index abed2a5b88cb8..9244385dfe4a2 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -6,8 +6,10 @@
 //!
 //! See the [`SystemRegistry`](bevy::ecs::SystemRegistry) docs for more details.
 
-use bevy::ecs::system::Callback;
-use bevy::prelude::*;
+use bevy::{
+    ecs::system::{SystemId, SystemRegistry},
+    prelude::*,
+};
 
 fn main() {
     App::new()
@@ -15,12 +17,7 @@ fn main() {
         .add_startup_system(setup)
         // One shot systems are interchangeable with ordinarily scheduled systems.
         // Change detection, Local and NonSend all work as expected.
-        .add_system_to_stage(CoreStage::PostUpdate, count_entities)
-        // Registered systems can be called dynamically by their label.
-        // These must be registered in advance, or commands.run_system will panic
-        // as no matching system was found.
-        .register_system(button_pressed)
-        .register_system(slider_toggled)
+        .add_system(count_entities.in_base_set(CoreSet::PostUpdate))
         // One-shot systems can be used to build complex abstractions
         // to match the needs of your design.
         // Here, we model a very simple component-linked callback architecture.
@@ -35,19 +32,22 @@ fn count_entities(all_entities: Query<()>) {
     dbg!(all_entities.iter().count());
 }
 
+#[derive(Component)]
+struct Callback(SystemId);
+
 #[derive(Component)]
 struct Triggered;
 
-fn setup(mut commands: Commands) {
-    commands
-        .spawn()
+fn setup(mut system_registry: ResMut<SystemRegistry>, mut commands: Commands) {
+    commands.spawn((
         // The Callback component is defined in bevy_ecs,
         // but wrapping this (or making your own customized variant) is easy.
         // Just stored a boxed SystemLabel!
-        .insert(Callback::new(button_pressed))
-        .insert(Triggered);
+        Callback(system_registry.register_system(button_pressed)),
+        Triggered,
+    ));
     // This entity does not have a Triggered component, so its callback won't run.
-    commands.spawn().insert(Callback::new(slider_toggled));
+    commands.spawn(Callback(system_registry.register_system(slider_toggled)));
     commands.run_system(count_entities);
 }
 
@@ -68,6 +68,6 @@ fn evaluate_callbacks(query: Query<&Callback, With<Triggered>>, mut commands: Co
         // we have to use the layer of indirection provided by system labels.
         // Note that if we had registered multiple systems with the same label,
         // they would all be evaluated here.
-        commands.run_callback(callback.clone());
+        commands.run_system_by_id(callback.0);
     }
 }

From b035e3b351c8bba52525a028782628dc0b93b9ab Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Mon, 13 Mar 2023 17:19:21 +0100
Subject: [PATCH 065/113] shorten system registry function names

---
 crates/bevy_ecs/src/system/system_registry.rs | 26 +++++++------------
 examples/ecs/one_shot_systems.rs              |  4 +--
 2 files changed, 11 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index be946c9f10c81..dc15ea21c211f 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -92,10 +92,7 @@ impl SystemRegistry {
     ///
     /// To provide explicit label(s), use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
-    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
-        &mut self,
-        system: S,
-    ) -> SystemId {
+    pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> SystemId {
         let type_id = TypeId::of::<S>();
 
         let index = *self.indices.entry(type_id).or_insert_with(|| {
@@ -117,13 +114,9 @@ impl SystemRegistry {
     ///
     /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeSet`],
     /// only the first will be run.
-    pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(
-        &mut self,
-        world: &mut World,
-        system: S,
-    ) {
-        let id = self.register_system(system);
-        self.run_system_by_id(world, id)
+    pub fn run<M, S: IntoSystem<(), (), M> + 'static>(&mut self, world: &mut World, system: S) {
+        let id = self.register(system);
+        self.run_by_id(world, id)
             .expect("System was registered before running");
     }
 
@@ -134,7 +127,7 @@ impl SystemRegistry {
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided label.
     #[inline]
-    pub fn run_system_by_id(
+    pub fn run_by_id(
         &mut self,
         world: &mut World,
         id: SystemId,
@@ -175,8 +168,7 @@ impl World {
         &mut self,
         system: S,
     ) -> SystemId {
-        self.resource_mut::<SystemRegistry>()
-            .register_system(system)
+        self.resource_mut::<SystemRegistry>().register(system)
     }
 
     /// Runs the supplied system on the [`World`] a single time.
@@ -185,7 +177,7 @@ impl World {
     #[inline]
     pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system(world, system);
+            registry.run(world, system);
         });
     }
 
@@ -195,7 +187,7 @@ impl World {
     #[inline]
     pub fn run_system_by_id(&mut self, id: SystemId) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_system_by_id(world, id)
+            registry.run_by_id(world, id)
         })
     }
 }
@@ -249,7 +241,7 @@ impl Command for RunSystemById {
     fn write(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry
-                .run_system_by_id(world, self.system_id)
+                .run_by_id(world, self.system_id)
                 // Ideally this error should be handled more gracefully,
                 // but that's blocked on a full error handling solution for commands
                 .unwrap();
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 9244385dfe4a2..65297617559a4 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -43,11 +43,11 @@ fn setup(mut system_registry: ResMut<SystemRegistry>, mut commands: Commands) {
         // The Callback component is defined in bevy_ecs,
         // but wrapping this (or making your own customized variant) is easy.
         // Just stored a boxed SystemLabel!
-        Callback(system_registry.register_system(button_pressed)),
+        Callback(system_registry.register(button_pressed)),
         Triggered,
     ));
     // This entity does not have a Triggered component, so its callback won't run.
-    commands.spawn(Callback(system_registry.register_system(slider_toggled)));
+    commands.spawn(Callback(system_registry.register(slider_toggled)));
     commands.run_system(count_entities);
 }
 

From 383cbebd2a81eb05d3cd79e61884d0f4fc3f928c Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 27 Jun 2023 14:43:23 +0200
Subject: [PATCH 066/113] Fixed most mistakes made during rebasing

---
 crates/bevy_ecs/src/system/commands/mod.rs    |  1 -
 crates/bevy_ecs/src/system/function_system.rs | 17 +++-----------
 crates/bevy_ecs/src/system/system_registry.rs | 23 ++++++++-----------
 crates/bevy_ecs/src/world/mod.rs              | 10 +++-----
 4 files changed, 16 insertions(+), 35 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 9e58496c81294..3e5d78ca95125 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -12,7 +12,6 @@ use bevy_ecs_macros::SystemParam;
 use bevy_utils::tracing::{error, info};
 pub use command_queue::CommandQueue;
 pub use parallel_scope::*;
-use std::marker::PhantomData;
 use std::{any::TypeId, marker::PhantomData};
 
 
diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index abb7a0a88fb3f..7ef73731d6408 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -8,7 +8,7 @@ use crate::{
 };
 
 use bevy_utils::all_tuples;
-use std::{any::TypeId, borrow::Cow, marker::PhantomData};
+use std::{any::TypeId, borrow::Cow, marker::PhantomData, fmt::Debug, hash::Hash};
 
 use super::{In, IntoSystem, ReadOnlySystem};
 
@@ -526,10 +526,6 @@ where
     F: SystemParamFunction<Marker>,
     F::Param: ReadOnlySystemParam,
 {
-    #[inline]
-    fn default_labels(&self) -> Vec<SystemLabelId> {
-        vec![self.func.as_system_label().as_label()]
-    }
 }
 
 /// A [`SystemLabel`] that was automatically generated for a system on the basis of its `TypeId`.
@@ -546,13 +542,6 @@ impl<T: 'static> SystemTypeIdLabel<T> {
     }
 }
 
-impl<T: 'static> SystemLabel for SystemTypeIdLabel<T> {
-    #[inline]
-    fn as_str(&self) -> &'static str {
-        std::any::type_name::<T>()
-    }
-}
-
 impl<T> Debug for SystemTypeIdLabel<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_tuple("SystemTypeIdLabel")
@@ -582,8 +571,8 @@ impl<T> PartialEq for SystemTypeIdLabel<T> {
 }
 impl<T> Eq for SystemTypeIdLabel<T> {}
 
-impl<T> SystemLabel for SystemTypeIdLabel<T> {
-    fn dyn_clone(&self) -> Box<dyn SystemLabel> {
+impl<T> crate::schedule::SystemSet for SystemTypeIdLabel<T> {
+    fn dyn_clone(&self) -> Box<dyn crate::schedule::SystemSet> {
         Box::new(*self)
     }
 }
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index dc15ea21c211f..01ab720c732b2 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -75,7 +75,7 @@ use bevy_ecs_macros::Resource;
 /// world.run_system(spawn_7_entities);
 /// world.run_system(assert_7_spawned);
 /// ```
-#[derive(Default)]
+#[derive(Resource, Default)]
 pub struct SystemRegistry {
     systems: Vec<(bool, BoxedSystem)>,
     indices: TypeIdMap<usize>,
@@ -139,7 +139,7 @@ impl SystemRegistry {
                     *initialized = true;
                 }
                 matching_system.run((), world);
-                matching_system.apply_buffers(world);
+                // matching_system.apply_buffers(world);
                 Ok(())
             }
             None => Err(SystemRegistryError::SystemIdNotRegistered(id)),
@@ -216,11 +216,7 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 {
     #[inline]
     fn apply(self, world: &mut World) {
-        if self.flush {
-            world.run_system(self.system);
-        } else {
-            world.run_system_without_flushing(self.system);
-        }
+        world.run_system(self.system);
     }
 }
 
@@ -238,7 +234,7 @@ impl RunSystemById {
 
 impl Command for RunSystemById {
     #[inline]
-    fn write(self, world: &mut World) {
+    fn apply(self, world: &mut World) {
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry
                 .run_by_id(world, self.system_id)
@@ -260,8 +256,9 @@ pub enum SystemRegistryError {
 
 mod tests {
     use crate::prelude::*;
+    use crate as bevy_ecs;
 
-    #[derive(Default, PartialEq, Debug)]
+    #[derive(Resource, Default, PartialEq, Debug)]
     struct Counter(u8);
 
     #[allow(dead_code)]
@@ -293,7 +290,7 @@ mod tests {
 
     #[allow(dead_code)]
     fn spawn_entity(mut commands: Commands) {
-        commands.spawn();
+        commands.spawn_empty();
     }
 
     #[test]
@@ -320,7 +317,7 @@ mod tests {
 
     #[test]
     fn change_detection() {
-        #[derive(Default)]
+        #[derive(Resource, Default)]
         struct ChangeDetector;
 
         #[allow(dead_code)]
@@ -353,8 +350,8 @@ mod tests {
     fn local_variables() {
         // The `Local` begins at the default value of 0
         fn doubling(mut last_counter: Local<Counter>, mut counter: ResMut<Counter>) {
-            counter.0 += last_counter.0;
-            last_counter.0 = counter.0;
+            counter.0 += last_counter.0.0;
+            last_counter.0.0 = counter.0;
         }
 
         let mut world = World::new();
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 818e862f9d30c..473c435f69053 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -18,7 +18,7 @@ use crate::{
     component::{Component, ComponentDescriptor, ComponentId, ComponentInfo, ComponentTicks, Components, Tick},
     entity::{AllocAtWithoutReplacement, Entities, Entity, EntityLocation},
     event::{Event, Events},
-    query::{DebugCheckedUnwrap, FilterFetch, QueryState, ReadOnlyWorldQuery, WorldQuery},
+    query::{DebugCheckedUnwrap, QueryState, ReadOnlyWorldQuery, WorldQuery},
     removal_detection::RemovedComponentEvents,
     schedule::{Schedule, ScheduleLabel, Schedules},
     storage::{Column, ResourceData, SparseSet, Storages},
@@ -70,10 +70,6 @@ pub struct World {
     pub(crate) change_tick: AtomicU32,
     pub(crate) last_change_tick: Tick,
     pub(crate) last_check_tick: Tick,
-    /// Stores the systems associated with this [`World`],
-    ///
-    /// These system can be manually run using [`World::run_system`].
-    pub system_registry: SystemRegistry,
 }
 
 impl Default for World {
@@ -92,8 +88,8 @@ impl Default for World {
             change_tick: AtomicU32::new(1),
             last_change_tick: Tick::new(0),
             last_check_tick: Tick::new(0),
-        }
-       // This resource is required by bevy_ecs itself, so cannot be included in a plugin
+        };
+        // This resource is required by bevy_ecs itself, so cannot be included in a plugin
         world.init_resource::<SystemRegistry>();
         world
     }

From cd0e7c5a10e1195be966a6d0e4bf04c30b447b71 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 27 Jun 2023 15:35:05 +0200
Subject: [PATCH 067/113] Fix command_processing test, renamed apply_buffers

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 01ab720c732b2..e68c4bcdee50b 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -139,7 +139,7 @@ impl SystemRegistry {
                     *initialized = true;
                 }
                 matching_system.run((), world);
-                // matching_system.apply_buffers(world);
+                matching_system.apply_deferred(world);
                 Ok(())
             }
             None => Err(SystemRegistryError::SystemIdNotRegistered(id)),

From dea567f8ae5fe816690121eb2943d53050075add Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 27 Jun 2023 16:11:45 +0200
Subject: [PATCH 068/113] Removed unnecessary imports, updated docs

---
 crates/bevy_app/src/system_registry.rs        | 2 +-
 crates/bevy_core/src/lib.rs                   | 2 +-
 crates/bevy_ecs/src/system/commands/mod.rs    | 2 +-
 crates/bevy_ecs/src/system/system_registry.rs | 3 +--
 crates/bevy_ecs/src/world/mod.rs              | 6 +++---
 5 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 83514afa7b706..67a91aaa7dd9c 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -5,7 +5,7 @@ use bevy_ecs::{
 };
 
 impl App {
-    /// Register a system with any number of [`SystemLabel`]s.
+    /// Register a system.
     ///
     /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register_system).
     pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index cd164f0df46a3..d12b2b0479059 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -23,7 +23,7 @@ pub mod prelude {
 use bevy_app::prelude::*;
 use bevy_ecs::{
     entity::Entity,
-    schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
+    schedule::ExclusiveSystemDescriptorCoercion,
     system::IntoExclusiveSystem,
 };
 use bevy_utils::HashSet;
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 3e5d78ca95125..7c264f24263df 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -12,7 +12,7 @@ use bevy_ecs_macros::SystemParam;
 use bevy_utils::tracing::{error, info};
 pub use command_queue::CommandQueue;
 pub use parallel_scope::*;
-use std::{any::TypeId, marker::PhantomData};
+use std::marker::PhantomData;
 
 
 use super::{Deferred, Resource, SystemBuffer, SystemMeta};
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index e68c4bcdee50b..d58048e8b1e2e 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -10,8 +10,7 @@ use bevy_ecs_macros::Resource;
 
 /// Stores initialized [`System`]s, so they can be reused and run in an ad-hoc fashion.
 ///
-/// Systems are keyed by their [`SystemLabel`]:
-///  - all systems with a given label will be run (in linear registration order) when a given label is run
+/// Systems are keyed by their [`SystemId`]:
 ///  - repeated calls with the same function type will reuse cached state, including for change detection
 ///
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 473c435f69053..97c2895a39539 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -14,14 +14,14 @@ pub use world_cell::*;
 use crate::{
     archetype::{ArchetypeComponentId, ArchetypeId, ArchetypeRow, Archetypes},
     bundle::{Bundle, BundleInserter, BundleSpawner, Bundles},
-    change_detection::{MutUntyped, TicksMut, Ticks},
-    component::{Component, ComponentDescriptor, ComponentId, ComponentInfo, ComponentTicks, Components, Tick},
+    change_detection::{MutUntyped, TicksMut},
+    component::{Component, ComponentDescriptor, ComponentId, ComponentInfo, Components, Tick},
     entity::{AllocAtWithoutReplacement, Entities, Entity, EntityLocation},
     event::{Event, Events},
     query::{DebugCheckedUnwrap, QueryState, ReadOnlyWorldQuery, WorldQuery},
     removal_detection::RemovedComponentEvents,
     schedule::{Schedule, ScheduleLabel, Schedules},
-    storage::{Column, ResourceData, SparseSet, Storages},
+    storage::{ResourceData, Storages},
     system::{Resource, SystemRegistry},
     world::error::TryRunScheduleError,
 };

From f47629b4e6e0d6a4adc29f2fb3f2af4c0e45709e Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 27 Jun 2023 22:30:46 +0200
Subject: [PATCH 069/113] Remove all of SystemTypeIdLabel and SystemLabel

---
 crates/bevy_ecs/src/system/function_system.rs | 51 +------------------
 crates/bevy_ecs/src/system/system_registry.rs |  3 +-
 2 files changed, 2 insertions(+), 52 deletions(-)

diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 7ef73731d6408..1862ffc68585b 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -8,7 +8,7 @@ use crate::{
 };
 
 use bevy_utils::all_tuples;
-use std::{any::TypeId, borrow::Cow, marker::PhantomData, fmt::Debug, hash::Hash};
+use std::{any::TypeId, borrow::Cow, marker::PhantomData};
 
 use super::{In, IntoSystem, ReadOnlySystem};
 
@@ -528,55 +528,6 @@ where
 {
 }
 
-/// A [`SystemLabel`] that was automatically generated for a system on the basis of its `TypeId`.
-#[derive(Default)]
-pub struct SystemTypeIdLabel<T: 'static>(PhantomData<fn() -> T>);
-
-impl<T: 'static> SystemTypeIdLabel<T> {
-    /// Constructs a new copy of the [`SystemTypeIdLabel`] for the type `T`
-    ///
-    /// You can also construct this by using [`.as_system_label()`](crate::system::AsSystemLabel) on a concrete instance
-    /// of your function type.
-    pub fn new() -> Self {
-        Self(PhantomData::default())
-    }
-}
-
-impl<T> Debug for SystemTypeIdLabel<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("SystemTypeIdLabel")
-            .field(&std::any::type_name::<T>())
-            .finish()
-    }
-}
-impl<T> Hash for SystemTypeIdLabel<T> {
-    fn hash<H: std::hash::Hasher>(&self, _state: &mut H) {
-        // All SystemTypeIds of a given type are the same.
-    }
-}
-impl<T> Clone for SystemTypeIdLabel<T> {
-    fn clone(&self) -> Self {
-        Self(PhantomData)
-    }
-}
-
-impl<T> Copy for SystemTypeIdLabel<T> {}
-
-impl<T> PartialEq for SystemTypeIdLabel<T> {
-    #[inline]
-    fn eq(&self, _other: &Self) -> bool {
-        // All labels of a given type are equal, as they will all have the same type id
-        true
-    }
-}
-impl<T> Eq for SystemTypeIdLabel<T> {}
-
-impl<T> crate::schedule::SystemSet for SystemTypeIdLabel<T> {
-    fn dyn_clone(&self) -> Box<dyn crate::schedule::SystemSet> {
-        Box::new(*self)
-    }
-}
-
 /// A trait implemented for all functions that can be used as [`System`]s.
 ///
 /// This trait can be useful for making your own systems which accept other systems,
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index d58048e8b1e2e..7d2f9e8702f2f 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -29,7 +29,7 @@ use bevy_ecs_macros::Resource;
 ///
 /// You can run a single system directly on the World,
 /// applying its effect and caching its state for the next time
-/// you call this method (internally, this is based on [`SystemTypeIdLabel`]).
+/// you call this method.
 ///
 /// ```rust
 /// use bevy_ecs::prelude::*;
@@ -83,7 +83,6 @@ pub struct SystemRegistry {
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so then it can be later run.
     ///
-    /// This allows the system to be run by their [`SystemTypeIdLabel`] using the `run_systems_by_label` method.
     /// Repeatedly registering a system will have no effect.
     ///
     /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,

From c39685914cb449841f515a214830bd31784ce528 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 27 Jun 2023 22:54:52 +0200
Subject: [PATCH 070/113] cargo fmt

---
 crates/bevy_ecs/src/system/commands/mod.rs    | 1 -
 crates/bevy_ecs/src/system/system_registry.rs | 6 +++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 7c264f24263df..9b1483a881774 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -14,7 +14,6 @@ pub use command_queue::CommandQueue;
 pub use parallel_scope::*;
 use std::marker::PhantomData;
 
-
 use super::{Deferred, Resource, SystemBuffer, SystemMeta};
 
 /// A [`World`] mutation.
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 7d2f9e8702f2f..d5ddb07e29727 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -253,8 +253,8 @@ pub enum SystemRegistryError {
 }
 
 mod tests {
-    use crate::prelude::*;
     use crate as bevy_ecs;
+    use crate::prelude::*;
 
     #[derive(Resource, Default, PartialEq, Debug)]
     struct Counter(u8);
@@ -348,8 +348,8 @@ mod tests {
     fn local_variables() {
         // The `Local` begins at the default value of 0
         fn doubling(mut last_counter: Local<Counter>, mut counter: ResMut<Counter>) {
-            counter.0 += last_counter.0.0;
-            last_counter.0.0 = counter.0;
+            counter.0 += last_counter.0 .0;
+            last_counter.0 .0 = counter.0;
         }
 
         let mut world = World::new();

From 7c8e15b20ad34cf5e097bb653954cf87cd11806e Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Thu, 29 Jun 2023 14:24:18 +0200
Subject: [PATCH 071/113] Added a failing test with unregistered systems

---
 crates/bevy_ecs/src/system/system_registry.rs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index d5ddb07e29727..8a45af5a194c8 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -294,7 +294,6 @@ mod tests {
     #[test]
     fn command_processing() {
         let mut world = World::new();
-        world.init_resource::<Counter>();
         assert_eq!(world.entities.len(), 0);
         world.run_system(spawn_entity);
         assert_eq!(world.entities.len(), 1);
@@ -365,6 +364,18 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(8));
     }
 
+    #[test]
+    fn unregistered_system_command() {
+        fn command_system(mut commands: Commands) {
+            commands.run_system(spawn_entity);
+        }
+
+        let mut world = World::new();
+        assert_eq!(world.entities.len(), 0);
+        world.run_system(command_system);
+        assert_eq!(world.entities.len(), 1)
+    }
+
     #[test]
     // This is a known limitation;
     // if this test passes the docs must be updated

From 5061e5564118242145fcea38fcade9bc8e964aab Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Mon, 3 Jul 2023 00:56:17 +0200
Subject: [PATCH 072/113] Simplified SystemRegistry, removed SystemId

---
 crates/bevy_ecs/src/system/commands/mod.rs    |  5 +-
 crates/bevy_ecs/src/system/system_registry.rs | 48 ++++++-------------
 2 files changed, 17 insertions(+), 36 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 9b1483a881774..90f31fea0a1c1 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,7 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystem, RunSystemById, SystemId},
+    system::{IntoSystem, RunSystem, RunSystemById},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -13,6 +13,7 @@ use bevy_utils::tracing::{error, info};
 pub use command_queue::CommandQueue;
 pub use parallel_scope::*;
 use std::marker::PhantomData;
+use std::any::TypeId;
 
 use super::{Deferred, Resource, SystemBuffer, SystemMeta};
 
@@ -536,7 +537,7 @@ impl<'w, 's> Commands<'w, 's> {
     /// Run the systems corresponding to the label stored in the provided [`Callback`]
     ///
     /// Calls [`SystemRegistry::run_callback`](crate::SystemRegistry::run_callback).
-    pub fn run_system_by_id(&mut self, system_id: SystemId) {
+    pub fn run_system_by_id(&mut self, system_id: TypeId) {
         self.queue.push(RunSystemById::new(system_id));
     }
 
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 8a45af5a194c8..5a8f6dbcc6736 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -76,8 +76,7 @@ use bevy_ecs_macros::Resource;
 /// ```
 #[derive(Resource, Default)]
 pub struct SystemRegistry {
-    systems: Vec<(bool, BoxedSystem)>,
-    indices: TypeIdMap<usize>,
+    systems: TypeIdMap<(bool, BoxedSystem)>,
 }
 
 impl SystemRegistry {
@@ -90,17 +89,13 @@ impl SystemRegistry {
     ///
     /// To provide explicit label(s), use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
-    pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> SystemId {
+    pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> TypeId {
         let type_id = TypeId::of::<S>();
-
-        let index = *self.indices.entry(type_id).or_insert_with(|| {
-            let index = self.systems.len();
-            self.systems
-                .push((false, Box::new(IntoSystem::into_system(system))));
-            index
-        });
-
-        SystemId::new(index)
+        if !self.systems.contains_key(&type_id) {
+            let boxed_system = Box::new(IntoSystem::into_system(system));
+            self.systems.insert(type_id, (false, boxed_system));
+        }
+        type_id
     }
 
     /// Runs the supplied system on the [`World`] a single time.
@@ -128,9 +123,9 @@ impl SystemRegistry {
     pub fn run_by_id(
         &mut self,
         world: &mut World,
-        id: SystemId,
+        id: TypeId,
     ) -> Result<(), SystemRegistryError> {
-        match self.systems.get_mut(id.index()) {
+        match self.systems.get_mut(&id) {
             Some((initialized, matching_system)) => {
                 if !*initialized {
                     matching_system.initialize(world);
@@ -145,27 +140,12 @@ impl SystemRegistry {
     }
 }
 
-#[derive(Debug, Copy, Clone, Hash, Ord, PartialOrd, Eq, PartialEq)]
-pub struct SystemId(usize);
-
-impl SystemId {
-    #[inline]
-    pub const fn new(index: usize) -> SystemId {
-        SystemId(index)
-    }
-
-    #[inline]
-    pub fn index(self) -> usize {
-        self.0
-    }
-}
-
 impl World {
     #[inline]
     pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         system: S,
-    ) -> SystemId {
+    ) -> TypeId {
         self.resource_mut::<SystemRegistry>().register(system)
     }
 
@@ -183,7 +163,7 @@ impl World {
     ///
     /// Calls [`SystemRegistry::run_callback`].
     #[inline]
-    pub fn run_system_by_id(&mut self, id: SystemId) -> Result<(), SystemRegistryError> {
+    pub fn run_system_by_id(&mut self, id: TypeId) -> Result<(), SystemRegistryError> {
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry.run_by_id(world, id)
         })
@@ -221,11 +201,11 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 /// The [`Command`] type for [`SystemRegistry::run_systems_by_label`]
 #[derive(Debug, Clone)]
 pub struct RunSystemById {
-    pub system_id: SystemId,
+    pub system_id: TypeId,
 }
 
 impl RunSystemById {
-    pub fn new(system_id: SystemId) -> Self {
+    pub fn new(system_id: TypeId) -> Self {
         Self { system_id }
     }
 }
@@ -249,7 +229,7 @@ pub enum SystemRegistryError {
     /// A system was run by label, but no system with that label was found.
     ///
     /// Did you forget to register it?
-    SystemIdNotRegistered(SystemId),
+    SystemIdNotRegistered(TypeId),
 }
 
 mod tests {

From 72b994fed4d72bc5561dbde2474ec29e654acbe8 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Mon, 3 Jul 2023 21:13:29 +0200
Subject: [PATCH 073/113] Fix test, cleanup

---
 crates/bevy_ecs/src/system/system_registry.rs | 20 +++++++++----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 5a8f6dbcc6736..5d05db2fdcda4 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,5 +1,4 @@
 use std::any::TypeId;
-use std::hash::Hash;
 use std::marker::PhantomData;
 
 use crate::system::{BoxedSystem, Command, IntoSystem};
@@ -91,10 +90,9 @@ impl SystemRegistry {
     #[inline]
     pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> TypeId {
         let type_id = TypeId::of::<S>();
-        if !self.systems.contains_key(&type_id) {
-            let boxed_system = Box::new(IntoSystem::into_system(system));
-            self.systems.insert(type_id, (false, boxed_system));
-        }
+        self.systems.entry(type_id).or_insert_with(|| {
+            (false, Box::new(IntoSystem::into_system(system)))
+        });
         type_id
     }
 
@@ -345,15 +343,15 @@ mod tests {
     }
 
     #[test]
-    fn unregistered_system_command() {
-        fn command_system(mut commands: Commands) {
-            commands.run_system(spawn_entity);
-        }
+    fn run_system_through_command() {
+        use crate::system::RunSystem;
+        use crate::system::commands::Command;
 
         let mut world = World::new();
+        let command = RunSystem::new(spawn_entity);
         assert_eq!(world.entities.len(), 0);
-        world.run_system(command_system);
-        assert_eq!(world.entities.len(), 1)
+        command.apply(&mut world);
+        assert_eq!(world.entities.len(), 1);
     }
 
     #[test]

From 64ad487e1ea302028c3672956a091b3f119133c6 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Mon, 3 Jul 2023 22:55:44 +0200
Subject: [PATCH 074/113] Better error for nested/recursive one-shot systems

---
 crates/bevy_ecs/src/system/commands/mod.rs    |  2 +-
 crates/bevy_ecs/src/system/system_registry.rs | 31 +++++++++++--------
 2 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 90f31fea0a1c1..d6cc317521ad0 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -12,8 +12,8 @@ use bevy_ecs_macros::SystemParam;
 use bevy_utils::tracing::{error, info};
 pub use command_queue::CommandQueue;
 pub use parallel_scope::*;
-use std::marker::PhantomData;
 use std::any::TypeId;
+use std::marker::PhantomData;
 
 use super::{Deferred, Resource, SystemBuffer, SystemMeta};
 
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 5d05db2fdcda4..cc2da9e9be871 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -90,9 +90,9 @@ impl SystemRegistry {
     #[inline]
     pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> TypeId {
         let type_id = TypeId::of::<S>();
-        self.systems.entry(type_id).or_insert_with(|| {
-            (false, Box::new(IntoSystem::into_system(system)))
-        });
+        self.systems
+            .entry(type_id)
+            .or_insert_with(|| (false, Box::new(IntoSystem::into_system(system))));
         type_id
     }
 
@@ -118,11 +118,7 @@ impl SystemRegistry {
     ///
     /// Systems will be run sequentially in registration order if more than one registered system matches the provided label.
     #[inline]
-    pub fn run_by_id(
-        &mut self,
-        world: &mut World,
-        id: TypeId,
-    ) -> Result<(), SystemRegistryError> {
+    pub fn run_by_id(&mut self, world: &mut World, id: TypeId) -> Result<(), SystemRegistryError> {
         match self.systems.get_mut(&id) {
             Some((initialized, matching_system)) => {
                 if !*initialized {
@@ -140,10 +136,7 @@ impl SystemRegistry {
 
 impl World {
     #[inline]
-    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
-        &mut self,
-        system: S,
-    ) -> TypeId {
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> TypeId {
         self.resource_mut::<SystemRegistry>().register(system)
     }
 
@@ -152,6 +145,10 @@ impl World {
     /// Calls [`SystemRegistry::run_system`].
     #[inline]
     pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
+        let _ = self.get_resource::<SystemRegistry>().expect(
+            "SystemRegistry not found: Nested and recursive one-shot systems are not supported.",
+        );
+
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry.run(world, system);
         });
@@ -162,6 +159,10 @@ impl World {
     /// Calls [`SystemRegistry::run_callback`].
     #[inline]
     pub fn run_system_by_id(&mut self, id: TypeId) -> Result<(), SystemRegistryError> {
+        let _ = self.get_resource::<SystemRegistry>().expect(
+            "SystemRegistry not found: Nested and recursive one-shot systems are not supported.",
+        );
+
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry.run_by_id(world, id)
         })
@@ -211,6 +212,10 @@ impl RunSystemById {
 impl Command for RunSystemById {
     #[inline]
     fn apply(self, world: &mut World) {
+        let _ = world.get_resource::<SystemRegistry>().expect(
+            "SystemRegistry not found: Nested and recursive one-shot systems are not supported.",
+        );
+
         world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry
                 .run_by_id(world, self.system_id)
@@ -344,8 +349,8 @@ mod tests {
 
     #[test]
     fn run_system_through_command() {
-        use crate::system::RunSystem;
         use crate::system::commands::Command;
+        use crate::system::RunSystem;
 
         let mut world = World::new();
         let command = RunSystem::new(spawn_entity);

From 1098cd5d5ac361af8a222a6bc2a6f2afc2694d03 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Thu, 20 Jul 2023 00:41:33 +0200
Subject: [PATCH 075/113] Removed the option to call systems by Id

---
 crates/bevy_ecs/src/system/commands/mod.rs    | 10 +--
 crates/bevy_ecs/src/system/system_registry.rs | 79 +++----------------
 2 files changed, 12 insertions(+), 77 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index d6cc317521ad0..23dd7c298b95c 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,14 +5,13 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystem, RunSystemById},
+    system::{IntoSystem, RunSystem},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
 use bevy_utils::tracing::{error, info};
 pub use command_queue::CommandQueue;
 pub use parallel_scope::*;
-use std::any::TypeId;
 use std::marker::PhantomData;
 
 use super::{Deferred, Resource, SystemBuffer, SystemMeta};
@@ -534,13 +533,6 @@ impl<'w, 's> Commands<'w, 's> {
         self.queue.push(RunSystem::new(system));
     }
 
-    /// Run the systems corresponding to the label stored in the provided [`Callback`]
-    ///
-    /// Calls [`SystemRegistry::run_callback`](crate::SystemRegistry::run_callback).
-    pub fn run_system_by_id(&mut self, system_id: TypeId) {
-        self.queue.push(RunSystemById::new(system_id));
-    }
-
     /// Pushes a generic [`Command`] to the command queue.
     ///
     /// `command` can be a built-in command, custom struct that implements [`Command`] or a closure
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index cc2da9e9be871..a9a07e121679c 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -79,16 +79,11 @@ pub struct SystemRegistry {
 }
 
 impl SystemRegistry {
-    /// Registers a system in the [`SystemRegistry`], so then it can be later run.
+    /// Registers a system in the [`SystemRegistry`], so it can be run later.
     ///
     /// Repeatedly registering a system will have no effect.
-    ///
-    /// When [`run_systems_by_label`](SystemRegistry::run_systems_by_label) is called,
-    /// all registered systems that match that label will be evaluated (in insertion order).
-    ///
-    /// To provide explicit label(s), use [`register_system_with_labels`](SystemRegistry::register_system_with_labels).
     #[inline]
-    pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> TypeId {
+    fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> TypeId {
         let type_id = TypeId::of::<S>();
         self.systems
             .entry(type_id)
@@ -99,26 +94,20 @@ impl SystemRegistry {
     /// Runs the supplied system on the [`World`] a single time.
     ///
     /// You do not need to register systems before they are run in this way.
-    /// Instead, systems will be automatically registered according to their [`SystemTypeSet`] the first time this method is called on them.
+    /// Instead, systems will be automatically registered according to their [`TypeId`] the first time this method is called on them.
     ///
     /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
-    ///
-    /// If, via manual system registration, you have somehow managed to insert more than one system with the same [`SystemTypeSet`],
-    /// only the first will be run.
     pub fn run<M, S: IntoSystem<(), (), M> + 'static>(&mut self, world: &mut World, system: S) {
         let id = self.register(system);
         self.run_by_id(world, id)
             .expect("System was registered before running");
     }
 
-    /// Run the systems corresponding to the label stored in the provided [`Callback`]
-    ///
-    /// Systems must be registered before they can be run by their label,
-    /// including via this method.
+    /// Run the system by its [`TypeId`]
     ///
-    /// Systems will be run sequentially in registration order if more than one registered system matches the provided label.
+    /// Systems must be registered before they can be run.
     #[inline]
-    pub fn run_by_id(&mut self, world: &mut World, id: TypeId) -> Result<(), SystemRegistryError> {
+    fn run_by_id(&mut self, world: &mut World, id: TypeId) -> Result<(), SystemRegistryError> {
         match self.systems.get_mut(&id) {
             Some((initialized, matching_system)) => {
                 if !*initialized {
@@ -135,38 +124,21 @@ impl SystemRegistry {
 }
 
 impl World {
-    #[inline]
-    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> TypeId {
-        self.resource_mut::<SystemRegistry>().register(system)
-    }
-
     /// Runs the supplied system on the [`World`] a single time.
     ///
     /// Calls [`SystemRegistry::run_system`].
     #[inline]
     pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
-        let _ = self.get_resource::<SystemRegistry>().expect(
-            "SystemRegistry not found: Nested and recursive one-shot systems are not supported.",
-        );
+        if !self.contains_resource::<SystemRegistry>() {
+            panic!(
+                "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
+            );
+        }
 
         self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
             registry.run(world, system);
         });
     }
-
-    /// Run the systems corresponding to the set stored in the provided [`Callback`]
-    ///
-    /// Calls [`SystemRegistry::run_callback`].
-    #[inline]
-    pub fn run_system_by_id(&mut self, id: TypeId) -> Result<(), SystemRegistryError> {
-        let _ = self.get_resource::<SystemRegistry>().expect(
-            "SystemRegistry not found: Nested and recursive one-shot systems are not supported.",
-        );
-
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_by_id(world, id)
-        })
-    }
 }
 
 /// The [`Command`] type for [`SystemRegistry::run_system`]
@@ -197,35 +169,6 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
     }
 }
 
-/// The [`Command`] type for [`SystemRegistry::run_systems_by_label`]
-#[derive(Debug, Clone)]
-pub struct RunSystemById {
-    pub system_id: TypeId,
-}
-
-impl RunSystemById {
-    pub fn new(system_id: TypeId) -> Self {
-        Self { system_id }
-    }
-}
-
-impl Command for RunSystemById {
-    #[inline]
-    fn apply(self, world: &mut World) {
-        let _ = world.get_resource::<SystemRegistry>().expect(
-            "SystemRegistry not found: Nested and recursive one-shot systems are not supported.",
-        );
-
-        world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry
-                .run_by_id(world, self.system_id)
-                // Ideally this error should be handled more gracefully,
-                // but that's blocked on a full error handling solution for commands
-                .unwrap();
-        });
-    }
-}
-
 /// An operation on a [`SystemRegistry`] failed
 #[derive(Debug)]
 pub enum SystemRegistryError {

From d9c89d9319ebe0f5a223b9452e0945c6a1a9c8c3 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Thu, 20 Jul 2023 21:49:27 +0200
Subject: [PATCH 076/113] Fixed a CI error in bevy_app

---
 crates/bevy_app/src/system_registry.rs | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 67a91aaa7dd9c..ad518216d358f 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -1,21 +1,9 @@
 use crate::App;
 use bevy_ecs::{
     prelude::*,
-    system::{SystemId, SystemRegistryError},
 };
 
 impl App {
-    /// Register a system.
-    ///
-    /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register_system).
-    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
-        &mut self,
-        system: S,
-    ) -> &mut Self {
-        self.world.register_system(system);
-        self
-    }
-
     /// Runs the supplied system on the [`World`] a single time.
     ///
     /// Calls [`SystemRegistry::run_system`](bevy_ecs::system::SystemRegistry::run_system).
@@ -24,12 +12,4 @@ impl App {
         self.world.run_system(system);
         self
     }
-
-    /// Run the systems corresponding to the label stored in the provided [`Callback`]
-    ///
-    /// Calls [`SystemRegistry::run_callback`](bevy_ecs::system::SystemRegistry::run_callback).
-    #[inline]
-    pub fn run_system_by_id(&mut self, system_id: SystemId) -> Result<(), SystemRegistryError> {
-        self.world.run_system_by_id(system_id)
-    }
 }

From 5e50d0244a8d9e84027ba85cc028b34b7cf4662e Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Thu, 20 Jul 2023 22:13:52 +0200
Subject: [PATCH 077/113] Fixed a previous rebasing error

---
 crates/bevy_core/src/lib.rs | 34 +++++++---------------------------
 1 file changed, 7 insertions(+), 27 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index d12b2b0479059..977f01489f286 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -21,12 +21,12 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::{
-    entity::Entity,
-    schedule::ExclusiveSystemDescriptorCoercion,
-    system::IntoExclusiveSystem,
-};
-use bevy_utils::HashSet;
+use bevy_ecs::prelude::*;
+use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
+use bevy_utils::{Duration, HashSet, Instant};
+use std::borrow::Cow;
+use std::ffi::OsString;
+use std::marker::PhantomData;
 use std::ops::Range;
 use std::path::{Path, PathBuf};
 
@@ -40,27 +40,7 @@ pub struct TypeRegistrationPlugin;
 
 impl Plugin for TypeRegistrationPlugin {
     fn build(&self, app: &mut App) {
-        // Setup the default bevy task pools
-        app.world
-            .get_resource::<DefaultTaskPoolOptions>()
-            .cloned()
-            .unwrap_or_default()
-            .create_default_pools(&mut app.world);
-
-        app.init_resource::<Time>()
-            .init_resource::<FixedTimesteps>()
-            .register_type::<HashSet<String>>()
-            .register_type::<Option<String>>()
-            .register_type::<Entity>()
-            .register_type::<Name>()
-            .register_type::<Range<f32>>()
-            .register_type::<Timer>()
-            // time system is added as an "exclusive system" to ensure it runs before other systems
-            // in CoreStage::First
-            .add_system_to_stage(
-                CoreStage::First,
-                time_system.exclusive_system().label(CoreSystem::Time),
-            );
+        app.register_type::<Entity>().register_type::<Name>();
 
         register_rust_types(app);
         register_math_types(app);

From c954f0ddd846ed7b4cde635e5d7a92aa2d70a45b Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Sun, 23 Jul 2023 20:46:49 +0200
Subject: [PATCH 078/113] Added a wrapper type for TypeId: SystemId

---
 crates/bevy_ecs/src/system/system_registry.rs | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index a9a07e121679c..fc4c1fe9f23e4 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -78,17 +78,22 @@ pub struct SystemRegistry {
     systems: TypeIdMap<(bool, BoxedSystem)>,
 }
 
+/// A wrapper type for TypeId.
+/// It identifies a system that is registered in the [`SystemRegistry`].
+#[derive(Debug)]
+pub struct SystemId(TypeId);
+
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so it can be run later.
     ///
     /// Repeatedly registering a system will have no effect.
     #[inline]
-    fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> TypeId {
+    fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> SystemId {
         let type_id = TypeId::of::<S>();
         self.systems
             .entry(type_id)
             .or_insert_with(|| (false, Box::new(IntoSystem::into_system(system))));
-        type_id
+        SystemId(type_id)
     }
 
     /// Runs the supplied system on the [`World`] a single time.
@@ -103,12 +108,12 @@ impl SystemRegistry {
             .expect("System was registered before running");
     }
 
-    /// Run the system by its [`TypeId`]
+    /// Run the system by its [`SystemId`]
     ///
     /// Systems must be registered before they can be run.
     #[inline]
-    fn run_by_id(&mut self, world: &mut World, id: TypeId) -> Result<(), SystemRegistryError> {
-        match self.systems.get_mut(&id) {
+    fn run_by_id(&mut self, world: &mut World, id: SystemId) -> Result<(), SystemRegistryError> {
+        match self.systems.get_mut(&id.0) {
             Some((initialized, matching_system)) => {
                 if !*initialized {
                     matching_system.initialize(world);
@@ -175,7 +180,7 @@ pub enum SystemRegistryError {
     /// A system was run by label, but no system with that label was found.
     ///
     /// Did you forget to register it?
-    SystemIdNotRegistered(TypeId),
+    SystemIdNotRegistered(SystemId),
 }
 
 mod tests {

From aa153709e4717c751ec5437b552c7cd3834febf5 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Thu, 3 Aug 2023 01:27:07 +0200
Subject: [PATCH 079/113] Re-instated the possibillity to run a system by id

---
 crates/bevy_app/src/system_registry.rs        |   8 ++
 crates/bevy_ecs/src/system/system_registry.rs | 118 +++++++++++++++---
 2 files changed, 107 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index ad518216d358f..2396b3f3ad5ad 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -12,4 +12,12 @@ impl App {
         self.world.run_system(system);
         self
     }
+
+    /// Run the systems corresponding to the label stored in the provided [`Callback`]
+    ///
+    /// Calls [`SystemRegistry::run_callback`](bevy_ecs::system::SystemRegistry::run_callback).
+    #[inline]
+    pub fn run_system_by_id(&mut self, system_id: SystemId) -> Result<(), SystemRegistryError> {
+        self.world.run_system_by_id(system_id)
+    }
 }
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index fc4c1fe9f23e4..2d7c277dc13c3 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,10 +1,10 @@
-use std::any::TypeId;
+use bevy_utils::HashMap;
 use std::marker::PhantomData;
 
 use crate::system::{BoxedSystem, Command, IntoSystem};
 use crate::world::{Mut, World};
 // Needed for derive(Component) macro
-use crate::{self as bevy_ecs, TypeIdMap};
+use crate::{self as bevy_ecs};
 use bevy_ecs_macros::Resource;
 
 /// Stores initialized [`System`]s, so they can be reused and run in an ad-hoc fashion.
@@ -75,13 +75,14 @@ use bevy_ecs_macros::Resource;
 /// ```
 #[derive(Resource, Default)]
 pub struct SystemRegistry {
-    systems: TypeIdMap<(bool, BoxedSystem)>,
+    last_id: u32,
+    systems: HashMap<u32, (bool, BoxedSystem)>,
 }
 
 /// A wrapper type for TypeId.
 /// It identifies a system that is registered in the [`SystemRegistry`].
-#[derive(Debug)]
-pub struct SystemId(TypeId);
+#[derive(Debug, Clone, Copy)]
+pub struct SystemId(u32);
 
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so it can be run later.
@@ -89,30 +90,43 @@ impl SystemRegistry {
     /// Repeatedly registering a system will have no effect.
     #[inline]
     fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> SystemId {
-        let type_id = TypeId::of::<S>();
+        let id = self.last_id + 1;
+        self.last_id = id;
         self.systems
-            .entry(type_id)
-            .or_insert_with(|| (false, Box::new(IntoSystem::into_system(system))));
-        SystemId(type_id)
+            .insert(id, (false, Box::new(IntoSystem::into_system(system))));
+        SystemId(id)
+    }
+
+    /// Removes a registered system from the [`SystemRegistry`], if the [`SystemId`] is not
+    /// registered, this function does nothing.
+    #[inline]
+    pub fn remove(&mut self, id: SystemId) {
+        self.systems.remove(&id.0);
     }
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
     /// You do not need to register systems before they are run in this way.
-    /// Instead, systems will be automatically registered according to their [`TypeId`] the first time this method is called on them.
+    /// Instead, systems will be automatically registered and removed when using this function.
     ///
-    /// System state will be reused between runs, ensuring that [`Local`](crate::system::Local) variables and change detection works correctly.
+    /// System state will not be reused between runs, so [`Local`](crate::system::Local) variables are not preserved between runs.
+    /// To preserve [`Local`](crate::system::Local) variables between runs, it's possible to register and run the system by id manually.
     pub fn run<M, S: IntoSystem<(), (), M> + 'static>(&mut self, world: &mut World, system: S) {
         let id = self.register(system);
         self.run_by_id(world, id)
             .expect("System was registered before running");
+        self.remove(id);
     }
 
     /// Run the system by its [`SystemId`]
     ///
     /// Systems must be registered before they can be run.
     #[inline]
-    fn run_by_id(&mut self, world: &mut World, id: SystemId) -> Result<(), SystemRegistryError> {
+    pub fn run_by_id(
+        &mut self,
+        world: &mut World,
+        id: SystemId,
+    ) -> Result<(), SystemRegistryError> {
         match self.systems.get_mut(&id.0) {
             Some((initialized, matching_system)) => {
                 if !*initialized {
@@ -129,6 +143,23 @@ impl SystemRegistry {
 }
 
 impl World {
+    /// Registers a system in the [`SystemRegistry`]/
+    ///
+    /// Calls [`SystemRegistry::register`].
+    #[inline]
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
+        &mut self,
+        system: S,
+    ) -> SystemId {
+        if !self.contains_resource::<SystemRegistry>() {
+            panic!(
+                "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
+            );
+        }
+
+        self.resource_mut::<SystemRegistry>().register(system)
+    }
+
     /// Runs the supplied system on the [`World`] a single time.
     ///
     /// Calls [`SystemRegistry::run_system`].
@@ -144,6 +175,22 @@ impl World {
             registry.run(world, system);
         });
     }
+
+    /// Run the systems with the provided [`SystemId`].
+    ///
+    /// Calls [`SystemRegistry::run_by_id`].
+    #[inline]
+    pub fn run_system_by_id(&mut self, id: SystemId) -> Result<(), SystemRegistryError> {
+        if !self.contains_resource::<SystemRegistry>() {
+            panic!(
+                "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
+            );
+        }
+
+        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry.run_by_id(world, id)
+        })
+    }
 }
 
 /// The [`Command`] type for [`SystemRegistry::run_system`]
@@ -174,6 +221,37 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
     }
 }
 
+/// The [`Command`] type for [`SystemRegistry::run_by_id`].
+#[derive(Debug, Clone)]
+pub struct RunSystemById {
+    pub system_id: SystemId,
+}
+
+impl RunSystemById {
+    pub fn new(system_id: SystemId) -> Self {
+        Self { system_id }
+    }
+}
+
+impl Command for RunSystemById {
+    #[inline]
+    fn apply(self, world: &mut World) {
+        if !world.contains_resource::<SystemRegistry>() {
+            panic!(
+                "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
+            );
+        }
+
+        world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
+            registry
+                .run_by_id(world, self.system_id)
+                // Ideally this error should be handled more gracefully,
+                // but that's blocked on a full error handling solution for commands
+                .unwrap();
+        });
+    }
+}
+
 /// An operation on a [`SystemRegistry`] failed
 #[derive(Debug)]
 pub enum SystemRegistryError {
@@ -263,14 +341,15 @@ mod tests {
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
         // Resources are changed when they are first added.
-        world.run_system(count_up_iff_changed);
+        let id = world.register_system(count_up_iff_changed);
+        let _ = world.run_system_by_id(id);
         assert_eq!(*world.resource::<Counter>(), Counter(1));
         // Nothing changed
-        world.run_system(count_up_iff_changed);
+        let _ = world.run_system_by_id(id);
         assert_eq!(*world.resource::<Counter>(), Counter(1));
         // Making a change
         world.resource_mut::<ChangeDetector>().set_changed();
-        world.run_system(count_up_iff_changed);
+        let _ = world.run_system_by_id(id);
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
@@ -285,13 +364,14 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Counter(1));
         assert_eq!(*world.resource::<Counter>(), Counter(1));
-        world.run_system(doubling);
+        let id = world.register_system(doubling);
+        let _ = world.run_system_by_id(id);
         assert_eq!(*world.resource::<Counter>(), Counter(1));
-        world.run_system(doubling);
+        let _ = world.run_system_by_id(id);
         assert_eq!(*world.resource::<Counter>(), Counter(2));
-        world.run_system(doubling);
+        let _ = world.run_system_by_id(id);
         assert_eq!(*world.resource::<Counter>(), Counter(4));
-        world.run_system(doubling);
+        let _ = world.run_system_by_id(id);
         assert_eq!(*world.resource::<Counter>(), Counter(8));
     }
 

From 47c75fc880c82a3b2802b5c25b3f4454f2effc17 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Wed, 23 Aug 2023 22:09:26 +0200
Subject: [PATCH 080/113] Fixed some build errors, fixed example

---
 crates/bevy_app/src/system_registry.rs        |  5 ++---
 crates/bevy_ecs/src/system/commands/mod.rs    |  9 ++++++++-
 crates/bevy_ecs/src/system/system_registry.rs | 13 +++++++------
 examples/ecs/one_shot_systems.rs              |  8 +++-----
 4 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 2396b3f3ad5ad..1dbe93f6c41d1 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -1,7 +1,6 @@
 use crate::App;
-use bevy_ecs::{
-    prelude::*,
-};
+use bevy_ecs::prelude::*;
+use bevy_ecs::system::{SystemId, SystemRegistryError};
 
 impl App {
     /// Runs the supplied system on the [`World`] a single time.
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 23dd7c298b95c..6ba9887777dd6 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,7 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystem},
+    system::{IntoSystem, RunSystem, RunSystemById, SystemId},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -533,6 +533,13 @@ impl<'w, 's> Commands<'w, 's> {
         self.queue.push(RunSystem::new(system));
     }
 
+    /// Runs the system corresponding to the given [`SystemId`].
+    ///
+    /// Calls [`SystemRegistry::run_system_by_id`](crate::SystemRegistry::run_system_by_id).
+    pub fn run_system_by_id(&mut self, id: SystemId) {
+        self.queue.push(RunSystemById::new(id));
+    }
+
     /// Pushes a generic [`Command`] to the command queue.
     ///
     /// `command` can be a built-in command, custom struct that implements [`Command`] or a closure
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 2d7c277dc13c3..e04244d9ac961 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -89,7 +89,7 @@ impl SystemRegistry {
     ///
     /// Repeatedly registering a system will have no effect.
     #[inline]
-    fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> SystemId {
+    pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> SystemId {
         let id = self.last_id + 1;
         self.last_id = id;
         self.systems
@@ -112,10 +112,10 @@ impl SystemRegistry {
     /// System state will not be reused between runs, so [`Local`](crate::system::Local) variables are not preserved between runs.
     /// To preserve [`Local`](crate::system::Local) variables between runs, it's possible to register and run the system by id manually.
     pub fn run<M, S: IntoSystem<(), (), M> + 'static>(&mut self, world: &mut World, system: S) {
-        let id = self.register(system);
-        self.run_by_id(world, id)
-            .expect("System was registered before running");
-        self.remove(id);
+        let mut boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
+        boxed_system.initialize(world);
+        boxed_system.run((), world);
+        boxed_system.apply_deferred(world);
     }
 
     /// Run the system by its [`SystemId`]
@@ -224,10 +224,11 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 /// The [`Command`] type for [`SystemRegistry::run_by_id`].
 #[derive(Debug, Clone)]
 pub struct RunSystemById {
-    pub system_id: SystemId,
+    system_id: SystemId,
 }
 
 impl RunSystemById {
+    /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
     pub fn new(system_id: SystemId) -> Self {
         Self { system_id }
     }
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 65297617559a4..13f0f48363ca1 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -13,15 +13,13 @@ use bevy::{
 
 fn main() {
     App::new()
-        .add_startup_system(count_entities)
-        .add_startup_system(setup)
+        .add_systems(Startup, (count_entities, setup))
         // One shot systems are interchangeable with ordinarily scheduled systems.
-        // Change detection, Local and NonSend all work as expected.
-        .add_system(count_entities.in_base_set(CoreSet::PostUpdate))
+        .add_systems(PostUpdate, count_entities)
         // One-shot systems can be used to build complex abstractions
         // to match the needs of your design.
         // Here, we model a very simple component-linked callback architecture.
-        .add_system(evaluate_callbacks)
+        .add_systems(Update, evaluate_callbacks)
         .run();
 }
 

From 1963e6399e0111956d3dbdf29b73dab536d6d76a Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Wed, 23 Aug 2023 22:25:43 +0200
Subject: [PATCH 081/113] Remove outdated comments

---
 examples/ecs/one_shot_systems.rs | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 13f0f48363ca1..67781a0d40a38 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -14,11 +14,7 @@ use bevy::{
 fn main() {
     App::new()
         .add_systems(Startup, (count_entities, setup))
-        // One shot systems are interchangeable with ordinarily scheduled systems.
         .add_systems(PostUpdate, count_entities)
-        // One-shot systems can be used to build complex abstractions
-        // to match the needs of your design.
-        // Here, we model a very simple component-linked callback architecture.
         .add_systems(Update, evaluate_callbacks)
         .run();
 }
@@ -38,9 +34,6 @@ struct Triggered;
 
 fn setup(mut system_registry: ResMut<SystemRegistry>, mut commands: Commands) {
     commands.spawn((
-        // The Callback component is defined in bevy_ecs,
-        // but wrapping this (or making your own customized variant) is easy.
-        // Just stored a boxed SystemLabel!
         Callback(system_registry.register(button_pressed)),
         Triggered,
     ));
@@ -62,10 +55,6 @@ fn slider_toggled() {
 /// This could be done in an exclusive system rather than using `Commands` if preferred.
 fn evaluate_callbacks(query: Query<&Callback, With<Triggered>>, mut commands: Commands) {
     for callback in query.iter() {
-        // Because we don't have access to the type information of the callbacks
-        // we have to use the layer of indirection provided by system labels.
-        // Note that if we had registered multiple systems with the same label,
-        // they would all be evaluated here.
         commands.run_system_by_id(callback.0);
     }
 }

From 069db4b50519f353fbda3b7dabe5bd689ddc019e Mon Sep 17 00:00:00 2001
From: Rob Parrett <robparrett@gmail.com>
Date: Fri, 25 Aug 2023 05:34:24 -0700
Subject: [PATCH 082/113] Fix CI for Rust 1.72 (#9562)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

[Rust 1.72.0](https://blog.rust-lang.org/2023/08/24/Rust-1.72.0.html) is
now stable.

- `let-else` formatting has arrived!
- I chose to allow `explicit_iter_loop` due to
https://github.com/rust-lang/rust-clippy/issues/11074.

We didn't hit any of the false positives that prevent compilation, but
fixing this did produce a lot of the "symbol soup" mentioned, e.g. `for
image in &mut *image_events {`.

  Happy to undo this if there's consensus the other way.

---------

Co-authored-by: François <mockersf@gmail.com>
---
 crates/bevy_animation/src/lib.rs   | 3 +++
 crates/bevy_pbr/src/prepass/mod.rs | 4 ++++
 2 files changed, 7 insertions(+)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index b39bfa42b7f22..991f97194f4e2 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -625,7 +625,10 @@ fn apply_animation(
             let Some(target) = entity_from_path(root, path, children, names, cached_path) else {
                 continue;
             };
+<<<<<<< HEAD
             any_path_found = true;
+=======
+>>>>>>> 165c47071 (Fix CI for Rust 1.72 (#9562))
             // SAFETY: The verify_no_ancestor_player check above ensures that two animation players cannot alias
             // any of their descendant Transforms.
             //
diff --git a/crates/bevy_pbr/src/prepass/mod.rs b/crates/bevy_pbr/src/prepass/mod.rs
index 21ea58e57f8f6..bf01cd5f345c9 100644
--- a/crates/bevy_pbr/src/prepass/mod.rs
+++ b/crates/bevy_pbr/src/prepass/mod.rs
@@ -798,7 +798,11 @@ pub fn queue_prepass_material_meshes<M: Material>(
         let rangefinder = view.rangefinder3d();
 
         for visible_entity in &visible_entities.entities {
+<<<<<<< HEAD
             let Ok((material_handle, mesh_handle, mesh_transforms)) =
+=======
+            let Ok((material_handle, mesh_handle, mesh_transforms, batch_indices)) =
+>>>>>>> 165c47071 (Fix CI for Rust 1.72 (#9562))
                 material_meshes.get(*visible_entity)
             else {
                 continue;

From afe255ea3014951427b0dfeec11276e1a97c98c9 Mon Sep 17 00:00:00 2001
From: Alice Cecile <alice.i.cecile@gmail.com>
Date: Wed, 29 Jun 2022 23:55:48 -0400
Subject: [PATCH 083/113] Add example

---
 examples/README.md               | 13 +++++++++++++
 examples/ecs/one_shot_systems.rs |  2 +-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/examples/README.md b/examples/README.md
index 9f3626935291e..05a0969f38faa 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -57,6 +57,19 @@ git checkout v0.4.0
   - [Transforms](#transforms)
   - [UI (User Interface)](#ui-user-interface)
   - [Window](#window)
+- [Tests](#tests)
+- [Platform-Specific Examples](#platform-specific-examples)
+  - [Android](#android)
+    - [Setup](#setup)
+    - [Build & Run](#build--run)
+    - [Old phones](#old-phones)
+  - [iOS](#ios)
+    - [Setup](#setup-1)
+    - [Build & Run](#build--run-1)
+  - [WASM](#wasm)
+    - [Setup](#setup-2)
+    - [Build & Run](#build--run-2)
+    - [Loading Assets](#loading-assets)
 
 - [Tests](#tests)
 - [Platform-Specific Examples](#platform-specific-examples)
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 67781a0d40a38..545078dac9de2 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -1,4 +1,4 @@
-//! Demonstrates the use of "one-shot systems", which run once when triggered.
+//! Demonstrates the use of "one-shot systems", which run once when triggered
 //!
 //! These can be useful to help structure your logic in a push-based fashion,
 //! reducing the overhead of running extremely rarely run systems

From f565203961d772544c3b2a58be83217f1acbefd6 Mon Sep 17 00:00:00 2001
From: Alejandro Pascual Pozo <alejandro.pascual.pozo@gmail.com>
Date: Fri, 10 Mar 2023 12:37:47 +0100
Subject: [PATCH 084/113] remove run_systems_by_set

---
 crates/bevy_app/src/system_registry.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 1dbe93f6c41d1..170f91416bace 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -3,6 +3,17 @@ use bevy_ecs::prelude::*;
 use bevy_ecs::system::{SystemId, SystemRegistryError};
 
 impl App {
+    /// Register a system with any number of [`SystemLabel`]s.
+    ///
+    /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register_system).
+    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
+        &mut self,
+        system: S,
+    ) -> &mut Self {
+        self.world.register_system(system);
+        self
+    }
+
     /// Runs the supplied system on the [`World`] a single time.
     ///
     /// Calls [`SystemRegistry::run_system`](bevy_ecs::system::SystemRegistry::run_system).

From 948147f84414fedf8716d8264d330a0c5ba71dbc Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Mon, 28 Aug 2023 21:00:39 +0200
Subject: [PATCH 085/113] Renamed RunSystem to RunSystemCommand to avoid name
 collision

---
 crates/bevy_ecs/src/system/commands/mod.rs    |  4 ++--
 crates/bevy_ecs/src/system/system_registry.rs | 10 +++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 6ba9887777dd6..5735138718e2e 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,7 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystem, RunSystemById, SystemId},
+    system::{IntoSystem, RunSystemCommand, RunSystemById, SystemId},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -530,7 +530,7 @@ impl<'w, 's> Commands<'w, 's> {
         &mut self,
         system: S,
     ) {
-        self.queue.push(RunSystem::new(system));
+        self.queue.push(RunSystemCommand::new(system));
     }
 
     /// Runs the system corresponding to the given [`SystemId`].
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index e04244d9ac961..2758c0f4f6d8a 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -195,12 +195,12 @@ impl World {
 
 /// The [`Command`] type for [`SystemRegistry::run_system`]
 #[derive(Debug, Clone)]
-pub struct RunSystem<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> {
+pub struct RunSystemCommand<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> {
     _phantom_marker: PhantomData<M>,
     system: S,
 }
 
-impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> RunSystem<M, S> {
+impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> RunSystemCommand<M, S> {
     /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
     #[inline]
     #[must_use]
@@ -213,7 +213,7 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 }
 
 impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> Command
-    for RunSystem<M, S>
+    for RunSystemCommand<M, S>
 {
     #[inline]
     fn apply(self, world: &mut World) {
@@ -379,10 +379,10 @@ mod tests {
     #[test]
     fn run_system_through_command() {
         use crate::system::commands::Command;
-        use crate::system::RunSystem;
+        use crate::system::RunSystemCommand;
 
         let mut world = World::new();
-        let command = RunSystem::new(spawn_entity);
+        let command = RunSystemCommand::new(spawn_entity);
         assert_eq!(world.entities.len(), 0);
         command.apply(&mut world);
         assert_eq!(world.entities.len(), 1);

From 91958492e3bbb1c7ea40fc5874bd82764cace83f Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Mon, 28 Aug 2023 21:12:58 +0200
Subject: [PATCH 086/113] Fixed a mistake from rebasing

---
 crates/bevy_ecs/src/system/commands/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 5735138718e2e..78449f09ce4c8 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -6,7 +6,7 @@ use crate::{
     bundle::Bundle,
     entity::{Entities, Entity},
     system::{IntoSystem, RunSystemCommand, RunSystemById, SystemId},
-    world::{FromWorld, World},
+    world::{EntityMut, FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
 use bevy_utils::tracing::{error, info};

From 29837c652330eb69526ec63c3cc8d4c09de7baae Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Mon, 28 Aug 2023 22:31:32 +0200
Subject: [PATCH 087/113] Revert "Add example"

This reverts commit afe255ea3014951427b0dfeec11276e1a97c98c9.
---
 examples/README.md               | 13 -------------
 examples/ecs/one_shot_systems.rs |  2 +-
 2 files changed, 1 insertion(+), 14 deletions(-)

diff --git a/examples/README.md b/examples/README.md
index 05a0969f38faa..9f3626935291e 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -57,19 +57,6 @@ git checkout v0.4.0
   - [Transforms](#transforms)
   - [UI (User Interface)](#ui-user-interface)
   - [Window](#window)
-- [Tests](#tests)
-- [Platform-Specific Examples](#platform-specific-examples)
-  - [Android](#android)
-    - [Setup](#setup)
-    - [Build & Run](#build--run)
-    - [Old phones](#old-phones)
-  - [iOS](#ios)
-    - [Setup](#setup-1)
-    - [Build & Run](#build--run-1)
-  - [WASM](#wasm)
-    - [Setup](#setup-2)
-    - [Build & Run](#build--run-2)
-    - [Loading Assets](#loading-assets)
 
 - [Tests](#tests)
 - [Platform-Specific Examples](#platform-specific-examples)
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 545078dac9de2..67781a0d40a38 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -1,4 +1,4 @@
-//! Demonstrates the use of "one-shot systems", which run once when triggered
+//! Demonstrates the use of "one-shot systems", which run once when triggered.
 //!
 //! These can be useful to help structure your logic in a push-based fashion,
 //! reducing the overhead of running extremely rarely run systems

From ebf4b99056d19c1ba2ed0ce015b688277197b832 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Mon, 28 Aug 2023 22:32:07 +0200
Subject: [PATCH 088/113] Revert "Fix CI for Rust 1.72 (#9562)"

This reverts commit 069db4b50519f353fbda3b7dabe5bd689ddc019e.
---
 crates/bevy_animation/src/lib.rs   | 3 ---
 crates/bevy_pbr/src/prepass/mod.rs | 4 ----
 2 files changed, 7 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 991f97194f4e2..b39bfa42b7f22 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -625,10 +625,7 @@ fn apply_animation(
             let Some(target) = entity_from_path(root, path, children, names, cached_path) else {
                 continue;
             };
-<<<<<<< HEAD
             any_path_found = true;
-=======
->>>>>>> 165c47071 (Fix CI for Rust 1.72 (#9562))
             // SAFETY: The verify_no_ancestor_player check above ensures that two animation players cannot alias
             // any of their descendant Transforms.
             //
diff --git a/crates/bevy_pbr/src/prepass/mod.rs b/crates/bevy_pbr/src/prepass/mod.rs
index bf01cd5f345c9..21ea58e57f8f6 100644
--- a/crates/bevy_pbr/src/prepass/mod.rs
+++ b/crates/bevy_pbr/src/prepass/mod.rs
@@ -798,11 +798,7 @@ pub fn queue_prepass_material_meshes<M: Material>(
         let rangefinder = view.rangefinder3d();
 
         for visible_entity in &visible_entities.entities {
-<<<<<<< HEAD
             let Ok((material_handle, mesh_handle, mesh_transforms)) =
-=======
-            let Ok((material_handle, mesh_handle, mesh_transforms, batch_indices)) =
->>>>>>> 165c47071 (Fix CI for Rust 1.72 (#9562))
                 material_meshes.get(*visible_entity)
             else {
                 continue;

From 9d15661b617b57b8b68582b93255b7d7c566622f Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Mon, 28 Aug 2023 23:07:30 +0200
Subject: [PATCH 089/113] Fixed tests

---
 crates/bevy_ecs/src/system/system_registry.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 2758c0f4f6d8a..6d5367033346b 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -327,7 +327,6 @@ mod tests {
         #[derive(Resource, Default)]
         struct ChangeDetector;
 
-        #[allow(dead_code)]
         fn count_up_iff_changed(
             mut counter: ResMut<Counter>,
             change_detector: ResMut<ChangeDetector>,
@@ -357,7 +356,7 @@ mod tests {
     #[test]
     fn local_variables() {
         // The `Local` begins at the default value of 0
-        fn doubling(mut last_counter: Local<Counter>, mut counter: ResMut<Counter>) {
+        fn doubling(last_counter: Local<Counter>, mut counter: ResMut<Counter>) {
             counter.0 += last_counter.0 .0;
             last_counter.0 .0 = counter.0;
         }

From 47c67b3fa37724f6f82bb1195a33c1b81e36702e Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 29 Aug 2023 00:29:29 +0200
Subject: [PATCH 090/113] Moved run_system command / test over to system

---
 crates/bevy_app/src/system_registry.rs        |   4 +-
 crates/bevy_ecs/src/system/system.rs          | 106 +++++++++++++
 crates/bevy_ecs/src/system/system_registry.rs | 144 ------------------
 3 files changed, 108 insertions(+), 146 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 170f91416bace..0b159c07372a1 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -1,6 +1,6 @@
 use crate::App;
 use bevy_ecs::prelude::*;
-use bevy_ecs::system::{SystemId, SystemRegistryError};
+use bevy_ecs::system::{RunSystem, SystemId, SystemRegistryError};
 
 impl App {
     /// Register a system with any number of [`SystemLabel`]s.
@@ -16,7 +16,7 @@ impl App {
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
-    /// Calls [`SystemRegistry::run_system`](bevy_ecs::system::SystemRegistry::run_system).
+    /// Calls [`RunSystem::run_system`](bevy_ecs::system::RunSystem::run_system).
     #[inline]
     pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> &mut Self {
         self.world.run_system(system);
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index a4e1b0625efa1..212e06e540228 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -1,7 +1,9 @@
 use bevy_utils::tracing::warn;
 use core::fmt::Debug;
+use std::marker::PhantomData;
 
 use crate::component::Tick;
+use crate::system::Command;
 use crate::world::unsafe_world_cell::UnsafeWorldCell;
 use crate::{archetype::ArchetypeComponentId, component::ComponentId, query::Access, world::World};
 
@@ -258,10 +260,39 @@ impl RunSystem for &mut World {
     }
 }
 
+/// The [`Command`] type for [`RunSystem`]
+#[derive(Debug, Clone)]
+pub struct RunSystemCommand<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> {
+    _phantom_marker: PhantomData<M>,
+    system: S,
+}
+
+impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> RunSystemCommand<M, S> {
+    /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
+    #[inline]
+    #[must_use]
+    pub fn new(system: S) -> Self {
+        Self {
+            _phantom_marker: PhantomData::default(),
+            system,
+        }
+    }
+}
+
+impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> Command
+    for RunSystemCommand<M, S>
+{
+    #[inline]
+    fn apply(self, world: &mut World) {
+        world.run_system(self.system);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::prelude::*;
+    use crate as bevy_ecs;
 
     #[test]
     fn run_system() {
@@ -279,4 +310,79 @@ mod tests {
         assert_eq!(n, 2);
         assert_eq!(world.resource::<T>().0, 1);
     }
+
+    #[derive(Resource, Default, PartialEq, Debug)]
+    struct Counter(u8);
+
+    #[allow(dead_code)]
+    fn count_up(mut counter: ResMut<Counter>) {
+        counter.0 += 1;
+    }
+
+    #[test]
+    /// We need to ensure that the system registry is accessible
+    /// even after being used once.
+    fn run_two_systems() {
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        world.run_system(count_up);
+        assert_eq!(*world.resource::<Counter>(), Counter(1));
+        world.run_system(count_up);
+        assert_eq!(*world.resource::<Counter>(), Counter(2));
+    }
+
+   #[allow(dead_code)]
+    fn spawn_entity(mut commands: Commands) {
+        commands.spawn_empty();
+    }
+
+    #[test]
+    fn command_processing() {
+        let mut world = World::new();
+        assert_eq!(world.entities.len(), 0);
+        world.run_system(spawn_entity);
+        assert_eq!(world.entities.len(), 1);
+    }
+
+    #[test]
+    fn non_send_resources() {
+        fn non_send_count_down(mut ns: NonSendMut<Counter>) {
+            ns.0 -= 1;
+        }
+
+        let mut world = World::new();
+        world.insert_non_send_resource(Counter(10));
+        assert_eq!(*world.non_send_resource::<Counter>(), Counter(10));
+        world.run_system(non_send_count_down);
+        assert_eq!(*world.non_send_resource::<Counter>(), Counter(9));
+    }
+
+    #[test]
+    fn run_system_through_command() {
+        use crate::system::commands::Command;
+        use crate::system::RunSystemCommand;
+
+        let mut world = World::new();
+        let command = RunSystemCommand::new(spawn_entity);
+        assert_eq!(world.entities.len(), 0);
+        command.apply(&mut world);
+        assert_eq!(world.entities.len(), 1);
+    }
+
+    #[test]
+    fn system_recursion() {
+        fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
+            counter.0 += 1;
+            if counter.0 < 10 {
+                commands.run_system(count_to_ten);
+            }
+        }
+
+        let mut world = World::new();
+        world.init_resource::<Counter>();
+        assert_eq!(*world.resource::<Counter>(), Counter(0));
+        world.run_system(count_to_ten);
+        assert_eq!(*world.resource::<Counter>(), Counter(10));
+    }
 }
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 6d5367033346b..89275b9d5d824 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,5 +1,4 @@
 use bevy_utils::HashMap;
-use std::marker::PhantomData;
 
 use crate::system::{BoxedSystem, Command, IntoSystem};
 use crate::world::{Mut, World};
@@ -104,20 +103,6 @@ impl SystemRegistry {
         self.systems.remove(&id.0);
     }
 
-    /// Runs the supplied system on the [`World`] a single time.
-    ///
-    /// You do not need to register systems before they are run in this way.
-    /// Instead, systems will be automatically registered and removed when using this function.
-    ///
-    /// System state will not be reused between runs, so [`Local`](crate::system::Local) variables are not preserved between runs.
-    /// To preserve [`Local`](crate::system::Local) variables between runs, it's possible to register and run the system by id manually.
-    pub fn run<M, S: IntoSystem<(), (), M> + 'static>(&mut self, world: &mut World, system: S) {
-        let mut boxed_system: BoxedSystem = Box::new(IntoSystem::into_system(system));
-        boxed_system.initialize(world);
-        boxed_system.run((), world);
-        boxed_system.apply_deferred(world);
-    }
-
     /// Run the system by its [`SystemId`]
     ///
     /// Systems must be registered before they can be run.
@@ -160,22 +145,6 @@ impl World {
         self.resource_mut::<SystemRegistry>().register(system)
     }
 
-    /// Runs the supplied system on the [`World`] a single time.
-    ///
-    /// Calls [`SystemRegistry::run_system`].
-    #[inline]
-    pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) {
-        if !self.contains_resource::<SystemRegistry>() {
-            panic!(
-                "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
-            );
-        }
-
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run(world, system);
-        });
-    }
-
     /// Run the systems with the provided [`SystemId`].
     ///
     /// Calls [`SystemRegistry::run_by_id`].
@@ -193,34 +162,6 @@ impl World {
     }
 }
 
-/// The [`Command`] type for [`SystemRegistry::run_system`]
-#[derive(Debug, Clone)]
-pub struct RunSystemCommand<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> {
-    _phantom_marker: PhantomData<M>,
-    system: S,
-}
-
-impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> RunSystemCommand<M, S> {
-    /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
-    #[inline]
-    #[must_use]
-    pub fn new(system: S) -> Self {
-        Self {
-            _phantom_marker: PhantomData::default(),
-            system,
-        }
-    }
-}
-
-impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> Command
-    for RunSystemCommand<M, S>
-{
-    #[inline]
-    fn apply(self, world: &mut World) {
-        world.run_system(self.system);
-    }
-}
-
 /// The [`Command`] type for [`SystemRegistry::run_by_id`].
 #[derive(Debug, Clone)]
 pub struct RunSystemById {
@@ -269,59 +210,6 @@ mod tests {
     #[derive(Resource, Default, PartialEq, Debug)]
     struct Counter(u8);
 
-    #[allow(dead_code)]
-    fn count_up(mut counter: ResMut<Counter>) {
-        counter.0 += 1;
-    }
-
-    #[test]
-    fn run_system() {
-        let mut world = World::new();
-        world.init_resource::<Counter>();
-        assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.run_system(count_up);
-        assert_eq!(*world.resource::<Counter>(), Counter(1));
-    }
-
-    #[test]
-    /// We need to ensure that the system registry is accessible
-    /// even after being used once.
-    fn run_two_systems() {
-        let mut world = World::new();
-        world.init_resource::<Counter>();
-        assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.run_system(count_up);
-        assert_eq!(*world.resource::<Counter>(), Counter(1));
-        world.run_system(count_up);
-        assert_eq!(*world.resource::<Counter>(), Counter(2));
-    }
-
-    #[allow(dead_code)]
-    fn spawn_entity(mut commands: Commands) {
-        commands.spawn_empty();
-    }
-
-    #[test]
-    fn command_processing() {
-        let mut world = World::new();
-        assert_eq!(world.entities.len(), 0);
-        world.run_system(spawn_entity);
-        assert_eq!(world.entities.len(), 1);
-    }
-
-    #[test]
-    fn non_send_resources() {
-        fn non_send_count_down(mut ns: NonSendMut<Counter>) {
-            ns.0 -= 1;
-        }
-
-        let mut world = World::new();
-        world.insert_non_send_resource(Counter(10));
-        assert_eq!(*world.non_send_resource::<Counter>(), Counter(10));
-        world.run_system(non_send_count_down);
-        assert_eq!(*world.non_send_resource::<Counter>(), Counter(9));
-    }
-
     #[test]
     fn change_detection() {
         #[derive(Resource, Default)]
@@ -374,36 +262,4 @@ mod tests {
         let _ = world.run_system_by_id(id);
         assert_eq!(*world.resource::<Counter>(), Counter(8));
     }
-
-    #[test]
-    fn run_system_through_command() {
-        use crate::system::commands::Command;
-        use crate::system::RunSystemCommand;
-
-        let mut world = World::new();
-        let command = RunSystemCommand::new(spawn_entity);
-        assert_eq!(world.entities.len(), 0);
-        command.apply(&mut world);
-        assert_eq!(world.entities.len(), 1);
-    }
-
-    #[test]
-    // This is a known limitation;
-    // if this test passes the docs must be updated
-    // to reflect the ability to chain run_system commands
-    #[should_panic]
-    fn system_recursion() {
-        fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
-            counter.0 += 1;
-            if counter.0 < 10 {
-                commands.run_system(count_to_ten);
-            }
-        }
-
-        let mut world = World::new();
-        world.init_resource::<Counter>();
-        assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.run_system(count_to_ten);
-        assert_eq!(*world.resource::<Counter>(), Counter(10));
-    }
 }

From 478e5fdaad1b131e11b729addb0f9c046f0bcac6 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 29 Aug 2023 00:39:04 +0200
Subject: [PATCH 091/113] cargo fmt

---
 crates/bevy_ecs/src/system/commands/mod.rs |  2 +-
 crates/bevy_ecs/src/system/system.rs       | 13 +++++++++----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 78449f09ce4c8..9dbe1b44c1c02 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,7 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystemCommand, RunSystemById, SystemId},
+    system::{IntoSystem, RunSystemById, RunSystemCommand, SystemId},
     world::{EntityMut, FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 212e06e540228..6f940e76ef5d5 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -262,12 +262,17 @@ impl RunSystem for &mut World {
 
 /// The [`Command`] type for [`RunSystem`]
 #[derive(Debug, Clone)]
-pub struct RunSystemCommand<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> {
+pub struct RunSystemCommand<
+    M: Send + Sync + 'static,
+    S: IntoSystem<(), (), M> + Send + Sync + 'static,
+> {
     _phantom_marker: PhantomData<M>,
     system: S,
 }
 
-impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> RunSystemCommand<M, S> {
+impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
+    RunSystemCommand<M, S>
+{
     /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
     #[inline]
     #[must_use]
@@ -291,8 +296,8 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::prelude::*;
     use crate as bevy_ecs;
+    use crate::prelude::*;
 
     #[test]
     fn run_system() {
@@ -332,7 +337,7 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
-   #[allow(dead_code)]
+    #[allow(dead_code)]
     fn spawn_entity(mut commands: Commands) {
         commands.spawn_empty();
     }

From 9f6a4267922cd05d0d40e8bf3650143aaa89dc42 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 29 Aug 2023 21:54:05 +0200
Subject: [PATCH 092/113] Rounded out remove systems from SystemRegistry

---
 crates/bevy_app/src/system_registry.rs        | 14 +++++++++++---
 crates/bevy_ecs/src/system/commands/mod.rs    |  2 +-
 crates/bevy_ecs/src/system/system_registry.rs | 16 +++++++++++++++-
 3 files changed, 27 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 0b159c07372a1..6168a01cc668e 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -3,7 +3,7 @@ use bevy_ecs::prelude::*;
 use bevy_ecs::system::{RunSystem, SystemId, SystemRegistryError};
 
 impl App {
-    /// Register a system with any number of [`SystemLabel`]s.
+    /// Register a system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry)
     ///
     /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register_system).
     pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
@@ -14,6 +14,14 @@ impl App {
         self
     }
 
+    /// Removes a registered system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    ///
+    /// Calls [`SystemRegistry::remove_system`](bevy_ecs::system::SystemRegistry::remove).
+    #[inline]
+    pub fn remove_system(&mut self, id: SystemId) {
+        self.world.remove_system(id);
+    }
+
     /// Runs the supplied system on the [`World`] a single time.
     ///
     /// Calls [`RunSystem::run_system`](bevy_ecs::system::RunSystem::run_system).
@@ -23,9 +31,9 @@ impl App {
         self
     }
 
-    /// Run the systems corresponding to the label stored in the provided [`Callback`]
+    /// Run the systems corresponding to the id.
     ///
-    /// Calls [`SystemRegistry::run_callback`](bevy_ecs::system::SystemRegistry::run_callback).
+    /// Calls [`SystemRegistry::run_system_by_id`](bevy_ecs::system::SystemRegistry::run_system_by_id).
     #[inline]
     pub fn run_system_by_id(&mut self, system_id: SystemId) -> Result<(), SystemRegistryError> {
         self.world.run_system_by_id(system_id)
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 78b4e14a5041e..9d33a823cee73 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,7 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystemById, RunSystemCommand, SystemId
+    system::{IntoSystem, RunSystemById, RunSystemCommand, SystemId},
     world::{EntityWorldMut, FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 89275b9d5d824..eb3581f25a926 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -128,7 +128,7 @@ impl SystemRegistry {
 }
 
 impl World {
-    /// Registers a system in the [`SystemRegistry`]/
+    /// Registers a system in the [`SystemRegistry`].
     ///
     /// Calls [`SystemRegistry::register`].
     #[inline]
@@ -145,6 +145,20 @@ impl World {
         self.resource_mut::<SystemRegistry>().register(system)
     }
 
+    /// Removes a registered system in the [`SystemRegistry`].
+    ///
+    /// Calls [`SystemRegistry::remove`].
+    #[inline]
+    pub fn remove_system(&mut self, id: SystemId) {
+        if !self.contains_resource::<SystemRegistry>() {
+            panic!(
+                "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
+            );
+        }
+
+        self.resource_mut::<SystemRegistry>().remove(id);
+    }
+
     /// Run the systems with the provided [`SystemId`].
     ///
     /// Calls [`SystemRegistry::run_by_id`].

From 0a41754e1e85f35e54c0bcd25f24ecda4bc40f89 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Wed, 30 Aug 2023 00:52:22 +0200
Subject: [PATCH 093/113] Changed and added to documentation

---
 crates/bevy_app/src/system_registry.rs        |  4 +-
 crates/bevy_ecs/src/system/commands/mod.rs    |  4 +-
 crates/bevy_ecs/src/system/system.rs          | 24 ++++++
 crates/bevy_ecs/src/system/system_registry.rs | 84 +++++++++----------
 4 files changed, 68 insertions(+), 48 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 6168a01cc668e..89e34d4217e63 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -5,7 +5,7 @@ use bevy_ecs::system::{RunSystem, SystemId, SystemRegistryError};
 impl App {
     /// Register a system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry)
     ///
-    /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register_system).
+    /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register).
     pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         system: S,
@@ -33,7 +33,7 @@ impl App {
 
     /// Run the systems corresponding to the id.
     ///
-    /// Calls [`SystemRegistry::run_system_by_id`](bevy_ecs::system::SystemRegistry::run_system_by_id).
+    /// Calls [`SystemRegistry::run_system_by_id`](bevy_ecs::system::SystemRegistry::run_by_id).
     #[inline]
     pub fn run_system_by_id(&mut self, system_id: SystemId) -> Result<(), SystemRegistryError> {
         self.world.run_system_by_id(system_id)
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 9d33a823cee73..2f76045c521c4 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -522,7 +522,7 @@ impl<'w, 's> Commands<'w, 's> {
 
     /// Runs the supplied system on the [`World`] a single time.
     ///
-    /// Calls [`SystemRegistry::run_system`](crate::SystemRegistry::run_system).
+    /// Calls [`SystemRegistry::run_system`](crate::system::RunSystem::run_system).
     pub fn run_system<
         M: Send + Sync + 'static,
         S: IntoSystem<(), (), M> + Send + Sync + 'static,
@@ -535,7 +535,7 @@ impl<'w, 's> Commands<'w, 's> {
 
     /// Runs the system corresponding to the given [`SystemId`].
     ///
-    /// Calls [`SystemRegistry::run_system_by_id`](crate::SystemRegistry::run_system_by_id).
+    /// Calls [`SystemRegistry::run_system_by_id`](crate::system::SystemRegistry::run_by_id).
     pub fn run_system_by_id(&mut self, id: SystemId) {
         self.queue.push(RunSystemById::new(id));
     }
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 6f940e76ef5d5..087905649c282 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -167,6 +167,30 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// This function is not an efficient method of running systems and its meant to be used as a utility
 /// for testing and/or diagnostics.
 ///
+/// Systems called through [`run_system`](crate::system::RunSystem::run_system) do not hold onto any state,
+/// as they are created and destroyed every time [`run_system`](crate::system::RunSystem::run_system) is called.
+/// Practically, this means that [`Local`](crate::system::Local) variables are
+/// reset on every run and change detection does not work.
+///
+/// ```
+/// # use bevy_ecs::prelude::*;
+/// # use bevy_ecs::system::RunSystem;
+/// #[derive(Resource, Default)]
+/// struct Counter(u8);
+///
+/// fn increment(mut counter: Local<Counter>) {
+///    counter.0 .0 += 1;
+///    println!("{}", counter.0 .0);
+/// }
+///
+/// let mut world = World.default();
+/// world.run_system(increment); // prints 1
+/// world.run_system(increment); // still prints 1
+/// ```
+///
+/// If you do need systems to hold onto state between runs, use the [`SystemRegistry`](crate::system::SystemRegistry)
+/// and call by [`SystemId`](crate::system::SystemId).
+///
 /// # Usage
 /// Typically, to test a system, or to extract specific diagnostics information from a world,
 /// you'd need a [`Schedule`](crate::schedule::Schedule) to run the system. This can create redundant boilerplate code
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index eb3581f25a926..5c73ccf1a1d62 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -6,10 +6,10 @@ use crate::world::{Mut, World};
 use crate::{self as bevy_ecs};
 use bevy_ecs_macros::Resource;
 
-/// Stores initialized [`System`]s, so they can be reused and run in an ad-hoc fashion.
+/// Stores systems, so they can be reused and run in an ad-hoc fashion.
 ///
-/// Systems are keyed by their [`SystemId`]:
-///  - repeated calls with the same function type will reuse cached state, including for change detection
+/// Systems are keyed by their [`SystemId`](crate::system::SystemId).
+/// Repeated calls with the same function type will reuse cached state, including for change detection.
 ///
 /// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
 ///
@@ -19,74 +19,70 @@ use bevy_ecs_macros::Resource;
 ///
 /// # Limitations
 ///
-///  - stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values
-///  - stored systems cannot recurse: they cannot run other systems via the [`SystemRegistry`] methods on `World` or `Commands`
-///  - exclusive systems cannot be used
+///  - Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
+///  - Stored systems cannot recurse: they cannot run other systems via
+///    the [`SystemRegistry`](crate::system::SystemRegistry) methods on [`World`] or [`Commands`](crate::system::Commands).
+///  - Exclusive systems cannot be used.
 ///
 /// # Examples
 ///
-/// You can run a single system directly on the World,
-/// applying its effect and caching its state for the next time
-/// you call this method.
+/// You can run a single system directly on the [`World``], while maintaining state.
+/// It's also possible to register two systems at once.
 ///
 /// ```rust
-/// use bevy_ecs::prelude::*;
-///
-/// let mut world = World::new();  
-///
-/// #[derive(Default, PartialEq, Debug)]
+/// # use bevy_ecs::prelude::*;
+/// #[derive(Resource, Default)]
 /// struct Counter(u8);
 ///
-/// fn count_up(mut counter: ResMut<Counter>){
-///     counter.0 += 1;
+/// fn increment(mut counter: Local<Counter>) {
+///    counter.0 .0 += 1;
+///    println!("{}", counter.0 .0);
 /// }
 ///
-/// world.init_resource::<Counter>();
-/// world.run_system(count_up);
-///
-/// assert_eq!(Counter(1), *world.resource());
+/// let mut world = World::default();
+/// let counter_one = world.register_system(increment);
+/// let counter_two = world.register_system(increment);
+/// world.run_system_by_id(counter_one); // -> 1
+/// world.run_system_by_id(counter_one); // -> 2
+/// world.run_system_by_id(counter_two); // -> 1
 /// ```
 ///
-/// These systems immediately apply commands and cache state,
-/// ensuring that change detection and [`Local`](crate::system::Local) variables work correctly.
+/// Change detection:
 ///
 /// ```rust
-/// use bevy_ecs::prelude::*;
-///
-/// let mut world = World::new();
-///
-/// #[derive(Component)]
-/// struct Marker;
+/// # use bevy_ecs::
+/// #[derive(Resource, Default)]
+/// struct ChangeDetector;
 ///
-/// fn spawn_7_entities(mut commands: Commands) {
-///     for _ in 0..7 {
-///         commands.spawn(Marker);
+/// world.init_resource::<ChangeDetector>();
+/// let detector = world.register_system(|change_detector: ResMut<ChangeDetector>| {
+///     if change_detector.is_changed() {
+///         println!("Something happened!");
+///     } else {
+///         println!("Nothing happaned.");
 ///     }
-/// }
-///
-/// fn assert_7_spawned(query: Query<(), Added<Marker>>){
-///     let n_spawned = query.iter().count();
-///     assert_eq!(n_spawned, 7);
-/// }
-///
-/// world.run_system(spawn_7_entities);
-/// world.run_system(assert_7_spawned);
+/// });
+/// // Resources are changed when they are first added
+/// let _ = world.run_system_by_id(detector); // -> Something happened!
+/// let _ = world.run_system_by_id(detecotr); // -> Nothing happened.
+/// world.resource_mut::<ChangeDetector>().set_changed();
+/// let _ = world.run_system_by_id(detector); // -> Something happened!
 /// ```
+
 #[derive(Resource, Default)]
 pub struct SystemRegistry {
     last_id: u32,
     systems: HashMap<u32, (bool, BoxedSystem)>,
 }
 
-/// A wrapper type for TypeId.
-/// It identifies a system that is registered in the [`SystemRegistry`].
+/// An identifier for a system registered in the [`SystemRegistry`].
 #[derive(Debug, Clone, Copy)]
 pub struct SystemId(u32);
 
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so it can be run later.
     ///
-    /// Repeatedly registering a system will have no effect.
+    /// It's possible to register the same system twice, creating two instances in the registry.
     #[inline]
     pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> SystemId {
         let id = self.last_id + 1;
@@ -103,7 +99,7 @@ impl SystemRegistry {
         self.systems.remove(&id.0);
     }
 
-    /// Run the system by its [`SystemId`]
+    /// Run the system by its [`SystemId`].
     ///
     /// Systems must be registered before they can be run.
     #[inline]

From 12c067f8da9a1c2cd80a1ff52b9d24d228af1974 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Wed, 30 Aug 2023 01:00:49 +0200
Subject: [PATCH 094/113] appease the CI

---
 crates/bevy_ecs/src/system/system.rs          | 4 ++--
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 087905649c282..1a4f9423d0e9d 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -183,7 +183,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 ///    println!("{}", counter.0 .0);
 /// }
 ///
-/// let mut world = World.default();
+/// let mut world = World::default();
 /// world.run_system(increment); // prints 1
 /// world.run_system(increment); // still prints 1
 /// ```
@@ -302,7 +302,7 @@ impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
     #[must_use]
     pub fn new(system: S) -> Self {
         Self {
-            _phantom_marker: PhantomData::default(),
+            _phantom_marker: PhantomData,
             system,
         }
     }
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 5c73ccf1a1d62..b387e30192cc6 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -26,7 +26,7 @@ use bevy_ecs_macros::Resource;
 ///
 /// # Examples
 ///
-/// You can run a single system directly on the [`World``], while maintaining state.
+/// You can run a single system directly on the [`World`], while maintaining state.
 /// It's also possible to register two systems at once.
 ///
 /// ```rust

From e646e9c325ca9460f4bcd959b0be9e2f659c5faa Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Wed, 30 Aug 2023 01:18:53 +0200
Subject: [PATCH 095/113] fixed doc test

---
 crates/bevy_ecs/src/system/system.rs          | 4 ++--
 crates/bevy_ecs/src/system/system_registry.rs | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 1a4f9423d0e9d..5558851322ab7 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -179,8 +179,8 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// struct Counter(u8);
 ///
 /// fn increment(mut counter: Local<Counter>) {
-///    counter.0 .0 += 1;
-///    println!("{}", counter.0 .0);
+///    counter.0 += 1;
+///    println!("{}", counter.0);
 /// }
 ///
 /// let mut world = World::default();
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index b387e30192cc6..f71ef57b88c24 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -35,8 +35,8 @@ use bevy_ecs_macros::Resource;
 /// struct Counter(u8);
 ///
 /// fn increment(mut counter: Local<Counter>) {
-///    counter.0 .0 += 1;
-///    println!("{}", counter.0 .0);
+///    counter.0 += 1;
+///    println!("{}", counter.0);
 /// }
 ///
 /// let mut world = World::default();
@@ -50,7 +50,7 @@ use bevy_ecs_macros::Resource;
 /// Change detection:
 ///
 /// ```rust
-/// # use bevy_ecs::
+/// # use bevy_ecs::prelude::*;
 /// #[derive(Resource, Default)]
 /// struct ChangeDetector;
 ///

From 17ad0756bda483e95da8363a231fa99b7f2457a0 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Wed, 30 Aug 2023 01:28:45 +0200
Subject: [PATCH 096/113] fixed doc example 2

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index f71ef57b88c24..c8e65acf83cc8 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -54,6 +54,7 @@ use bevy_ecs_macros::Resource;
 /// #[derive(Resource, Default)]
 /// struct ChangeDetector;
 ///
+/// let mut world = World.default();
 /// world.init_resource::<ChangeDetector>();
 /// let detector = world.register_system(|change_detector: ResMut<ChangeDetector>| {
 ///     if change_detector.is_changed() {
@@ -62,6 +63,7 @@ use bevy_ecs_macros::Resource;
 ///         println!("Nothing happaned.");
 ///     }
 /// });
+///
 /// // Resources are changed when they are first added
 /// let _ = world.run_system_by_id(detector); // -> Something happened!
 /// let _ = world.run_system_by_id(detecotr); // -> Nothing happened.

From d1e7e4cfc53ccd31bc32399d23e27a95b998b28c Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Wed, 30 Aug 2023 01:39:08 +0200
Subject: [PATCH 097/113] fixed doc test 3

---
 crates/bevy_ecs/src/system/system_registry.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index c8e65acf83cc8..614fd5601cee1 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -54,7 +54,7 @@ use bevy_ecs_macros::Resource;
 /// #[derive(Resource, Default)]
 /// struct ChangeDetector;
 ///
-/// let mut world = World.default();
+/// let mut world = World::default();
 /// world.init_resource::<ChangeDetector>();
 /// let detector = world.register_system(|change_detector: ResMut<ChangeDetector>| {
 ///     if change_detector.is_changed() {
@@ -66,7 +66,7 @@ use bevy_ecs_macros::Resource;
 ///
 /// // Resources are changed when they are first added
 /// let _ = world.run_system_by_id(detector); // -> Something happened!
-/// let _ = world.run_system_by_id(detecotr); // -> Nothing happened.
+/// let _ = world.run_system_by_id(detector); // -> Nothing happened.
 /// world.resource_mut::<ChangeDetector>().set_changed();
 /// let _ = world.run_system_by_id(detector); // -> Something happened!
 /// ```

From 61986c33c098b05eeb07b906397dc8cd26b02ed4 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Wed, 30 Aug 2023 22:21:10 +0200
Subject: [PATCH 098/113] Changes from code review

---
 crates/bevy_app/src/system_registry.rs        |  6 ++--
 crates/bevy_ecs/src/system/system.rs          |  2 +-
 crates/bevy_ecs/src/system/system_registry.rs | 30 +++++++++++--------
 3 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 89e34d4217e63..484bb686719c5 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -1,5 +1,6 @@
 use crate::App;
 use bevy_ecs::prelude::*;
+use bevy_ecs::system::BoxedSystem;
 use bevy_ecs::system::{RunSystem, SystemId, SystemRegistryError};
 
 impl App {
@@ -15,11 +16,12 @@ impl App {
     }
 
     /// Removes a registered system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
+    /// It returns nothing if id has no corresponding system.
     ///
     /// Calls [`SystemRegistry::remove_system`](bevy_ecs::system::SystemRegistry::remove).
     #[inline]
-    pub fn remove_system(&mut self, id: SystemId) {
-        self.world.remove_system(id);
+    pub fn remove_system(&mut self, id: SystemId) -> Option<BoxedSystem> {
+        self.world.remove_system(id)
     }
 
     /// Runs the supplied system on the [`World`] a single time.
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 5558851322ab7..40c68fdcf2712 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -189,7 +189,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// ```
 ///
 /// If you do need systems to hold onto state between runs, use the [`SystemRegistry`](crate::system::SystemRegistry)
-/// and call by [`SystemId`](crate::system::SystemId).
+/// andrun the system by their [`SystemId`](crate::system::SystemId).
 ///
 /// # Usage
 /// Typically, to test a system, or to extract specific diagnostics information from a world,
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 614fd5601cee1..7f5a8723a0f1b 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -20,9 +20,8 @@ use bevy_ecs_macros::Resource;
 /// # Limitations
 ///
 ///  - Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
-///  - Stored systems cannot recurse: they cannot run other systems via
+///  - Stored systems cannot recurse or nest: they cannot run other systems via
 ///    the [`SystemRegistry`](crate::system::SystemRegistry) methods on [`World`] or [`Commands`](crate::system::Commands).
-///  - Exclusive systems cannot be used.
 ///
 /// # Examples
 ///
@@ -78,16 +77,22 @@ pub struct SystemRegistry {
 }
 
 /// An identifier for a system registered in the [`SystemRegistry`].
-#[derive(Debug, Clone, Copy)]
+///
+/// These are opaque identifiers, keyed to a specific [`SystemRegistry`],
+/// and are created via [`SystemRegistry::register`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct SystemId(u32);
 
 impl SystemRegistry {
     /// Registers a system in the [`SystemRegistry`], so it can be run later.
     ///
-    /// It's possible to register the same system twice, creating two instances in the registry.
+    /// It's possible to register the same system twice, creating two or more distinct instances in the registry.
     #[inline]
     pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> SystemId {
-        let id = self.last_id + 1;
+        let id = self
+            .last_id
+            .checked_add(1)
+            .expect("Maximum number of registered systems exceeded.");
         self.last_id = id;
         self.systems
             .insert(id, (false, Box::new(IntoSystem::into_system(system))));
@@ -95,15 +100,15 @@ impl SystemRegistry {
     }
 
     /// Removes a registered system from the [`SystemRegistry`], if the [`SystemId`] is not
-    /// registered, this function does nothing.
+    /// registered, it returns [`None`], otherwise it returns the system.
     #[inline]
-    pub fn remove(&mut self, id: SystemId) {
-        self.systems.remove(&id.0);
+    pub fn remove(&mut self, id: SystemId) -> Option<BoxedSystem> {
+        self.systems.remove(&id.0).unzip().1
     }
 
     /// Run the system by its [`SystemId`].
     ///
-    /// Systems must be registered before they can be run.
+    /// A [`SystemId`] can be obtained by registering it first via [`SystemRegistry::register`].
     #[inline]
     pub fn run_by_id(
         &mut self,
@@ -143,21 +148,22 @@ impl World {
         self.resource_mut::<SystemRegistry>().register(system)
     }
 
-    /// Removes a registered system in the [`SystemRegistry`].
+    /// Removes a registered system in the [`SystemRegistry`] and returns the system if it exists.
     ///
     /// Calls [`SystemRegistry::remove`].
     #[inline]
-    pub fn remove_system(&mut self, id: SystemId) {
+    pub fn remove_system(&mut self, id: SystemId) -> Option<BoxedSystem> {
         if !self.contains_resource::<SystemRegistry>() {
             panic!(
                 "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
             );
         }
 
-        self.resource_mut::<SystemRegistry>().remove(id);
+        self.resource_mut::<SystemRegistry>().remove(id)
     }
 
     /// Run the systems with the provided [`SystemId`].
+    /// A [`SystemId`] can obtained by registering a system via `[world::register_system]`.
     ///
     /// Calls [`SystemRegistry::run_by_id`].
     #[inline]

From c6de53df9b1496f67f972472b85dc843e035fbf8 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Thu, 31 Aug 2023 02:10:05 +0200
Subject: [PATCH 099/113] Changed outdated documentation

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 examples/ecs/one_shot_systems.rs              | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 7f5a8723a0f1b..1efb9efad103b 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -22,7 +22,7 @@ use bevy_ecs_macros::Resource;
 ///  - Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
 ///  - Stored systems cannot recurse or nest: they cannot run other systems via
 ///    the [`SystemRegistry`](crate::system::SystemRegistry) methods on [`World`] or [`Commands`](crate::system::Commands).
-///
+///  - Exclusive systems cannot be used.
 /// # Examples
 ///
 /// You can run a single system directly on the [`World`], while maintaining state.
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index 67781a0d40a38..a71ee9eb65181 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -20,8 +20,6 @@ fn main() {
 }
 
 // Any ordinary system can be run via commands.run_system or world.run_system.
-//
-// Chained systems, exclusive systems and systems which themselves run systems cannot be called in this way.
 fn count_entities(all_entities: Query<()>) {
     dbg!(all_entities.iter().count());
 }

From ea3082445b0e7dbe83f38d94f36f1848053e555d Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Fri, 1 Sep 2023 00:33:47 +0200
Subject: [PATCH 100/113] Store system initialization explicitly

---
 crates/bevy_app/src/system_registry.rs        |  4 +-
 crates/bevy_ecs/src/system/system_registry.rs | 37 +++++++++++++------
 2 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index 484bb686719c5..ec8137c77816e 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -1,6 +1,6 @@
 use crate::App;
 use bevy_ecs::prelude::*;
-use bevy_ecs::system::BoxedSystem;
+use bevy_ecs::system::RegisteredSystem;
 use bevy_ecs::system::{RunSystem, SystemId, SystemRegistryError};
 
 impl App {
@@ -20,7 +20,7 @@ impl App {
     ///
     /// Calls [`SystemRegistry::remove_system`](bevy_ecs::system::SystemRegistry::remove).
     #[inline]
-    pub fn remove_system(&mut self, id: SystemId) -> Option<BoxedSystem> {
+    pub fn remove_system(&mut self, id: SystemId) -> Option<RegisteredSystem> {
         self.world.remove_system(id)
     }
 
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 1efb9efad103b..3aa1334df1bbf 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -69,11 +69,20 @@ use bevy_ecs_macros::Resource;
 /// world.resource_mut::<ChangeDetector>().set_changed();
 /// let _ = world.run_system_by_id(detector); // -> Something happened!
 /// ```
-
 #[derive(Resource, Default)]
 pub struct SystemRegistry {
     last_id: u32,
-    systems: HashMap<u32, (bool, BoxedSystem)>,
+    systems: HashMap<u32, RegisteredSystem>,
+}
+
+/// A small wrapper for [`BoxedSystem`] that also keeps track whether or not the system has been initialized.
+///
+/// The [`SystemRegistry`] stores systems in this format.
+pub struct RegisteredSystem {
+    /// Shows whether or not the system is initialized.
+    pub initialized: bool,
+    /// The system stored in the [`SystemRegistry`].
+    pub system: BoxedSystem,
 }
 
 /// An identifier for a system registered in the [`SystemRegistry`].
@@ -94,16 +103,19 @@ impl SystemRegistry {
             .checked_add(1)
             .expect("Maximum number of registered systems exceeded.");
         self.last_id = id;
-        self.systems
-            .insert(id, (false, Box::new(IntoSystem::into_system(system))));
+        let registered_system = RegisteredSystem {
+            initialized: false,
+            system: Box::new(IntoSystem::into_system(system)),
+        };
+        self.systems.insert(id, registered_system);
         SystemId(id)
     }
 
     /// Removes a registered system from the [`SystemRegistry`], if the [`SystemId`] is not
     /// registered, it returns [`None`], otherwise it returns the system.
     #[inline]
-    pub fn remove(&mut self, id: SystemId) -> Option<BoxedSystem> {
-        self.systems.remove(&id.0).unzip().1
+    pub fn remove(&mut self, id: SystemId) -> Option<RegisteredSystem> {
+        self.systems.remove(&id.0)
     }
 
     /// Run the system by its [`SystemId`].
@@ -116,13 +128,16 @@ impl SystemRegistry {
         id: SystemId,
     ) -> Result<(), SystemRegistryError> {
         match self.systems.get_mut(&id.0) {
-            Some((initialized, matching_system)) => {
+            Some(RegisteredSystem {
+                initialized,
+                system,
+            }) => {
                 if !*initialized {
-                    matching_system.initialize(world);
+                    system.initialize(world);
                     *initialized = true;
                 }
-                matching_system.run((), world);
-                matching_system.apply_deferred(world);
+                system.run((), world);
+                system.apply_deferred(world);
                 Ok(())
             }
             None => Err(SystemRegistryError::SystemIdNotRegistered(id)),
@@ -152,7 +167,7 @@ impl World {
     ///
     /// Calls [`SystemRegistry::remove`].
     #[inline]
-    pub fn remove_system(&mut self, id: SystemId) -> Option<BoxedSystem> {
+    pub fn remove_system(&mut self, id: SystemId) -> Option<RegisteredSystem> {
         if !self.contains_resource::<SystemRegistry>() {
             panic!(
                 "SystemRegistry not found: Nested and recursive one-shot systems are not supported"

From ff615742b4a3ea9848eb905564098a4c0afbac23 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Fri, 1 Sep 2023 00:39:01 +0200
Subject: [PATCH 101/113] spelling mistake

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 3aa1334df1bbf..617c896c0aa8f 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -59,7 +59,7 @@ use bevy_ecs_macros::Resource;
 ///     if change_detector.is_changed() {
 ///         println!("Something happened!");
 ///     } else {
-///         println!("Nothing happaned.");
+///         println!("Nothing happened.");
 ///     }
 /// });
 ///

From 66b688ca490bc61ef576d38bc0891959963f0cca Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Sun, 3 Sep 2023 15:34:00 +0200
Subject: [PATCH 102/113] Changed public API for nested one-shot systems

---
 crates/bevy_app/src/system_registry.rs        |  4 +-
 crates/bevy_ecs/src/system/system_registry.rs | 38 +++++++++++++++----
 2 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
index ec8137c77816e..57c35f4ccc1fc 100644
--- a/crates/bevy_app/src/system_registry.rs
+++ b/crates/bevy_app/src/system_registry.rs
@@ -1,6 +1,6 @@
 use crate::App;
 use bevy_ecs::prelude::*;
-use bevy_ecs::system::RegisteredSystem;
+use bevy_ecs::system::RemovedSystem;
 use bevy_ecs::system::{RunSystem, SystemId, SystemRegistryError};
 
 impl App {
@@ -20,7 +20,7 @@ impl App {
     ///
     /// Calls [`SystemRegistry::remove_system`](bevy_ecs::system::SystemRegistry::remove).
     #[inline]
-    pub fn remove_system(&mut self, id: SystemId) -> Option<RegisteredSystem> {
+    pub fn remove_system(&mut self, id: SystemId) -> Result<RemovedSystem, SystemRegistryError> {
         self.world.remove_system(id)
     }
 
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 617c896c0aa8f..a3fcae0470114 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -79,10 +79,29 @@ pub struct SystemRegistry {
 ///
 /// The [`SystemRegistry`] stores systems in this format.
 pub struct RegisteredSystem {
-    /// Shows whether or not the system is initialized.
-    pub initialized: bool,
-    /// The system stored in the [`SystemRegistry`].
-    pub system: BoxedSystem,
+    initialized: bool,
+    system: BoxedSystem,
+}
+
+/// A system that has been removed from the registry.
+/// It contains the system and whether or not it has been initialized.
+///
+/// This struct is returned by [`SystemRegistry::remove`].
+pub struct RemovedSystem {
+    initialized: bool,
+    system: BoxedSystem,
+}
+
+impl RemovedSystem {
+    /// Is the system initialized?
+    /// A system is initialized the first time it's ran.
+    pub fn initialized(&self) -> bool {
+        self.initialized
+    }
+    /// The system removed from the [`SystemRegistry`]
+    pub fn system(self) -> BoxedSystem {
+        self.system
+    }
 }
 
 /// An identifier for a system registered in the [`SystemRegistry`].
@@ -112,10 +131,13 @@ impl SystemRegistry {
     }
 
     /// Removes a registered system from the [`SystemRegistry`], if the [`SystemId`] is not
-    /// registered, it returns [`None`], otherwise it returns the system.
+    /// registered, it returns a [`SystemRegistryError::SystemIdNotRegistered`], otherwise it returns the system.
     #[inline]
-    pub fn remove(&mut self, id: SystemId) -> Option<RegisteredSystem> {
-        self.systems.remove(&id.0)
+    pub fn remove(&mut self, id: SystemId) -> Result<RemovedSystem, SystemRegistryError> {
+        self.systems
+            .remove(&id.0)
+            .map(|RegisteredSystem { initialized, system }| RemovedSystem { initialized, system })
+            .ok_or(SystemRegistryError::SystemIdNotRegistered(id))
     }
 
     /// Run the system by its [`SystemId`].
@@ -167,7 +189,7 @@ impl World {
     ///
     /// Calls [`SystemRegistry::remove`].
     #[inline]
-    pub fn remove_system(&mut self, id: SystemId) -> Option<RegisteredSystem> {
+    pub fn remove_system(&mut self, id: SystemId) -> Result<RemovedSystem, SystemRegistryError> {
         if !self.contains_resource::<SystemRegistry>() {
             panic!(
                 "SystemRegistry not found: Nested and recursive one-shot systems are not supported"

From 7bacdf23d65aa43c611d828d4da74034c87aa3d0 Mon Sep 17 00:00:00 2001
From: Trashtalk217 <trashtalk217@gmail.com>
Date: Thu, 7 Sep 2023 22:50:11 +0200
Subject: [PATCH 103/113] Update crates/bevy_ecs/src/system/system.rs

Co-authored-by: Dmytro Banin <banind@cs.washington.edu>
---
 crates/bevy_ecs/src/system/system.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 40c68fdcf2712..1194f974552e2 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -189,7 +189,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// ```
 ///
 /// If you do need systems to hold onto state between runs, use the [`SystemRegistry`](crate::system::SystemRegistry)
-/// andrun the system by their [`SystemId`](crate::system::SystemId).
+/// and run the system by their [`SystemId`](crate::system::SystemId).
 ///
 /// # Usage
 /// Typically, to test a system, or to extract specific diagnostics information from a world,

From 83b898b589e12af45e959ac932c9caff367fd239 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Fri, 8 Sep 2023 22:05:53 +0200
Subject: [PATCH 104/113] Removed SystemRegistry, systems as almost entities

---
 crates/bevy_ecs/src/system/system_registry.rs | 186 ++++++++----------
 crates/bevy_ecs/src/world/mod.rs              |   9 +-
 examples/ecs/one_shot_systems.rs              |  15 +-
 3 files changed, 93 insertions(+), 117 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index a3fcae0470114..dd52c95b6b5c3 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,10 +1,9 @@
-use bevy_utils::HashMap;
-
 use crate::system::{BoxedSystem, Command, IntoSystem};
-use crate::world::{Mut, World};
+use crate::world::World;
 // Needed for derive(Component) macro
+use crate::entity::Entity;
 use crate::{self as bevy_ecs};
-use bevy_ecs_macros::Resource;
+use bevy_ecs_macros::Component;
 
 /// Stores systems, so they can be reused and run in an ad-hoc fashion.
 ///
@@ -69,16 +68,12 @@ use bevy_ecs_macros::Resource;
 /// world.resource_mut::<ChangeDetector>().set_changed();
 /// let _ = world.run_system_by_id(detector); // -> Something happened!
 /// ```
-#[derive(Resource, Default)]
-pub struct SystemRegistry {
-    last_id: u32,
-    systems: HashMap<u32, RegisteredSystem>,
-}
 
 /// A small wrapper for [`BoxedSystem`] that also keeps track whether or not the system has been initialized.
 ///
 /// The [`SystemRegistry`] stores systems in this format.
-pub struct RegisteredSystem {
+#[derive(Component)]
+struct RegisteredSystem {
     initialized: bool,
     system: BoxedSystem,
 }
@@ -109,111 +104,78 @@ impl RemovedSystem {
 /// These are opaque identifiers, keyed to a specific [`SystemRegistry`],
 /// and are created via [`SystemRegistry::register`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct SystemId(u32);
-
-impl SystemRegistry {
-    /// Registers a system in the [`SystemRegistry`], so it can be run later.
-    ///
-    /// It's possible to register the same system twice, creating two or more distinct instances in the registry.
-    #[inline]
-    pub fn register<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> SystemId {
-        let id = self
-            .last_id
-            .checked_add(1)
-            .expect("Maximum number of registered systems exceeded.");
-        self.last_id = id;
-        let registered_system = RegisteredSystem {
-            initialized: false,
-            system: Box::new(IntoSystem::into_system(system)),
-        };
-        self.systems.insert(id, registered_system);
-        SystemId(id)
-    }
-
-    /// Removes a registered system from the [`SystemRegistry`], if the [`SystemId`] is not
-    /// registered, it returns a [`SystemRegistryError::SystemIdNotRegistered`], otherwise it returns the system.
-    #[inline]
-    pub fn remove(&mut self, id: SystemId) -> Result<RemovedSystem, SystemRegistryError> {
-        self.systems
-            .remove(&id.0)
-            .map(|RegisteredSystem { initialized, system }| RemovedSystem { initialized, system })
-            .ok_or(SystemRegistryError::SystemIdNotRegistered(id))
-    }
-
-    /// Run the system by its [`SystemId`].
-    ///
-    /// A [`SystemId`] can be obtained by registering it first via [`SystemRegistry::register`].
-    #[inline]
-    pub fn run_by_id(
-        &mut self,
-        world: &mut World,
-        id: SystemId,
-    ) -> Result<(), SystemRegistryError> {
-        match self.systems.get_mut(&id.0) {
-            Some(RegisteredSystem {
-                initialized,
-                system,
-            }) => {
-                if !*initialized {
-                    system.initialize(world);
-                    *initialized = true;
-                }
-                system.run((), world);
-                system.apply_deferred(world);
-                Ok(())
-            }
-            None => Err(SystemRegistryError::SystemIdNotRegistered(id)),
-        }
-    }
-}
+pub struct SystemId(Entity);
 
 impl World {
     /// Registers a system in the [`SystemRegistry`].
     ///
     /// Calls [`SystemRegistry::register`].
-    #[inline]
     pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         system: S,
     ) -> SystemId {
-        if !self.contains_resource::<SystemRegistry>() {
-            panic!(
-                "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
-            );
-        }
-
-        self.resource_mut::<SystemRegistry>().register(system)
+        SystemId(
+            self.spawn(RegisteredSystem {
+                initialized: false,
+                system: Box::new(IntoSystem::into_system(system)),
+            })
+            .id(),
+        )
     }
 
     /// Removes a registered system in the [`SystemRegistry`] and returns the system if it exists.
     ///
     /// Calls [`SystemRegistry::remove`].
-    #[inline]
     pub fn remove_system(&mut self, id: SystemId) -> Result<RemovedSystem, SystemRegistryError> {
-        if !self.contains_resource::<SystemRegistry>() {
-            panic!(
-                "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
-            );
+        match self.get_entity_mut(id.0) {
+            Some(mut entity) => {
+                let registered_system = entity
+                    .take::<RegisteredSystem>()
+                    .expect("SystemId is not associated to a registered system.");
+                entity.despawn();
+                Ok(RemovedSystem {
+                    initialized: registered_system.initialized,
+                    system: registered_system.system,
+                })
+            }
+            None => Err(SystemRegistryError::SystemIdNotRegistered(id)),
         }
-
-        self.resource_mut::<SystemRegistry>().remove(id)
     }
 
     /// Run the systems with the provided [`SystemId`].
     /// A [`SystemId`] can obtained by registering a system via `[world::register_system]`.
     ///
     /// Calls [`SystemRegistry::run_by_id`].
-    #[inline]
     pub fn run_system_by_id(&mut self, id: SystemId) -> Result<(), SystemRegistryError> {
-        if !self.contains_resource::<SystemRegistry>() {
-            panic!(
-                "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
-            );
+        // lookup
+        let mut entity = self
+            .get_entity_mut(id.0)
+            .ok_or(SystemRegistryError::SystemIdNotRegistered(id))?;
+
+        // take ownership of system trait object
+        let RegisteredSystem {
+            mut initialized,
+            mut system,
+        } = entity
+            .take::<RegisteredSystem>()
+            .expect("Recursive system lookups are not supported.");
+
+        // run the system
+        if !initialized {
+            system.initialize(self);
+            initialized = true;
         }
+        system.run((), self);
+        system.apply_deferred(self);
 
-        self.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry.run_by_id(world, id)
-        })
+        // return ownership of system trait object (if entity still exists)
+        if let Some(mut entity) = self.get_entity_mut(id.0) {
+            entity.insert::<RegisteredSystem>(RegisteredSystem {
+                initialized,
+                system,
+            });
+        }
+        Ok(())
     }
 }
 
@@ -233,19 +195,7 @@ impl RunSystemById {
 impl Command for RunSystemById {
     #[inline]
     fn apply(self, world: &mut World) {
-        if !world.contains_resource::<SystemRegistry>() {
-            panic!(
-                "SystemRegistry not found: Nested and recursive one-shot systems are not supported"
-            );
-        }
-
-        world.resource_scope(|world, mut registry: Mut<SystemRegistry>| {
-            registry
-                .run_by_id(world, self.system_id)
-                // Ideally this error should be handled more gracefully,
-                // but that's blocked on a full error handling solution for commands
-                .unwrap();
-        });
+        let _ = world.run_system_by_id(self.system_id);
     }
 }
 
@@ -317,4 +267,34 @@ mod tests {
         let _ = world.run_system_by_id(id);
         assert_eq!(*world.resource::<Counter>(), Counter(8));
     }
+
+    #[test]
+    fn nested_systems() {
+        use crate::system::SystemId;
+
+        #[derive(Component)]
+        struct Callback(SystemId);
+
+        fn nested(query: Query<&Callback>, mut commands: Commands) {
+            for callback in query.iter() {
+                commands.run_system_by_id(callback.0);
+            }
+        }
+
+        let mut world = World::new();
+        world.insert_resource(Counter(0));
+
+        let increment_two = world.register_system(|mut counter: ResMut<Counter>| {
+            counter.0 += 2;
+        });
+        let increment_three = world.register_system(|mut counter: ResMut<Counter>| {
+            counter.0 += 3;
+        });
+        let nested_id = world.register_system(nested);
+
+        world.spawn(Callback(increment_two));
+        world.spawn(Callback(increment_three));
+        let _ = world.run_system_by_id(nested_id);
+        assert_eq!(*world.resource::<Counter>(), Counter(5));
+    }
 }
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index d50f610696490..2d795a242c94b 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -22,7 +22,7 @@ use crate::{
     removal_detection::RemovedComponentEvents,
     schedule::{Schedule, ScheduleLabel, Schedules},
     storage::{ResourceData, Storages},
-    system::{Resource, SystemRegistry},
+    system::Resource,
     world::error::TryRunScheduleError,
 };
 use bevy_ptr::{OwningPtr, Ptr};
@@ -75,7 +75,7 @@ pub struct World {
 
 impl Default for World {
     fn default() -> Self {
-        let mut world = Self {
+        Self {
             id: WorldId::new().expect("More `bevy` `World`s have been created than is supported"),
             entities: Entities::new(),
             components: Default::default(),
@@ -89,10 +89,7 @@ impl Default for World {
             change_tick: AtomicU32::new(1),
             last_change_tick: Tick::new(0),
             last_check_tick: Tick::new(0),
-        };
-        // This resource is required by bevy_ecs itself, so cannot be included in a plugin
-        world.init_resource::<SystemRegistry>();
-        world
+        }
     }
 }
 
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index a71ee9eb65181..e591675b505b3 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -7,7 +7,7 @@
 //! See the [`SystemRegistry`](bevy::ecs::SystemRegistry) docs for more details.
 
 use bevy::{
-    ecs::system::{SystemId, SystemRegistry},
+    ecs::system::{RunSystem, SystemId},
     prelude::*,
 };
 
@@ -30,14 +30,13 @@ struct Callback(SystemId);
 #[derive(Component)]
 struct Triggered;
 
-fn setup(mut system_registry: ResMut<SystemRegistry>, mut commands: Commands) {
-    commands.spawn((
-        Callback(system_registry.register(button_pressed)),
-        Triggered,
-    ));
+fn setup(world: &mut World) {
+    let button_pressed_id = world.register_system(button_pressed);
+    world.spawn((Callback(button_pressed_id), Triggered));
     // This entity does not have a Triggered component, so its callback won't run.
-    commands.spawn(Callback(system_registry.register(slider_toggled)));
-    commands.run_system(count_entities);
+    let slider_toggled_id = world.register_system(slider_toggled);
+    world.spawn(Callback(slider_toggled_id));
+    world.run_system(count_entities);
 }
 
 fn button_pressed() {

From d01a23ea2d0c3ac3ed5689e94deecd516d882aaf Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Sat, 9 Sep 2023 15:07:38 +0200
Subject: [PATCH 105/113] Fixed documentation, added RegisteredSystemError's

---
 crates/bevy_ecs/src/system/system_registry.rs | 163 ++++++++----------
 1 file changed, 76 insertions(+), 87 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index dd52c95b6b5c3..4446e588d00e1 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -5,73 +5,7 @@ use crate::entity::Entity;
 use crate::{self as bevy_ecs};
 use bevy_ecs_macros::Component;
 
-/// Stores systems, so they can be reused and run in an ad-hoc fashion.
-///
-/// Systems are keyed by their [`SystemId`](crate::system::SystemId).
-/// Repeated calls with the same function type will reuse cached state, including for change detection.
-///
-/// Any [`Commands`](crate::system::Commands) generated by these systems (but not other systems), will immediately be applied.
-///
-/// This type is stored as a [`Resource`](crate::system::Resource) on each [`World`], initialized by default.
-/// However, it will likely be easier to use the corresponding methods on [`World`],
-/// to avoid having to worry about split mutable borrows yourself.
-///
-/// # Limitations
-///
-///  - Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
-///  - Stored systems cannot recurse or nest: they cannot run other systems via
-///    the [`SystemRegistry`](crate::system::SystemRegistry) methods on [`World`] or [`Commands`](crate::system::Commands).
-///  - Exclusive systems cannot be used.
-/// # Examples
-///
-/// You can run a single system directly on the [`World`], while maintaining state.
-/// It's also possible to register two systems at once.
-///
-/// ```rust
-/// # use bevy_ecs::prelude::*;
-/// #[derive(Resource, Default)]
-/// struct Counter(u8);
-///
-/// fn increment(mut counter: Local<Counter>) {
-///    counter.0 += 1;
-///    println!("{}", counter.0);
-/// }
-///
-/// let mut world = World::default();
-/// let counter_one = world.register_system(increment);
-/// let counter_two = world.register_system(increment);
-/// world.run_system_by_id(counter_one); // -> 1
-/// world.run_system_by_id(counter_one); // -> 2
-/// world.run_system_by_id(counter_two); // -> 1
-/// ```
-///
-/// Change detection:
-///
-/// ```rust
-/// # use bevy_ecs::prelude::*;
-/// #[derive(Resource, Default)]
-/// struct ChangeDetector;
-///
-/// let mut world = World::default();
-/// world.init_resource::<ChangeDetector>();
-/// let detector = world.register_system(|change_detector: ResMut<ChangeDetector>| {
-///     if change_detector.is_changed() {
-///         println!("Something happened!");
-///     } else {
-///         println!("Nothing happened.");
-///     }
-/// });
-///
-/// // Resources are changed when they are first added
-/// let _ = world.run_system_by_id(detector); // -> Something happened!
-/// let _ = world.run_system_by_id(detector); // -> Nothing happened.
-/// world.resource_mut::<ChangeDetector>().set_changed();
-/// let _ = world.run_system_by_id(detector); // -> Something happened!
-/// ```
-
 /// A small wrapper for [`BoxedSystem`] that also keeps track whether or not the system has been initialized.
-///
-/// The [`SystemRegistry`] stores systems in this format.
 #[derive(Component)]
 struct RegisteredSystem {
     initialized: bool,
@@ -81,7 +15,7 @@ struct RegisteredSystem {
 /// A system that has been removed from the registry.
 /// It contains the system and whether or not it has been initialized.
 ///
-/// This struct is returned by [`SystemRegistry::remove`].
+/// This struct is returned by [`World::remove_system`].
 pub struct RemovedSystem {
     initialized: bool,
     system: BoxedSystem,
@@ -99,17 +33,17 @@ impl RemovedSystem {
     }
 }
 
-/// An identifier for a system registered in the [`SystemRegistry`].
+/// An identifier for a registered system.
 ///
-/// These are opaque identifiers, keyed to a specific [`SystemRegistry`],
-/// and are created via [`SystemRegistry::register`].
+/// These are opaque identifiers, keyed to a specific [`World`],
+/// and are created via [`World::register_system`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct SystemId(Entity);
 
 impl World {
-    /// Registers a system in the [`SystemRegistry`].
+    /// Registers a system and returns a [`SystemId`] so it can later be called by [`World::run_system_by_id`].
     ///
-    /// Calls [`SystemRegistry::register`].
+    /// It's possible to register the same systems more than once, they'll be stored seperately.
     pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         system: S,
@@ -123,34 +57,85 @@ impl World {
         )
     }
 
-    /// Removes a registered system in the [`SystemRegistry`] and returns the system if it exists.
+    /// Removes a registered system and returns the system, if it exists.
     ///
-    /// Calls [`SystemRegistry::remove`].
-    pub fn remove_system(&mut self, id: SystemId) -> Result<RemovedSystem, SystemRegistryError> {
+    /// If a system does not exist, this method returns an error.
+    /// Systems are also not allowed to remove themselves, this returns an error too.
+    pub fn remove_system(&mut self, id: SystemId) -> Result<RemovedSystem, RegisteredSystemError> {
         match self.get_entity_mut(id.0) {
             Some(mut entity) => {
                 let registered_system = entity
                     .take::<RegisteredSystem>()
-                    .expect("SystemId is not associated to a registered system.");
+                    .ok_or(RegisteredSystemError::SelfRemove(id))?;
                 entity.despawn();
                 Ok(RemovedSystem {
                     initialized: registered_system.initialized,
                     system: registered_system.system,
                 })
             }
-            None => Err(SystemRegistryError::SystemIdNotRegistered(id)),
+            None => Err(RegisteredSystemError::SystemIdNotRegistered(id)),
         }
     }
 
-    /// Run the systems with the provided [`SystemId`].
-    /// A [`SystemId`] can obtained by registering a system via `[world::register_system]`.
+    /// Run stored systems by their [`SystemId`].
+    /// Before running a system, it must first be registered.
+    /// The method [world::register_system]` stores a given system and returns a [`SystemId`].
+    /// This is different from [`world::run_system`], because it keeps local state between calls and change detection works correctly.
+    ///
+    /// # Limitations
+    ///
+    ///  - Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
+    ///  - Stored systems cannot be recursive, they cannot call themselves through [`Commands::run_system_by_id`].
+    ///  - Exclusive systems cannot be used.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use bevy_ecs::prelude::*;
+    /// #[derive(Resource, Default)]
+    /// struct Counter(u8);
+    ///
+    /// fn increment(mut counter: Local<Counter>) {
+    ///    counter.0 += 1;
+    ///    println!("{}", counter.0);
+    /// }
+    ///
+    /// let mut world = World::default();
+    /// let counter_one = world.register_system(increment);
+    /// let counter_two = world.register_system(increment);
+    /// world.run_system_by_id(counter_one); // -> 1
+    /// world.run_system_by_id(counter_one); // -> 2
+    /// world.run_system_by_id(counter_two); // -> 1
+    /// ```
+    ///
+    /// Change detection:
+    ///
+    /// ```rust
+    /// # use bevy_ecs::prelude::*;
+    /// #[derive(Resource, Default)]
+    /// struct ChangeDetector;
+    ///
+    /// let mut world = World::default();
+    /// world.init_resource::<ChangeDetector>();
+    /// let detector = world.register_system(|change_detector: ResMut<ChangeDetector>| {
+    ///     if change_detector.is_changed() {
+    ///         println!("Something happened!");
+    ///     } else {
+    ///         println!("Nothing happened.");
+    ///     }
+    /// });
     ///
-    /// Calls [`SystemRegistry::run_by_id`].
-    pub fn run_system_by_id(&mut self, id: SystemId) -> Result<(), SystemRegistryError> {
+    /// // Resources are changed when they are first added
+    /// let _ = world.run_system_by_id(detector); // -> Something happened!
+    /// let _ = world.run_system_by_id(detector); // -> Nothing happened.
+    /// world.resource_mut::<ChangeDetector>().set_changed();
+    /// let _ = world.run_system_by_id(detector); // -> Something happened!
+    /// ```
+    pub fn run_system_by_id(&mut self, id: SystemId) -> Result<(), RegisteredSystemError> {
         // lookup
         let mut entity = self
             .get_entity_mut(id.0)
-            .ok_or(SystemRegistryError::SystemIdNotRegistered(id))?;
+            .ok_or(RegisteredSystemError::SystemIdNotRegistered(id))?;
 
         // take ownership of system trait object
         let RegisteredSystem {
@@ -158,7 +143,7 @@ impl World {
             mut system,
         } = entity
             .take::<RegisteredSystem>()
-            .expect("Recursive system lookups are not supported.");
+            .ok_or(RegisteredSystemError::Recursive(id))?;
 
         // run the system
         if !initialized {
@@ -179,7 +164,7 @@ impl World {
     }
 }
 
-/// The [`Command`] type for [`SystemRegistry::run_by_id`].
+/// The [`Command`] type for [`World::run_system_by_id`].
 #[derive(Debug, Clone)]
 pub struct RunSystemById {
     system_id: SystemId,
@@ -199,13 +184,17 @@ impl Command for RunSystemById {
     }
 }
 
-/// An operation on a [`SystemRegistry`] failed
+/// An operation with stored systems failed.
 #[derive(Debug)]
-pub enum SystemRegistryError {
-    /// A system was run by label, but no system with that label was found.
+pub enum RegisteredSystemError {
+    /// A system was run by id, but no system with that id was found.
     ///
     /// Did you forget to register it?
     SystemIdNotRegistered(SystemId),
+    /// A system tried to run itself recursively.
+    Recursive(SystemId),
+    /// A system tried to remove itself.
+    SelfRemove(SystemId),
 }
 
 mod tests {

From c4c94e6fd4709328d4e5e8148766141cb8cee13f Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Sat, 9 Sep 2023 15:14:42 +0200
Subject: [PATCH 106/113] trimmed API

---
 crates/bevy_app/src/system_registry.rs     | 43 --------------------
 crates/bevy_ecs/src/system/commands/mod.rs | 15 +------
 crates/bevy_ecs/src/system/system.rs       | 47 ----------------------
 3 files changed, 1 insertion(+), 104 deletions(-)
 delete mode 100644 crates/bevy_app/src/system_registry.rs

diff --git a/crates/bevy_app/src/system_registry.rs b/crates/bevy_app/src/system_registry.rs
deleted file mode 100644
index 57c35f4ccc1fc..0000000000000
--- a/crates/bevy_app/src/system_registry.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-use crate::App;
-use bevy_ecs::prelude::*;
-use bevy_ecs::system::RemovedSystem;
-use bevy_ecs::system::{RunSystem, SystemId, SystemRegistryError};
-
-impl App {
-    /// Register a system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry)
-    ///
-    /// Calls [`SystemRegistry::register_system`](bevy_ecs::system::SystemRegistry::register).
-    pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
-        &mut self,
-        system: S,
-    ) -> &mut Self {
-        self.world.register_system(system);
-        self
-    }
-
-    /// Removes a registered system in the [`SystemRegistry`](bevy_ecs::system::SystemRegistry).
-    /// It returns nothing if id has no corresponding system.
-    ///
-    /// Calls [`SystemRegistry::remove_system`](bevy_ecs::system::SystemRegistry::remove).
-    #[inline]
-    pub fn remove_system(&mut self, id: SystemId) -> Result<RemovedSystem, SystemRegistryError> {
-        self.world.remove_system(id)
-    }
-
-    /// Runs the supplied system on the [`World`] a single time.
-    ///
-    /// Calls [`RunSystem::run_system`](bevy_ecs::system::RunSystem::run_system).
-    #[inline]
-    pub fn run_system<M, S: IntoSystem<(), (), M> + 'static>(&mut self, system: S) -> &mut Self {
-        self.world.run_system(system);
-        self
-    }
-
-    /// Run the systems corresponding to the id.
-    ///
-    /// Calls [`SystemRegistry::run_system_by_id`](bevy_ecs::system::SystemRegistry::run_by_id).
-    #[inline]
-    pub fn run_system_by_id(&mut self, system_id: SystemId) -> Result<(), SystemRegistryError> {
-        self.world.run_system_by_id(system_id)
-    }
-}
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 2f76045c521c4..9e1b8872cb26b 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,7 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    system::{IntoSystem, RunSystemById, RunSystemCommand, SystemId},
+    system::{RunSystemById, SystemId},
     world::{EntityWorldMut, FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -520,19 +520,6 @@ impl<'w, 's> Commands<'w, 's> {
         self.queue.push(RemoveResource::<R>::new());
     }
 
-    /// Runs the supplied system on the [`World`] a single time.
-    ///
-    /// Calls [`SystemRegistry::run_system`](crate::system::RunSystem::run_system).
-    pub fn run_system<
-        M: Send + Sync + 'static,
-        S: IntoSystem<(), (), M> + Send + Sync + 'static,
-    >(
-        &mut self,
-        system: S,
-    ) {
-        self.queue.push(RunSystemCommand::new(system));
-    }
-
     /// Runs the system corresponding to the given [`SystemId`].
     ///
     /// Calls [`SystemRegistry::run_system_by_id`](crate::system::SystemRegistry::run_by_id).
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 1194f974552e2..038c338de93c6 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -1,9 +1,7 @@
 use bevy_utils::tracing::warn;
 use core::fmt::Debug;
-use std::marker::PhantomData;
 
 use crate::component::Tick;
-use crate::system::Command;
 use crate::world::unsafe_world_cell::UnsafeWorldCell;
 use crate::{archetype::ArchetypeComponentId, component::ComponentId, query::Access, world::World};
 
@@ -284,39 +282,6 @@ impl RunSystem for &mut World {
     }
 }
 
-/// The [`Command`] type for [`RunSystem`]
-#[derive(Debug, Clone)]
-pub struct RunSystemCommand<
-    M: Send + Sync + 'static,
-    S: IntoSystem<(), (), M> + Send + Sync + 'static,
-> {
-    _phantom_marker: PhantomData<M>,
-    system: S,
-}
-
-impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static>
-    RunSystemCommand<M, S>
-{
-    /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
-    #[inline]
-    #[must_use]
-    pub fn new(system: S) -> Self {
-        Self {
-            _phantom_marker: PhantomData,
-            system,
-        }
-    }
-}
-
-impl<M: Send + Sync + 'static, S: IntoSystem<(), (), M> + Send + Sync + 'static> Command
-    for RunSystemCommand<M, S>
-{
-    #[inline]
-    fn apply(self, world: &mut World) {
-        world.run_system(self.system);
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -387,18 +352,6 @@ mod tests {
         assert_eq!(*world.non_send_resource::<Counter>(), Counter(9));
     }
 
-    #[test]
-    fn run_system_through_command() {
-        use crate::system::commands::Command;
-        use crate::system::RunSystemCommand;
-
-        let mut world = World::new();
-        let command = RunSystemCommand::new(spawn_entity);
-        assert_eq!(world.entities.len(), 0);
-        command.apply(&mut world);
-        assert_eq!(world.entities.len(), 1);
-    }
-
     #[test]
     fn system_recursion() {
         fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {

From d2e9ac770963971bf256de4ad8162e51fb94d7d7 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Sat, 9 Sep 2023 15:51:32 +0200
Subject: [PATCH 107/113] fixed documentation and an error

---
 crates/bevy_app/src/lib.rs                    | 1 -
 crates/bevy_ecs/src/system/commands/mod.rs    | 2 +-
 crates/bevy_ecs/src/system/function_system.rs | 4 ++--
 crates/bevy_ecs/src/system/system.rs          | 2 +-
 crates/bevy_ecs/src/system/system_registry.rs | 6 +++---
 5 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_app/src/lib.rs b/crates/bevy_app/src/lib.rs
index e317086a452c6..3439620a46633 100644
--- a/crates/bevy_app/src/lib.rs
+++ b/crates/bevy_app/src/lib.rs
@@ -8,7 +8,6 @@ mod main_schedule;
 mod plugin;
 mod plugin_group;
 mod schedule_runner;
-mod system_registry;
 
 #[cfg(feature = "bevy_ci_testing")]
 pub mod ci_testing;
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 9e1b8872cb26b..0137c29105688 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -522,7 +522,7 @@ impl<'w, 's> Commands<'w, 's> {
 
     /// Runs the system corresponding to the given [`SystemId`].
     ///
-    /// Calls [`SystemRegistry::run_system_by_id`](crate::system::SystemRegistry::run_by_id).
+    /// Calls [`World::run_system_by_id`](crate::system::World::run_system_by_id).
     pub fn run_system_by_id(&mut self, id: SystemId) {
         self.queue.push(RunSystemById::new(id));
     }
diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 1862ffc68585b..30a87d81349e8 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -62,7 +62,7 @@ impl SystemMeta {
 ///
 /// This is a powerful and convenient tool for working with exclusive world access,
 /// allowing you to fetch data from the [`World`] as if you were running a [`System`].
-/// However, simply calling `world::run_system(my_system)` using a [`SystemRegistry`](crate::system::SystemRegistry)
+/// However, simply calling `world::run_system_by_id(my_system)` using a [`World::run_system_by_id`](crate::system::World::run_system_by_id)
 /// can be significantly simpler and ensures that change detection and command flushing work as expected.
 ///
 /// Borrow-checking is handled for you, allowing you to mutably access multiple compatible system parameters at once,
@@ -79,7 +79,7 @@ impl SystemMeta {
 /// - [`Local`](crate::system::Local) variables that hold state
 /// - [`EventReader`](crate::event::EventReader) system parameters, which rely on a [`Local`](crate::system::Local) to track which events have been seen
 ///
-/// Note that this is automatically handled for you when using a [`SystemRegistry`](crate::system::SystemRegistry).
+/// Note that this is automatically handled for you when using a [`World::run_system_by_id`](crate::system::World::run_system_by_id).
 ///
 /// # Example
 ///
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 038c338de93c6..455fd7383c19d 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -186,7 +186,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// world.run_system(increment); // still prints 1
 /// ```
 ///
-/// If you do need systems to hold onto state between runs, use the [`SystemRegistry`](crate::system::SystemRegistry)
+/// If you do need systems to hold onto state between runs, use the [`World::run_system_by_id`](crate::system::World::run_system_by_id)
 /// and run the system by their [`SystemId`](crate::system::SystemId).
 ///
 /// # Usage
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 4446e588d00e1..5fbe010043148 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -27,7 +27,7 @@ impl RemovedSystem {
     pub fn initialized(&self) -> bool {
         self.initialized
     }
-    /// The system removed from the [`SystemRegistry`]
+    /// The system removed from the storage.
     pub fn system(self) -> BoxedSystem {
         self.system
     }
@@ -79,13 +79,13 @@ impl World {
 
     /// Run stored systems by their [`SystemId`].
     /// Before running a system, it must first be registered.
-    /// The method [world::register_system]` stores a given system and returns a [`SystemId`].
+    /// The method [World::register_system]` stores a given system and returns a [`SystemId`].
     /// This is different from [`world::run_system`], because it keeps local state between calls and change detection works correctly.
     ///
     /// # Limitations
     ///
     ///  - Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
-    ///  - Stored systems cannot be recursive, they cannot call themselves through [`Commands::run_system_by_id`].
+    ///  - Stored systems cannot be recursive, they cannot call themselves through [`Commands::run_system_by_id`](crate::system::Commands).
     ///  - Exclusive systems cannot be used.
     ///
     /// # Examples

From bcb7687eb0dbc2aafe8f659bda327520e419177f Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Sat, 9 Sep 2023 16:46:02 +0200
Subject: [PATCH 108/113] small fixes, removed failing test

---
 crates/bevy_ecs/src/system/system.rs          | 16 ----------------
 crates/bevy_ecs/src/system/system_registry.rs |  2 +-
 2 files changed, 1 insertion(+), 17 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 455fd7383c19d..aafe9749f581d 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -351,20 +351,4 @@ mod tests {
         world.run_system(non_send_count_down);
         assert_eq!(*world.non_send_resource::<Counter>(), Counter(9));
     }
-
-    #[test]
-    fn system_recursion() {
-        fn count_to_ten(mut counter: ResMut<Counter>, mut commands: Commands) {
-            counter.0 += 1;
-            if counter.0 < 10 {
-                commands.run_system(count_to_ten);
-            }
-        }
-
-        let mut world = World::new();
-        world.init_resource::<Counter>();
-        assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.run_system(count_to_ten);
-        assert_eq!(*world.resource::<Counter>(), Counter(10));
-    }
 }
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 5fbe010043148..03f8782206120 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -79,7 +79,7 @@ impl World {
 
     /// Run stored systems by their [`SystemId`].
     /// Before running a system, it must first be registered.
-    /// The method [World::register_system]` stores a given system and returns a [`SystemId`].
+    /// The method [`World::register_system`] stores a given system and returns a [`SystemId`].
     /// This is different from [`world::run_system`], because it keeps local state between calls and change detection works correctly.
     ///
     /// # Limitations

From 0b8f8dc10ede8057dff3e60d72ba0b1ee27b54cb Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Sun, 10 Sep 2023 14:07:32 +0200
Subject: [PATCH 109/113] renamed run_system and run_system_by_id

---
 crates/bevy_ecs/src/system/commands/mod.rs    |  8 +--
 crates/bevy_ecs/src/system/function_system.rs |  4 +-
 crates/bevy_ecs/src/system/system.rs          | 42 ++++++++--------
 crates/bevy_ecs/src/system/system_registry.rs | 49 ++++++++++---------
 examples/ecs/one_shot_systems.rs              | 10 ++--
 5 files changed, 57 insertions(+), 56 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 0137c29105688..85b3b7be292f6 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -5,7 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
-    system::{RunSystemById, SystemId},
+    system::{RunSystem, SystemId},
     world::{EntityWorldMut, FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -522,9 +522,9 @@ impl<'w, 's> Commands<'w, 's> {
 
     /// Runs the system corresponding to the given [`SystemId`].
     ///
-    /// Calls [`World::run_system_by_id`](crate::system::World::run_system_by_id).
-    pub fn run_system_by_id(&mut self, id: SystemId) {
-        self.queue.push(RunSystemById::new(id));
+    /// Calls [`World::run_system`](crate::system::World::run_system).
+    pub fn run_system(&mut self, id: SystemId) {
+        self.queue.push(RunSystem::new(id));
     }
 
     /// Pushes a generic [`Command`] to the command queue.
diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 30a87d81349e8..047a3807e88cb 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -62,7 +62,7 @@ impl SystemMeta {
 ///
 /// This is a powerful and convenient tool for working with exclusive world access,
 /// allowing you to fetch data from the [`World`] as if you were running a [`System`].
-/// However, simply calling `world::run_system_by_id(my_system)` using a [`World::run_system_by_id`](crate::system::World::run_system_by_id)
+/// However, simply calling `world::run_system(my_system)` using a [`World::run_system`](crate::system::World::run_system)
 /// can be significantly simpler and ensures that change detection and command flushing work as expected.
 ///
 /// Borrow-checking is handled for you, allowing you to mutably access multiple compatible system parameters at once,
@@ -79,7 +79,7 @@ impl SystemMeta {
 /// - [`Local`](crate::system::Local) variables that hold state
 /// - [`EventReader`](crate::event::EventReader) system parameters, which rely on a [`Local`](crate::system::Local) to track which events have been seen
 ///
-/// Note that this is automatically handled for you when using a [`World::run_system_by_id`](crate::system::World::run_system_by_id).
+/// Note that this is automatically handled for you when using a [`World::run_system`](crate::system::World::run_system).
 ///
 /// # Example
 ///
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index aafe9749f581d..bc42f5cc766f7 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -165,8 +165,8 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// This function is not an efficient method of running systems and its meant to be used as a utility
 /// for testing and/or diagnostics.
 ///
-/// Systems called through [`run_system`](crate::system::RunSystem::run_system) do not hold onto any state,
-/// as they are created and destroyed every time [`run_system`](crate::system::RunSystem::run_system) is called.
+/// Systems called through [`run_system_once`](crate::system::RunSystemOnce::run_system_once) do not hold onto any state,
+/// as they are created and destroyed every time [`run_system_once`](crate::system::RunSystemOnce::run_system_once) is called.
 /// Practically, this means that [`Local`](crate::system::Local) variables are
 /// reset on every run and change detection does not work.
 ///
@@ -182,11 +182,11 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// }
 ///
 /// let mut world = World::default();
-/// world.run_system(increment); // prints 1
-/// world.run_system(increment); // still prints 1
+/// world.run_system_once(increment); // prints 1
+/// world.run_system_once(increment); // still prints 1
 /// ```
 ///
-/// If you do need systems to hold onto state between runs, use the [`World::run_system_by_id`](crate::system::World::run_system_by_id)
+/// If you do need systems to hold onto state between runs, use the [`World::run_system`](crate::system::World::run_system)
 /// and run the system by their [`SystemId`](crate::system::SystemId).
 ///
 /// # Usage
@@ -206,7 +206,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// # use bevy_ecs::prelude::*;
 /// # use bevy_ecs::system::RunSystem;
 /// let mut world = World::default();
-/// let entity = world.run_system(|mut commands: Commands| {
+/// let entity = world.run_system_once(|mut commands: Commands| {
 ///     commands.spawn_empty().id()
 /// });
 /// # assert!(world.get_entity(entity).is_some());
@@ -226,7 +226,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// world.spawn(T(0));
 /// world.spawn(T(1));
 /// world.spawn(T(1));
-/// let count = world.run_system(|query: Query<&T>| {
+/// let count = world.run_system_once(|query: Query<&T>| {
 ///     query.iter().filter(|t| t.0 == 1).count()
 /// });
 ///
@@ -250,26 +250,26 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// world.spawn(T(0));
 /// world.spawn(T(1));
 /// world.spawn(T(1));
-/// let count = world.run_system(count);
+/// let count = world.run_system_once(count);
 ///
 /// # assert_eq!(count, 2);
 /// ```
-pub trait RunSystem: Sized {
+pub trait RunSystemOnce: Sized {
     /// Runs a system and applies its deferred parameters.
-    fn run_system<T: IntoSystem<(), Out, Marker>, Out, Marker>(self, system: T) -> Out {
-        self.run_system_with((), system)
+    fn run_system_once<T: IntoSystem<(), Out, Marker>, Out, Marker>(self, system: T) -> Out {
+        self.run_system_once_with((), system)
     }
 
     /// Runs a system with given input and applies its deferred parameters.
-    fn run_system_with<T: IntoSystem<In, Out, Marker>, In, Out, Marker>(
+    fn run_system_once_with<T: IntoSystem<In, Out, Marker>, In, Out, Marker>(
         self,
         input: In,
         system: T,
     ) -> Out;
 }
 
-impl RunSystem for &mut World {
-    fn run_system_with<T: IntoSystem<In, Out, Marker>, In, Out, Marker>(
+impl RunSystemOnce for &mut World {
+    fn run_system_once_with<T: IntoSystem<In, Out, Marker>, In, Out, Marker>(
         self,
         input: In,
         system: T,
@@ -289,7 +289,7 @@ mod tests {
     use crate::prelude::*;
 
     #[test]
-    fn run_system() {
+    fn run_system_once() {
         struct T(usize);
 
         impl Resource for T {}
@@ -300,7 +300,7 @@ mod tests {
         }
 
         let mut world = World::default();
-        let n = world.run_system_with(1, system);
+        let n = world.run_system_once_with(1, system);
         assert_eq!(n, 2);
         assert_eq!(world.resource::<T>().0, 1);
     }
@@ -314,15 +314,13 @@ mod tests {
     }
 
     #[test]
-    /// We need to ensure that the system registry is accessible
-    /// even after being used once.
     fn run_two_systems() {
         let mut world = World::new();
         world.init_resource::<Counter>();
         assert_eq!(*world.resource::<Counter>(), Counter(0));
-        world.run_system(count_up);
+        world.run_system_once(count_up);
         assert_eq!(*world.resource::<Counter>(), Counter(1));
-        world.run_system(count_up);
+        world.run_system_once(count_up);
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
@@ -335,7 +333,7 @@ mod tests {
     fn command_processing() {
         let mut world = World::new();
         assert_eq!(world.entities.len(), 0);
-        world.run_system(spawn_entity);
+        world.run_system_once(spawn_entity);
         assert_eq!(world.entities.len(), 1);
     }
 
@@ -348,7 +346,7 @@ mod tests {
         let mut world = World::new();
         world.insert_non_send_resource(Counter(10));
         assert_eq!(*world.non_send_resource::<Counter>(), Counter(10));
-        world.run_system(non_send_count_down);
+        world.run_system_once(non_send_count_down);
         assert_eq!(*world.non_send_resource::<Counter>(), Counter(9));
     }
 }
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 03f8782206120..81b1d4c7d5ce2 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -41,7 +41,7 @@ impl RemovedSystem {
 pub struct SystemId(Entity);
 
 impl World {
-    /// Registers a system and returns a [`SystemId`] so it can later be called by [`World::run_system_by_id`].
+    /// Registers a system and returns a [`SystemId`] so it can later be called by [`World::run_system`].
     ///
     /// It's possible to register the same systems more than once, they'll be stored seperately.
     pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
@@ -80,12 +80,13 @@ impl World {
     /// Run stored systems by their [`SystemId`].
     /// Before running a system, it must first be registered.
     /// The method [`World::register_system`] stores a given system and returns a [`SystemId`].
-    /// This is different from [`world::run_system`], because it keeps local state between calls and change detection works correctly.
+    /// This is different from [`RunSystemOnce::run_system_once`](crate::system::RunSystemOnce::run_system_once), 
+    /// because it keeps local state between calls and change detection works correctly.
     ///
     /// # Limitations
     ///
     ///  - Stored systems cannot be chained: they can neither have an [`In`](crate::system::In) nor return any values.
-    ///  - Stored systems cannot be recursive, they cannot call themselves through [`Commands::run_system_by_id`](crate::system::Commands).
+    ///  - Stored systems cannot be recursive, they cannot call themselves through [`Commands::run_system`](crate::system::Commands).
     ///  - Exclusive systems cannot be used.
     ///
     /// # Examples
@@ -103,9 +104,9 @@ impl World {
     /// let mut world = World::default();
     /// let counter_one = world.register_system(increment);
     /// let counter_two = world.register_system(increment);
-    /// world.run_system_by_id(counter_one); // -> 1
-    /// world.run_system_by_id(counter_one); // -> 2
-    /// world.run_system_by_id(counter_two); // -> 1
+    /// world.run_system(counter_one); // -> 1
+    /// world.run_system(counter_one); // -> 2
+    /// world.run_system(counter_two); // -> 1
     /// ```
     ///
     /// Change detection:
@@ -126,12 +127,12 @@ impl World {
     /// });
     ///
     /// // Resources are changed when they are first added
-    /// let _ = world.run_system_by_id(detector); // -> Something happened!
-    /// let _ = world.run_system_by_id(detector); // -> Nothing happened.
+    /// let _ = world.run_system(detector); // -> Something happened!
+    /// let _ = world.run_system(detector); // -> Nothing happened.
     /// world.resource_mut::<ChangeDetector>().set_changed();
-    /// let _ = world.run_system_by_id(detector); // -> Something happened!
+    /// let _ = world.run_system(detector); // -> Something happened!
     /// ```
-    pub fn run_system_by_id(&mut self, id: SystemId) -> Result<(), RegisteredSystemError> {
+    pub fn run_system(&mut self, id: SystemId) -> Result<(), RegisteredSystemError> {
         // lookup
         let mut entity = self
             .get_entity_mut(id.0)
@@ -164,23 +165,23 @@ impl World {
     }
 }
 
-/// The [`Command`] type for [`World::run_system_by_id`].
+/// The [`Command`] type for [`World::run_system`].
 #[derive(Debug, Clone)]
-pub struct RunSystemById {
+pub struct RunSystem {
     system_id: SystemId,
 }
 
-impl RunSystemById {
+impl RunSystem {
     /// Creates a new [`Command`] struct, which can be added to [`Commands`](crate::system::Commands)
     pub fn new(system_id: SystemId) -> Self {
         Self { system_id }
     }
 }
 
-impl Command for RunSystemById {
+impl Command for RunSystem {
     #[inline]
     fn apply(self, world: &mut World) {
-        let _ = world.run_system_by_id(self.system_id);
+        let _ = world.run_system(self.system_id);
     }
 }
 
@@ -224,14 +225,14 @@ mod tests {
         assert_eq!(*world.resource::<Counter>(), Counter(0));
         // Resources are changed when they are first added.
         let id = world.register_system(count_up_iff_changed);
-        let _ = world.run_system_by_id(id);
+        let _ = world.run_system(id);
         assert_eq!(*world.resource::<Counter>(), Counter(1));
         // Nothing changed
-        let _ = world.run_system_by_id(id);
+        let _ = world.run_system(id);
         assert_eq!(*world.resource::<Counter>(), Counter(1));
         // Making a change
         world.resource_mut::<ChangeDetector>().set_changed();
-        let _ = world.run_system_by_id(id);
+        let _ = world.run_system(id);
         assert_eq!(*world.resource::<Counter>(), Counter(2));
     }
 
@@ -247,13 +248,13 @@ mod tests {
         world.insert_resource(Counter(1));
         assert_eq!(*world.resource::<Counter>(), Counter(1));
         let id = world.register_system(doubling);
-        let _ = world.run_system_by_id(id);
+        let _ = world.run_system(id);
         assert_eq!(*world.resource::<Counter>(), Counter(1));
-        let _ = world.run_system_by_id(id);
+        let _ = world.run_system(id);
         assert_eq!(*world.resource::<Counter>(), Counter(2));
-        let _ = world.run_system_by_id(id);
+        let _ = world.run_system(id);
         assert_eq!(*world.resource::<Counter>(), Counter(4));
-        let _ = world.run_system_by_id(id);
+        let _ = world.run_system(id);
         assert_eq!(*world.resource::<Counter>(), Counter(8));
     }
 
@@ -266,7 +267,7 @@ mod tests {
 
         fn nested(query: Query<&Callback>, mut commands: Commands) {
             for callback in query.iter() {
-                commands.run_system_by_id(callback.0);
+                commands.run_system(callback.0);
             }
         }
 
@@ -283,7 +284,7 @@ mod tests {
 
         world.spawn(Callback(increment_two));
         world.spawn(Callback(increment_three));
-        let _ = world.run_system_by_id(nested_id);
+        let _ = world.run_system(nested_id);
         assert_eq!(*world.resource::<Counter>(), Counter(5));
     }
 }
diff --git a/examples/ecs/one_shot_systems.rs b/examples/ecs/one_shot_systems.rs
index e591675b505b3..f7f76d4fa7a98 100644
--- a/examples/ecs/one_shot_systems.rs
+++ b/examples/ecs/one_shot_systems.rs
@@ -4,10 +4,12 @@
 //! reducing the overhead of running extremely rarely run systems
 //! and improving schedule flexibility.
 //!
-//! See the [`SystemRegistry`](bevy::ecs::SystemRegistry) docs for more details.
+//! See the [`World::run_system`](bevy::ecs::World::run_system) or
+//! [`World::run_system_once`](bevy::ecs::World::run_system_once) docs for more
+//! details.
 
 use bevy::{
-    ecs::system::{RunSystem, SystemId},
+    ecs::system::{RunSystemOnce, SystemId},
     prelude::*,
 };
 
@@ -36,7 +38,7 @@ fn setup(world: &mut World) {
     // This entity does not have a Triggered component, so its callback won't run.
     let slider_toggled_id = world.register_system(slider_toggled);
     world.spawn(Callback(slider_toggled_id));
-    world.run_system(count_entities);
+    world.run_system_once(count_entities);
 }
 
 fn button_pressed() {
@@ -52,6 +54,6 @@ fn slider_toggled() {
 /// This could be done in an exclusive system rather than using `Commands` if preferred.
 fn evaluate_callbacks(query: Query<&Callback, With<Triggered>>, mut commands: Commands) {
     for callback in query.iter() {
-        commands.run_system_by_id(callback.0);
+        commands.run_system(callback.0);
     }
 }

From cdaecfcc214900a0fe993be7dc16e9daec6d538c Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Sun, 10 Sep 2023 14:10:22 +0200
Subject: [PATCH 110/113] cargo fmt

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 81b1d4c7d5ce2..46c688e451aa4 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -80,7 +80,7 @@ impl World {
     /// Run stored systems by their [`SystemId`].
     /// Before running a system, it must first be registered.
     /// The method [`World::register_system`] stores a given system and returns a [`SystemId`].
-    /// This is different from [`RunSystemOnce::run_system_once`](crate::system::RunSystemOnce::run_system_once), 
+    /// This is different from [`RunSystemOnce::run_system_once`](crate::system::RunSystemOnce::run_system_once),
     /// because it keeps local state between calls and change detection works correctly.
     ///
     /// # Limitations

From e5fbad0ab50f97dec660cb9042e402605240b610 Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Sun, 10 Sep 2023 14:29:13 +0200
Subject: [PATCH 111/113] fixed doc tests

---
 crates/bevy_ecs/src/system/system.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index bc42f5cc766f7..0c8c839f95e42 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -172,7 +172,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 ///
 /// ```
 /// # use bevy_ecs::prelude::*;
-/// # use bevy_ecs::system::RunSystem;
+/// # use bevy_ecs::system::RunSystemOnce;
 /// #[derive(Resource, Default)]
 /// struct Counter(u8);
 ///
@@ -204,7 +204,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// This usage is helpful when trying to test systems or functions that operate on [`Commands`](crate::system::Commands):
 /// ```
 /// # use bevy_ecs::prelude::*;
-/// # use bevy_ecs::system::RunSystem;
+/// # use bevy_ecs::system::RunSystemOnce;
 /// let mut world = World::default();
 /// let entity = world.run_system_once(|mut commands: Commands| {
 ///     commands.spawn_empty().id()
@@ -217,7 +217,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 /// This usage is helpful when trying to run an arbitrary query on a world for testing or debugging purposes:
 /// ```
 /// # use bevy_ecs::prelude::*;
-/// # use bevy_ecs::system::RunSystem;
+/// # use bevy_ecs::system::RunSystemOnce;
 ///
 /// #[derive(Component)]
 /// struct T(usize);
@@ -237,7 +237,7 @@ impl<In: 'static, Out: 'static> Debug for dyn System<In = In, Out = Out> {
 ///
 /// ```
 /// # use bevy_ecs::prelude::*;
-/// # use bevy_ecs::system::RunSystem;
+/// # use bevy_ecs::system::RunSystemOnce;
 ///
 /// #[derive(Component)]
 /// struct T(usize);

From 99166feea493ff30dfa4b9b85811fc5094fb8a7e Mon Sep 17 00:00:00 2001
From: Trashtalk <trashtalk217@gmail.com>
Date: Tue, 19 Sep 2023 21:00:28 +0200
Subject: [PATCH 112/113] Updated documentation

---
 crates/bevy_ecs/src/system/commands/mod.rs    |  2 ++
 crates/bevy_ecs/src/system/system_registry.rs | 17 ++++++++++++++---
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 85b3b7be292f6..703f1482755fc 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -521,6 +521,8 @@ impl<'w, 's> Commands<'w, 's> {
     }
 
     /// Runs the system corresponding to the given [`SystemId`].
+    /// Systems are ran in an exclusive and single threaded way.
+    /// Running slow systems can become a bottleneck.
     ///
     /// Calls [`World::run_system`](crate::system::World::run_system).
     pub fn run_system(&mut self, id: SystemId) {
diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index 46c688e451aa4..cb5cce8c23baa 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -1,7 +1,6 @@
+use crate::entity::Entity;
 use crate::system::{BoxedSystem, Command, IntoSystem};
 use crate::world::World;
-// Needed for derive(Component) macro
-use crate::entity::Entity;
 use crate::{self as bevy_ecs};
 use bevy_ecs_macros::Component;
 
@@ -27,6 +26,7 @@ impl RemovedSystem {
     pub fn initialized(&self) -> bool {
         self.initialized
     }
+
     /// The system removed from the storage.
     pub fn system(self) -> BoxedSystem {
         self.system
@@ -44,6 +44,12 @@ impl World {
     /// Registers a system and returns a [`SystemId`] so it can later be called by [`World::run_system`].
     ///
     /// It's possible to register the same systems more than once, they'll be stored seperately.
+    ///
+    /// This is different from adding systems to a [`Schedule`](crate::schedule::Schedule),
+    /// because the [`SystemId`] that is returned can be used anywhere in the [`World`] to run the associated system.
+    /// This allows for running systems in a pushed-based fashion, which is very flexible.
+    /// Using a [`Schedule`](crate::schedule::Schedule) is still preferred for most cases
+    /// due to its better performance and abillity to run non-conflicting systems simultaneously.
     pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(
         &mut self,
         system: S,
@@ -58,8 +64,10 @@ impl World {
     }
 
     /// Removes a registered system and returns the system, if it exists.
+    /// After removing a system, the [`SystemId`] becomes invalid and attempting to use it afterwards will result in errors.
+    /// Re-adding the removed system will register it on a new [`SystemId`].
     ///
-    /// If a system does not exist, this method returns an error.
+    /// If no system corresponds to the given [`SystemId`], this method returns an error.
     /// Systems are also not allowed to remove themselves, this returns an error too.
     pub fn remove_system(&mut self, id: SystemId) -> Result<RemovedSystem, RegisteredSystemError> {
         match self.get_entity_mut(id.0) {
@@ -166,6 +174,9 @@ impl World {
 }
 
 /// The [`Command`] type for [`World::run_system`].
+///
+/// This command runs systems in an exclusive and single threaded way.
+/// Running slow systems can become a bottleneck.
 #[derive(Debug, Clone)]
 pub struct RunSystem {
     system_id: SystemId,

From aa81e3f8ae94e20e4494776ecc48b58d3fdefeb7 Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Tue, 19 Sep 2023 12:59:40 -0700
Subject: [PATCH 113/113] Remove unnecessary comment about being flexible.

---
 crates/bevy_ecs/src/system/system_registry.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/system/system_registry.rs b/crates/bevy_ecs/src/system/system_registry.rs
index cb5cce8c23baa..f0522606d978f 100644
--- a/crates/bevy_ecs/src/system/system_registry.rs
+++ b/crates/bevy_ecs/src/system/system_registry.rs
@@ -47,7 +47,7 @@ impl World {
     ///
     /// This is different from adding systems to a [`Schedule`](crate::schedule::Schedule),
     /// because the [`SystemId`] that is returned can be used anywhere in the [`World`] to run the associated system.
-    /// This allows for running systems in a pushed-based fashion, which is very flexible.
+    /// This allows for running systems in a pushed-based fashion.
     /// Using a [`Schedule`](crate::schedule::Schedule) is still preferred for most cases
     /// due to its better performance and abillity to run non-conflicting systems simultaneously.
     pub fn register_system<M, S: IntoSystem<(), (), M> + 'static>(