Fast and correct one-shot systems with a system registry resource

Cargo.toml

@@ -820,6 +820,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"

crates/bevy_app/src/lib.rs

@@ -6,6 +6,7 @@ mod app;
 mod plugin;
 mod plugin_group;
 mod schedule_runner;
+mod system_registry;
 
 #[cfg(feature = "bevy_ci_testing")]
 mod ci_testing;

crates/bevy_app/src/system_registry.rs

@@ -0,0 +1,53 @@
+use crate::App;
+use bevy_ecs::prelude::*;
+use bevy_ecs::system::{Callback, 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<
+        Params,
+        S: IntoSystem<(), (), Params> + 'static,
+        LI: IntoIterator<Item = L>,
+        L: SystemLabel,
+    >(
+        &mut self,
+        system: S,
+        labels: LI,
+    ) -> &mut Self {
+        self.world.register_system(system, labels);
+        self
+    }
+
+    /// Runs the supplied system on the [`World`] a single time.
+    ///
+    /// 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 {
+        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).
+    #[inline]
+    pub fn run_callback(&mut self, callback: Callback) -> Result<(), SystemRegistryError> {
+        self.world.run_callback(callback)
+    }
+}

crates/bevy_ecs/src/system/commands/mod.rs

@@ -5,6 +5,8 @@ use crate::{
     bundle::Bundle,
     component::Component,
     entity::{Entities, Entity},
+    schedule::SystemLabel,
+    system::{Callback, IntoSystem, RunSystemCommand, RunSystemsByLabelCommand},
     world::{FromWorld, World},
 };
 use bevy_utils::tracing::{error, info, warn};
@@ -401,6 +403,37 @@ impl<'w, 's> Commands<'w, 's> {
         });
     }
 
+    /// Runs the supplied system on the [`World`] a single time.
+    ///
+    /// Calls [`SystemRegistry::run_system`](crate::SystemRegistry::run_system).
+    pub fn run_system<
+        Params: Send + Sync + 'static,
+        S: IntoSystem<(), (), Params> + Send + Sync + 'static,
+    >(
+        &mut self,
+        system: 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 });
+    }
+
     /// Adds a command directly to the command queue.
     ///
     /// `command` can be a built-in command, custom struct that implements [`Command`] or a closure

crates/bevy_ecs/src/system/function_system.rs

@@ -56,8 +56,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 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.
@@ -73,6 +75,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:
@@ -444,14 +448,26 @@ where
             self.system_meta.name.as_ref(),
         );
     }
+
     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`.
+#[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: 'static> SystemLabel for SystemTypeIdLabel<T> {
     #[inline]
     fn as_str(&self) -> &'static str {

crates/bevy_ecs/src/system/mod.rs

@@ -74,6 +74,7 @@ mod query;
 mod system;
 mod system_chaining;
 mod system_param;
+mod system_registry;
 
 pub use commands::*;
 pub use exclusive_system::*;
@@ -82,6 +83,7 @@ pub use query::*;
 pub use system::*;
 pub use system_chaining::*;
 pub use system_param::*;
+pub use system_registry::*;
 
 /// Ensure that a given function is a system
 ///