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

Cargo.toml

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

@@ -7,6 +7,7 @@ mod config;
 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,35 @@
+use crate::App;
+use bevy_ecs::{
+    prelude::*,
+    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).
+    #[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 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)
+    }
+}

crates/bevy_ecs/src/schedule/set.rs

@@ -98,6 +98,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(PhantomData)

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

@@ -5,6 +5,7 @@ use crate::{
     self as bevy_ecs,
     bundle::Bundle,
     entity::{Entities, Entity},
+    system::{IntoSystem, RunSystem, RunSystemById, SystemId},
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::SystemParam;
@@ -504,6 +505,27 @@ impl<'w, 's> Commands<'w, 's> {
         });
     }
 
+    /// Adds a command directly to the command queue.
+    /// Runs the supplied system on the [`World`] a single time.
+    ///
+    /// Calls [`SystemRegistry::run_system`](crate::SystemRegistry::run_system).
+    pub fn run_system<
+        M: Send + Sync + 'static,
+        S: IntoSystem<(), (), M> + Send + Sync + 'static,
+    >(
+        &mut self,
+        system: 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: SystemId) {
+        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

crates/bevy_ecs/src/system/function_system.rs

@@ -61,8 +61,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.
@@ -78,6 +80,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:

crates/bevy_ecs/src/system/mod.rs

@@ -108,6 +108,7 @@ mod query;
 mod system;
 mod system_param;
 mod system_piping;
+mod system_registry;
 
 pub use combinator::*;
 pub use commands::*;
@@ -118,6 +119,7 @@ pub use query::*;
 pub use system::*;
 pub use system_param::*;
 pub use system_piping::*;
+pub use system_registry::*;
 
 /// Ensure that a given function is a [system](System).
 ///