diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index 4b9a71812f083..dc800ae99a70e 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,10 +1,9 @@
 use crate::{CoreStage, Events, Plugin, PluginGroup, PluginGroupBuilder, StartupStage};
 use bevy_ecs::{
     component::{Component, ComponentDescriptor},
-    prelude::{FromWorld, IntoExclusiveSystem},
-    schedule::{
-        IntoSystemDescriptor, RunOnce, Schedule, Stage, StageLabel, State, SystemSet, SystemStage,
-    },
+    prelude::{ExclusiveSystem, FromWorld, IntoExclusiveSystem, IntoSystem, StageConfig, System},
+    schedule::{RunOnce, Schedule, Stage, StageLabel, State, SystemSet, SystemStage},
+    system::BoxedSystem,
     world::World,
 };
 use bevy_utils::tracing::debug;
@@ -50,7 +49,7 @@ impl Default for App {
 
         app.add_default_stages()
             .add_event::<AppExit>()
-            .add_system_to_stage(CoreStage::Last, World::clear_trackers.exclusive_system());
+            .add_exclusive(World::clear_trackers.stage(CoreStage::Last));
 
         #[cfg(feature = "bevy_ci_testing")]
         {
@@ -203,85 +202,108 @@ impl App {
     /// App::new()
     ///     .add_system(my_system);
     /// ```
-    pub fn add_system<Params>(&mut self, system: impl IntoSystemDescriptor<Params>) -> &mut Self {
-        self.add_system_to_stage(CoreStage::Update, system)
-    }
-
-    pub fn add_system_set(&mut self, system_set: SystemSet) -> &mut Self {
-        self.add_system_set_to_stage(CoreStage::Update, system_set)
-    }
-
-    pub fn add_system_to_stage<Params>(
-        &mut self,
-        stage_label: impl StageLabel,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> &mut Self {
-        self.schedule.add_system_to_stage(stage_label, system);
-        self
-    }
-
-    pub fn add_system_set_to_stage(
-        &mut self,
-        stage_label: impl StageLabel,
-        system_set: SystemSet,
-    ) -> &mut Self {
-        self.schedule
-            .add_system_set_to_stage(stage_label, system_set);
+    pub fn add_system<Params>(&mut self, system: impl IntoSystem<(), (), Params>) -> &mut Self {
+        let system = system.system();
+        if system.config().startup {
+            let system = {
+                if system.config().stage.is_some() {
+                    system
+                } else {
+                    system.stage(StartupStage::Startup)
+                }
+            };
+            self.schedule
+                .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                    schedule.add_system(system)
+                });
+        } else {
+            let system = {
+                if system.config().stage.is_some() {
+                    system
+                } else {
+                    system.stage(CoreStage::Update)
+                }
+            };
+            self.schedule.add_system(system);
+        }
         self
     }
 
-    /// Adds a system that is run once at application startup
-    ///
-    /// Startup systems run exactly once BEFORE all other systems. These are generally used for
-    /// app initialization code (ex: adding entities and resources).
-    ///
-    /// * For adding a system that runs for every frame, see [`App::add_system`].
-    /// * For adding a system to specific stage, see [`App::add_system_to_stage`].
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// fn my_startup_system(_commands: Commands) {
-    ///     println!("My startup system");
-    /// }
-    ///
-    /// App::new()
-    ///     .add_startup_system(my_startup_system);
-    /// ```
-    pub fn add_startup_system<Params>(
-        &mut self,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> &mut Self {
-        self.add_startup_system_to_stage(StartupStage::Startup, system)
-    }
-
-    pub fn add_startup_system_set(&mut self, system_set: SystemSet) -> &mut Self {
-        self.add_startup_system_set_to_stage(StartupStage::Startup, system_set)
-    }
+    pub fn add_system_set(&mut self, set: SystemSet) -> &mut Self {
+        fn ensure_no_conflicts(set: &SystemSet) {
+            if let Some(l) = set.systems
+                .iter()
+                .filter(|s| s.config().stage != set.config().stage)
+                .next()
+                .and_then(|s| s.config().stage.as_ref()) {
+                    panic!("System set stage conflicts with internal exclusive system's stage: {:?}", l.as_ref());
+                }
+            if let Some(l) = set.exclusive_systems
+                .iter()
+                .filter(|s| s.config().stage != set.config().stage)
+                .next()
+                .and_then(|s| s.config().stage.as_ref()) {
+                    panic!("System set stage conflicts with internal exclusive system's stage: {:?}", l.as_ref());
+                }
+        }
 
-    pub fn add_startup_system_to_stage<Params>(
-        &mut self,
-        stage_label: impl StageLabel,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> &mut Self {
-        self.schedule
-            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
-                schedule.add_system_to_stage(stage_label, system)
-            });
+        if set.config().startup {
+            let set = {
+                if set.config().stage.is_some() {
+                    set
+                } else {
+                    set.stage(StartupStage::Startup)
+                }
+            };
+            ensure_no_conflicts(&set);
+            self.schedule
+                .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                    schedule.add_system_set(set)
+                });
+        } else {
+            let set = {
+                if set.config().stage.is_some() {
+                    set
+                } else {
+                    set.stage(CoreStage::Update)
+                }
+            };
+            ensure_no_conflicts(&set);
+            self.schedule.add_system_set(set);
+        }
         self
     }
 
-    pub fn add_startup_system_set_to_stage(
+    pub fn add_exclusive<Params, SystemType>(
         &mut self,
-        stage_label: impl StageLabel,
-        system_set: SystemSet,
-    ) -> &mut Self {
-        self.schedule
-            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
-                schedule.add_system_set_to_stage(stage_label, system_set)
-            });
+        system: impl IntoExclusiveSystem<Params, SystemType>,
+    ) -> &mut Self
+    where
+        SystemType: ExclusiveSystem + StageConfig<Params, SystemType>,
+    {
+        let system = system.exclusive_system();
+        if system.config().startup {
+            let system = {
+                if system.config().stage.is_some() {
+                    system
+                } else {
+                    system.exclusive_system().stage(StartupStage::Startup)
+                }
+            };
+            self.schedule
+                .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                    schedule.add_exclusive(system)
+                });
+        } else {
+            let system = {
+                if system.config().stage.is_some() {
+                    system
+                } else {
+                    system.exclusive_system().stage(CoreStage::Update)
+                }
+            };
+            self.schedule.add_exclusive(system);
+        }
         self
     }
 
@@ -307,7 +329,7 @@ impl App {
         T: Component + Debug + Clone + Eq + Hash,
     {
         self.insert_resource(State::new(initial))
-            .add_system_set_to_stage(stage, State::<T>::get_driver())
+            .add_system_set(State::<T>::get_driver().stage(stage))
     }
 
     pub fn add_default_stages(&mut self) -> &mut Self {
@@ -335,7 +357,7 @@ impl App {
         T: Component,
     {
         self.insert_resource(Events::<T>::default())
-            .add_system_to_stage(CoreStage::First, Events::<T>::update_system)
+            .add_system(Events::<T>::update_system.stage(CoreStage::First))
     }
 
     /// Inserts a resource to the current [App] and overwrites any resource previously added of the same type.
diff --git a/crates/bevy_asset/src/assets.rs b/crates/bevy_asset/src/assets.rs
index d444cdee2d159..cb0d5f1de6b8e 100644
--- a/crates/bevy_asset/src/assets.rs
+++ b/crates/bevy_asset/src/assets.rs
@@ -3,7 +3,7 @@ use crate::{
     RefChange,
 };
 use bevy_app::{App, EventWriter, Events};
-use bevy_ecs::{system::ResMut, world::FromWorld};
+use bevy_ecs::{prelude::StageConfig, system::ResMut, world::FromWorld};
 use bevy_utils::HashMap;
 use crossbeam_channel::Sender;
 use std::fmt::Debug;
@@ -214,8 +214,8 @@ impl AddAsset for App {
         };
 
         self.insert_resource(assets)
-            .add_system_to_stage(AssetStage::AssetEvents, Assets::<T>::asset_event_system)
-            .add_system_to_stage(AssetStage::LoadAssets, update_asset_storage_system::<T>)
+            .add_system(Assets::<T>::asset_event_system.stage(AssetStage::AssetEvents))
+            .add_system(update_asset_storage_system::<T>.stage(AssetStage::LoadAssets))
             .register_type::<Handle<T>>()
             .add_event::<AssetEvent<T>>()
     }
diff --git a/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs b/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs
index 8224edd3893da..aa30833027b26 100644
--- a/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs
+++ b/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs
@@ -1,7 +1,10 @@
 use crate::{Asset, Assets};
 use bevy_app::prelude::*;
 use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics, MAX_DIAGNOSTIC_NAME_WIDTH};
-use bevy_ecs::system::{Res, ResMut};
+use bevy_ecs::{
+    prelude::StartupConfig,
+    system::{Res, ResMut},
+};
 
 /// Adds "asset count" diagnostic to an App
 pub struct AssetCountDiagnosticsPlugin<T: Asset> {
@@ -18,7 +21,7 @@ impl<T: Asset> Default for AssetCountDiagnosticsPlugin<T> {
 
 impl<T: Asset> Plugin for AssetCountDiagnosticsPlugin<T> {
     fn build(&self, app: &mut App) {
-        app.add_startup_system(Self::setup_system)
+        app.add_system(Self::setup_system.startup())
             .add_system(Self::diagnostic_system);
     }
 }
diff --git a/crates/bevy_asset/src/lib.rs b/crates/bevy_asset/src/lib.rs
index 0067c266ce981..42e3c30150726 100644
--- a/crates/bevy_asset/src/lib.rs
+++ b/crates/bevy_asset/src/lib.rs
@@ -27,7 +27,10 @@ pub use loader::*;
 pub use path::*;
 
 use bevy_app::{prelude::Plugin, App};
-use bevy_ecs::schedule::{StageLabel, SystemStage};
+use bevy_ecs::{
+    prelude::StageConfig,
+    schedule::{StageLabel, SystemStage},
+};
 use bevy_tasks::IoTaskPool;
 
 /// The names of asset stages in an App Schedule
@@ -101,15 +104,12 @@ impl Plugin for AssetPlugin {
             SystemStage::parallel(),
         )
         .register_type::<HandleId>()
-        .add_system_to_stage(
-            bevy_app::CoreStage::PreUpdate,
-            asset_server::free_unused_assets_system,
-        );
+        .add_system(asset_server::free_unused_assets_system.stage(bevy_app::CoreStage::PreUpdate));
 
         #[cfg(all(
             feature = "filesystem_watcher",
             all(not(target_arch = "wasm32"), not(target_os = "android"))
         ))]
-        app.add_system_to_stage(AssetStage::LoadAssets, io::filesystem_watcher_system);
+        app.add_system(io::filesystem_watcher_system.stage(AssetStage::LoadAssets));
     }
 }
diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs
index 5f44d68f9f40b..bbf39dcfb1b85 100644
--- a/crates/bevy_audio/src/lib.rs
+++ b/crates/bevy_audio/src/lib.rs
@@ -13,7 +13,7 @@ pub use audio_source::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::system::IntoExclusiveSystem;
+use bevy_ecs::{prelude::StageConfig, system::IntoExclusiveSystem};
 
 /// Adds support for audio playback to an App
 #[derive(Default)]
@@ -24,9 +24,10 @@ impl Plugin for AudioPlugin {
         app.init_non_send_resource::<AudioOutput<AudioSource>>()
             .add_asset::<AudioSource>()
             .init_resource::<Audio<AudioSource>>()
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                play_queued_audio_system::<AudioSource>.exclusive_system(),
+            .add_exclusive(
+                play_queued_audio_system::<AudioSource>
+                    .exclusive_system()
+                    .stage(CoreStage::PostUpdate),
             );
 
         #[cfg(any(feature = "mp3", feature = "flac", feature = "wav", feature = "vorbis"))]
diff --git a/crates/bevy_core/src/label.rs b/crates/bevy_core/src/label.rs
index 6c99bc76d8eea..91456dab7e5ea 100644
--- a/crates/bevy_core/src/label.rs
+++ b/crates/bevy_core/src/label.rs
@@ -122,6 +122,7 @@ pub(crate) fn entity_labels_system(
 #[cfg(test)]
 mod tests {
     use bevy_ecs::{
+        prelude::StageConfig,
         schedule::{Schedule, Stage, SystemStage},
         world::World,
     };
@@ -133,7 +134,7 @@ mod tests {
         world.insert_resource(EntityLabels::default());
         let mut schedule = Schedule::default();
         schedule.add_stage("test", SystemStage::single_threaded());
-        schedule.add_system_to_stage("test", entity_labels_system);
+        schedule.add_system(entity_labels_system.stage("test"));
         (world, schedule)
     }
 
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 5af6bc88f297e..085eb6588f7ad 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -20,8 +20,8 @@ pub mod prelude {
 use bevy_app::prelude::*;
 use bevy_ecs::{
     entity::Entity,
-    schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
-    system::IntoExclusiveSystem,
+    prelude::{ScheduleConfig, StageConfig, StartupConfig},
+    schedule::SystemLabel,
 };
 use bevy_utils::HashSet;
 use std::ops::Range;
@@ -58,12 +58,13 @@ impl Plugin for CorePlugin {
             .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),
+            .add_exclusive(time_system.stage(CoreStage::First).label(CoreSystem::Time))
+            .add_system(
+                entity_labels_system
+                    .startup()
+                    .stage(StartupStage::PostStartup),
             )
-            .add_startup_system_to_stage(StartupStage::PostStartup, entity_labels_system)
-            .add_system_to_stage(CoreStage::PostUpdate, entity_labels_system);
+            .add_system(entity_labels_system.stage(CoreStage::PostUpdate));
 
         register_rust_types(app);
         register_math_types(app);
diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 3655da70db419..67337ac5a71f4 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -4,7 +4,7 @@ use bevy_ecs::{
     component::ComponentId,
     query::Access,
     schedule::ShouldRun,
-    system::{ConfigurableSystem, IntoSystem, Local, Res, ResMut, System, SystemId},
+    system::{ConfigurableSystem, IntoSystem, Local, Res, ResMut, System, SystemConfig, SystemId},
     world::World,
 };
 use bevy_utils::HashMap;
@@ -51,6 +51,7 @@ impl FixedTimesteps {
 pub struct FixedTimestep {
     state: State,
     internal_system: Box<dyn System<In = (), Out = ShouldRun>>,
+    config: SystemConfig,
 }
 
 impl Default for FixedTimestep {
@@ -58,6 +59,7 @@ impl Default for FixedTimestep {
         Self {
             state: State::default(),
             internal_system: Box::new(Self::prepare_system.system()),
+            config: SystemConfig::default(),
         }
     }
 }
@@ -197,4 +199,12 @@ impl System for FixedTimestep {
     fn check_change_tick(&mut self, change_tick: u32) {
         self.internal_system.check_change_tick(change_tick);
     }
+
+    fn config(&self) -> &SystemConfig {
+        &self.config
+    }
+
+    fn config_mut(&mut self) -> &mut SystemConfig {
+        &mut self.config
+    }
 }
diff --git a/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs
index add37dee3c556..56550576bf71a 100644
--- a/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs
@@ -1,5 +1,6 @@
 use bevy_app::{App, Plugin};
 use bevy_ecs::{
+    prelude::StartupConfig,
     system::{IntoExclusiveSystem, ResMut},
     world::World,
 };
@@ -12,8 +13,8 @@ pub struct EntityCountDiagnosticsPlugin;
 
 impl Plugin for EntityCountDiagnosticsPlugin {
     fn build(&self, app: &mut App) {
-        app.add_startup_system(Self::setup_system)
-            .add_system(Self::diagnostic_system.exclusive_system());
+        app.add_system(Self::setup_system.startup())
+            .add_exclusive(Self::diagnostic_system.exclusive_system());
     }
 }
 
diff --git a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
index 2ff6f17af4f80..b90862b9b4f73 100644
--- a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
@@ -1,7 +1,10 @@
 use crate::{Diagnostic, DiagnosticId, Diagnostics};
 use bevy_app::prelude::*;
 use bevy_core::Time;
-use bevy_ecs::system::{Res, ResMut};
+use bevy_ecs::{
+    prelude::StartupConfig,
+    system::{Res, ResMut},
+};
 
 /// Adds "frame time" diagnostic to an App, specifically "frame time", "fps" and "frame count"
 #[derive(Default)]
@@ -13,7 +16,7 @@ pub struct FrameTimeDiagnosticsState {
 
 impl Plugin for FrameTimeDiagnosticsPlugin {
     fn build(&self, app: &mut bevy_app::App) {
-        app.add_startup_system(Self::setup_system)
+        app.add_system(Self::setup_system.startup())
             .insert_resource(FrameTimeDiagnosticsState { frame_count: 0.0 })
             .add_system(Self::diagnostic_system);
     }
diff --git a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
index e4054b20b9884..8945bc26f3439 100644
--- a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
@@ -1,7 +1,10 @@
 use super::{Diagnostic, DiagnosticId, Diagnostics};
 use bevy_app::prelude::*;
 use bevy_core::{Time, Timer};
-use bevy_ecs::system::{Res, ResMut};
+use bevy_ecs::{
+    prelude::StageConfig,
+    system::{Res, ResMut},
+};
 use bevy_log::{debug, info};
 use bevy_utils::Duration;
 
@@ -36,9 +39,9 @@ impl Plugin for LogDiagnosticsPlugin {
         });
 
         if self.debug {
-            app.add_system_to_stage(CoreStage::PostUpdate, Self::log_diagnostics_debug_system);
+            app.add_system(Self::log_diagnostics_debug_system.stage(CoreStage::PostUpdate));
         } else {
-            app.add_system_to_stage(CoreStage::PostUpdate, Self::log_diagnostics_system);
+            app.add_system(Self::log_diagnostics_system.stage(CoreStage::PostUpdate));
         }
     }
 }
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index c51925b710569..5adb27b252898 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -24,13 +24,15 @@ pub mod prelude {
         event::{EventReader, EventWriter},
         query::{Added, ChangeTrackers, Changed, Or, QueryState, With, Without},
         schedule::{
-            AmbiguitySetLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
-            RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaLabel, RunCriteriaPiping,
-            Schedule, Stage, StageLabel, State, SystemLabel, SystemSet, SystemStage,
+            AmbiguitySetLabel, RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaLabel,
+            RunCriteriaPiping, Schedule, Stage, StageLabel, State, SystemLabel, SystemSet,
+            SystemStage,
         },
         system::{
-            Commands, ConfigurableSystem, In, IntoChainSystem, IntoExclusiveSystem, IntoSystem,
-            Local, NonSend, NonSendMut, Query, QuerySet, RemovedComponents, Res, ResMut, System,
+            AmbiguityConfig, Commands, ConfigurableSystem, ExclusiveConfig, ExclusiveSystem, In,
+            IntoChainSystem, IntoExclusiveSystem, IntoSystem, Local, NonSend, NonSendMut, Query,
+            QuerySet, RemovedComponents, Res, ResMut, RunCriteraConfig, ScheduleConfig,
+            StageConfig, StartupConfig, System, SystemConfig,
         },
         world::{FromWorld, Mut, World},
     };
diff --git a/crates/bevy_ecs/src/schedule/mod.rs b/crates/bevy_ecs/src/schedule/mod.rs
index a1c386446c5d0..bb9e66c10c52b 100644
--- a/crates/bevy_ecs/src/schedule/mod.rs
+++ b/crates/bevy_ecs/src/schedule/mod.rs
@@ -6,7 +6,6 @@ mod run_criteria;
 mod stage;
 mod state;
 mod system_container;
-mod system_descriptor;
 mod system_set;
 
 pub use executor::*;
@@ -17,12 +16,15 @@ pub use run_criteria::*;
 pub use stage::*;
 pub use state::*;
 pub use system_container::*;
-pub use system_descriptor::*;
 pub use system_set::*;
 
 use std::fmt::Debug;
 
-use crate::{system::System, world::World};
+use crate::{
+    prelude::{ExclusiveSystem, IntoExclusiveSystem, IntoSystem},
+    system::System,
+    world::World,
+};
 use bevy_utils::HashMap;
 
 #[derive(Default)]
@@ -63,15 +65,6 @@ impl Schedule {
         self
     }
 
-    pub fn with_system_in_stage<Params>(
-        mut self,
-        stage_label: impl StageLabel,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> Self {
-        self.add_system_to_stage(stage_label, system);
-        self
-    }
-
     pub fn set_run_criteria<S: System<In = (), Out = ShouldRun>>(
         &mut self,
         system: S,
@@ -138,11 +131,10 @@ impl Schedule {
         self
     }
 
-    pub fn add_system_to_stage<Params>(
-        &mut self,
-        stage_label: impl StageLabel,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> &mut Self {
+    pub fn add_system<Params>(&mut self, system: impl IntoSystem<(), (), Params>) -> &mut Self {
+        let system = system.system();
+        let stage_label = system.config().stage.clone().expect("test");
+
         // Use a function instead of a closure to ensure that it is codegend inside bevy_ecs instead
         // of the game. Closures inherit generic parameters from their enclosing function.
         #[cold]
@@ -154,20 +146,57 @@ impl Schedule {
         }
 
         let stage = self
-            .get_stage_mut::<SystemStage>(&stage_label)
+            .get_stage_mut::<SystemStage>(stage_label.as_ref())
             .unwrap_or_else(move || stage_not_found(&stage_label));
         stage.add_system(system);
         self
     }
 
-    pub fn add_system_set_to_stage(
+    pub fn add_system_set(&mut self, system_set: SystemSet) -> &mut Self {
+        let stage_label = system_set.config().stage.clone().expect("test");
+
+        // Use a function instead of a closure to ensure that it is codegend inside bevy_ecs instead
+        // of the game. Closures inherit generic parameters from their enclosing function.
+        #[cold]
+        fn stage_not_found(stage_label: &dyn Debug) -> ! {
+            panic!(
+                "Stage '{:?}' does not exist or is not a SystemStage",
+                stage_label
+            )
+        }
+
+        let stage = self
+            .get_stage_mut::<SystemStage>(stage_label.as_ref())
+            .unwrap_or_else(move || stage_not_found(&stage_label));
+        stage.add_system_set(system_set);
+        self
+    }
+
+    pub fn add_exclusive<Params, SystemType>(
         &mut self,
-        stage_label: impl StageLabel,
-        system_set: SystemSet,
-    ) -> &mut Self {
-        self.stage(stage_label, |stage: &mut SystemStage| {
-            stage.add_system_set(system_set)
-        })
+        system: impl IntoExclusiveSystem<Params, SystemType>,
+    ) -> &mut Self
+    where
+        SystemType: ExclusiveSystem,
+    {
+        let system = system.exclusive_system();
+        let stage_label = system.config().stage.clone().expect("test");
+
+        // Use a function instead of a closure to ensure that it is codegend inside bevy_ecs instead
+        // of the game. Closures inherit generic parameters from their enclosing function.
+        #[cold]
+        fn stage_not_found(stage_label: &dyn Debug) -> ! {
+            panic!(
+                "Stage '{:?}' does not exist or is not a SystemStage",
+                stage_label
+            )
+        }
+
+        let stage = self
+            .get_stage_mut::<SystemStage>(stage_label.as_ref())
+            .unwrap_or_else(move || stage_not_found(&stage_label));
+        stage.add_exclusive(system);
+        self
     }
 
     pub fn stage<T: Stage, F: FnOnce(&mut T) -> &mut T>(
diff --git a/crates/bevy_ecs/src/schedule/run_criteria.rs b/crates/bevy_ecs/src/schedule/run_criteria.rs
index 56c43452d3e60..892920e51d211 100644
--- a/crates/bevy_ecs/src/schedule/run_criteria.rs
+++ b/crates/bevy_ecs/src/schedule/run_criteria.rs
@@ -3,7 +3,7 @@ use crate::{
     component::ComponentId,
     query::Access,
     schedule::{BoxedRunCriteriaLabel, GraphNode, RunCriteriaLabel},
-    system::{BoxedSystem, IntoSystem, System, SystemId},
+    system::{BoxedSystem, IntoSystem, System, SystemConfig, SystemId},
     world::World,
 };
 use std::borrow::Cow;
@@ -399,6 +399,7 @@ where
 pub struct RunOnce {
     ran: bool,
     system_id: SystemId,
+    system_config: SystemConfig,
     archetype_component_access: Access<ArchetypeComponentId>,
     component_access: Access<ComponentId>,
 }
@@ -408,6 +409,7 @@ impl Default for RunOnce {
         Self {
             ran: false,
             system_id: SystemId::new(),
+            system_config: SystemConfig::default(),
             archetype_component_access: Default::default(),
             component_access: Default::default(),
         }
@@ -454,4 +456,12 @@ impl System for RunOnce {
     fn initialize(&mut self, _world: &mut World) {}
 
     fn check_change_tick(&mut self, _change_tick: u32) {}
+
+    fn config(&self) -> &SystemConfig {
+        &self.system_config
+    }
+
+    fn config_mut(&mut self) -> &mut SystemConfig {
+        &mut self.system_config
+    }
 }
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 9d5dda4bdf385..75eddccbb9381 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1,14 +1,14 @@
 use crate::{
     component::ComponentId,
-    prelude::IntoSystem,
+    prelude::*,
     schedule::{
         graph_utils::{self, DependencyGraphError},
         BoxedRunCriteria, BoxedRunCriteriaLabel, BoxedSystemLabel, DuplicateLabelStrategy,
-        ExclusiveSystemContainer, GraphNode, InsertionPoint, ParallelExecutor,
-        ParallelSystemContainer, ParallelSystemExecutor, RunCriteriaContainer,
-        RunCriteriaDescriptor, RunCriteriaDescriptorOrLabel, RunCriteriaInner, ShouldRun,
-        SingleThreadedExecutor, SystemContainer, SystemDescriptor, SystemSet,
+        GraphNode, ParallelExecutor, ParallelSystemContainer, ParallelSystemExecutor,
+        RunCriteriaContainer, RunCriteriaDescriptor, RunCriteriaDescriptorOrLabel,
+        RunCriteriaInner, ShouldRun, SingleThreadedExecutor, SystemSet,
     },
+    system::{BoxedExclusiveSystem, BoxedSystem, InsertionPoint},
     world::{World, WorldId},
 };
 use bevy_utils::{tracing::info, HashMap, HashSet};
@@ -16,7 +16,8 @@ use downcast_rs::{impl_downcast, Downcast};
 use fixedbitset::FixedBitSet;
 use std::fmt::Debug;
 
-use super::IntoSystemDescriptor;
+use super::system_container::SystemContainer;
+use super::ExclusiveSystemContainer;
 
 pub trait Stage: Downcast + Send + Sync {
     /// Runs the stage; this happens once per update.
@@ -48,7 +49,7 @@ impl_downcast!(Stage);
 pub struct ReportExecutionOrderAmbiguities;
 
 /// Stores and executes systems. Execution order is not defined unless explicitly specified;
-/// see `SystemDescriptor` documentation.
+/// see [SystemConfig](crate::system::SystemConfig) documentation to configure which stage a system runs in.
 pub struct SystemStage {
     /// The WorldId this stage was last run on.
     world_id: Option<WorldId>,
@@ -107,10 +108,19 @@ impl SystemStage {
         }
     }
 
-    pub fn single<Params>(system: impl IntoSystemDescriptor<Params>) -> Self {
+    pub fn single<Params>(system: impl IntoSystem<(), (), Params>) -> Self {
         Self::single_threaded().with_system(system)
     }
 
+    pub fn single_exclusive<Params, SystemType>(
+        system: impl IntoExclusiveSystem<Params, SystemType>,
+    ) -> Self
+    where
+        SystemType: ExclusiveSystem,
+    {
+        Self::single_threaded().with_exclusive(system)
+    }
+
     pub fn single_threaded() -> Self {
         Self::new(Box::new(SingleThreadedExecutor::default()))
     }
@@ -133,72 +143,107 @@ impl SystemStage {
         self.executor = executor;
     }
 
-    pub fn with_system<Params>(mut self, system: impl IntoSystemDescriptor<Params>) -> Self {
+    pub fn with_system<Params>(mut self, system: impl IntoSystem<(), (), Params>) -> Self {
         self.add_system(system);
         self
     }
 
-    pub fn add_system<Params>(&mut self, system: impl IntoSystemDescriptor<Params>) -> &mut Self {
-        self.add_system_inner(system.into_descriptor(), None);
+    pub fn with_exclusive<Params, SystemType>(
+        mut self,
+        system: impl IntoExclusiveSystem<Params, SystemType>,
+    ) -> Self
+    where
+        SystemType: ExclusiveSystem,
+    {
+        self.add_exclusive(system);
+        self
+    }
+
+    pub fn add_system<Params>(&mut self, system: impl IntoSystem<(), (), Params>) -> &mut Self {
+        self.add_system_inner(Box::new(system.system()), None);
+        self
+    }
+
+    pub fn add_boxed_system(&mut self, system: BoxedSystem<(), ()>) -> &mut Self {
+        self.add_system_inner(system, None);
+        self
+    }
+
+    pub fn add_exclusive<Params, SystemType>(
+        &mut self,
+        system: impl IntoExclusiveSystem<Params, SystemType>,
+    ) -> &mut Self
+    where
+        SystemType: ExclusiveSystem,
+    {
+        self.add_exclusive_inner(Box::new(system.exclusive_system()), None);
         self
     }
 
-    fn add_system_inner(&mut self, system: SystemDescriptor, default_run_criteria: Option<usize>) {
+    pub fn add_boxed_exclusive_system(&mut self, system: BoxedExclusiveSystem) -> &mut Self {
+        self.add_exclusive_inner(system, None);
+        self
+    }
+    fn add_system_inner(
+        &mut self,
+        system: BoxedSystem<(), ()>,
+        default_run_criteria: Option<usize>,
+    ) {
         self.systems_modified = true;
-        match system {
-            SystemDescriptor::Exclusive(mut descriptor) => {
-                let insertion_point = descriptor.insertion_point;
-                let criteria = descriptor.run_criteria.take();
-                let mut container = ExclusiveSystemContainer::from_descriptor(descriptor);
-                match criteria {
-                    Some(RunCriteriaDescriptorOrLabel::Label(label)) => {
-                        container.run_criteria_label = Some(label);
-                    }
-                    Some(RunCriteriaDescriptorOrLabel::Descriptor(criteria_descriptor)) => {
-                        container.run_criteria_label = criteria_descriptor.label.clone();
-                        container.run_criteria_index =
-                            Some(self.add_run_criteria_internal(criteria_descriptor));
-                    }
-                    None => {
-                        container.run_criteria_index = default_run_criteria;
-                    }
-                }
-                match insertion_point {
-                    InsertionPoint::AtStart => {
-                        let index = self.exclusive_at_start.len();
-                        self.uninitialized_at_start.push(index);
-                        self.exclusive_at_start.push(container);
-                    }
-                    InsertionPoint::BeforeCommands => {
-                        let index = self.exclusive_before_commands.len();
-                        self.uninitialized_before_commands.push(index);
-                        self.exclusive_before_commands.push(container);
-                    }
-                    InsertionPoint::AtEnd => {
-                        let index = self.exclusive_at_end.len();
-                        self.uninitialized_at_end.push(index);
-                        self.exclusive_at_end.push(container);
-                    }
-                }
+        let mut container = ParallelSystemContainer::from_system(system);
+        match container.system_mut().config_mut().run_criteria.take() {
+            Some(RunCriteriaDescriptorOrLabel::Label(label)) => {
+                container.run_criteria_label = Some(label);
             }
-            SystemDescriptor::Parallel(mut descriptor) => {
-                let criteria = descriptor.run_criteria.take();
-                let mut container = ParallelSystemContainer::from_descriptor(descriptor);
-                match criteria {
-                    Some(RunCriteriaDescriptorOrLabel::Label(label)) => {
-                        container.run_criteria_label = Some(label);
-                    }
-                    Some(RunCriteriaDescriptorOrLabel::Descriptor(criteria_descriptor)) => {
-                        container.run_criteria_label = criteria_descriptor.label.clone();
-                        container.run_criteria_index =
-                            Some(self.add_run_criteria_internal(criteria_descriptor));
-                    }
-                    None => {
-                        container.run_criteria_index = default_run_criteria;
-                    }
-                }
-                self.uninitialized_parallel.push(self.parallel.len());
-                self.parallel.push(container);
+            Some(RunCriteriaDescriptorOrLabel::Descriptor(criteria_descriptor)) => {
+                container.run_criteria_label = criteria_descriptor.label.clone();
+                container.run_criteria_index =
+                    Some(self.add_run_criteria_internal(criteria_descriptor));
+            }
+            None => {
+                container.run_criteria_index = default_run_criteria;
+            }
+        }
+        self.uninitialized_parallel.push(self.parallel.len());
+        self.parallel.push(container);
+    }
+
+    fn add_exclusive_inner(
+        &mut self,
+        system: BoxedExclusiveSystem,
+        default_run_criteria: Option<usize>,
+    ) {
+        self.systems_modified = true;
+        let mut container = ExclusiveSystemContainer::from_system(system);
+        match container.system_mut().config_mut().run_criteria.take() {
+            Some(RunCriteriaDescriptorOrLabel::Label(label)) => {
+                container.run_criteria_label = Some(label);
+            }
+            Some(RunCriteriaDescriptorOrLabel::Descriptor(criteria_descriptor)) => {
+                container.run_criteria_label = criteria_descriptor.label.clone();
+                container.run_criteria_index =
+                    Some(self.add_run_criteria_internal(criteria_descriptor));
+            }
+            None => {
+                container.run_criteria_index = default_run_criteria;
+            }
+        }
+
+        match container.system_mut().config_mut().insertion_point {
+            InsertionPoint::AtStart => {
+                let index = self.exclusive_at_start.len();
+                self.uninitialized_at_start.push(index);
+                self.exclusive_at_start.push(container);
+            }
+            InsertionPoint::BeforeCommands => {
+                let index = self.exclusive_before_commands.len();
+                self.uninitialized_before_commands.push(index);
+                self.exclusive_before_commands.push(container);
+            }
+            InsertionPoint::AtEnd => {
+                let index = self.exclusive_at_end.len();
+                self.uninitialized_at_end.push(index);
+                self.exclusive_at_end.push(container);
             }
         }
     }
@@ -239,20 +284,31 @@ impl SystemStage {
 
     pub fn add_system_set(&mut self, system_set: SystemSet) -> &mut Self {
         self.systems_modified = true;
-        let (run_criteria, mut systems) = system_set.bake();
+        let (run_criteria, mut systems, mut exclusive_systems) = system_set.bake();
         let set_run_criteria_index = run_criteria.and_then(|criteria| {
             // validate that no systems have criteria
             for system in systems.iter_mut() {
-                if let Some(name) = match system {
-                    SystemDescriptor::Exclusive(descriptor) => descriptor
-                        .run_criteria
-                        .is_some()
-                        .then(|| descriptor.system.name()),
-                    SystemDescriptor::Parallel(descriptor) => descriptor
-                        .run_criteria
-                        .is_some()
-                        .then(|| descriptor.system.name()),
-                } {
+                if let Some(name) = system
+                    .config()
+                    .run_criteria
+                    .is_some()
+                    .then(|| system.name())
+                {
+                    panic!(
+                        "The system {} has a run criteria, but its `SystemSet` also has a run \
+                        criteria. This is not supported. Consider moving the system into a \
+                        different `SystemSet` or calling `add_system()` instead.",
+                        name
+                    )
+                }
+            }
+            for system in exclusive_systems.iter_mut() {
+                if let Some(name) = system
+                    .config()
+                    .run_criteria
+                    .is_some()
+                    .then(|| system.name())
+                {
                     panic!(
                         "The system {} has a run criteria, but its `SystemSet` also has a run \
                         criteria. This is not supported. Consider moving the system into a \
@@ -267,18 +323,13 @@ impl SystemStage {
                 }
                 RunCriteriaDescriptorOrLabel::Label(label) => {
                     for system in systems.iter_mut() {
-                        match system {
-                            SystemDescriptor::Exclusive(descriptor) => {
-                                descriptor.run_criteria =
-                                    Some(RunCriteriaDescriptorOrLabel::Label(label.clone()))
-                            }
-                            SystemDescriptor::Parallel(descriptor) => {
-                                descriptor.run_criteria =
-                                    Some(RunCriteriaDescriptorOrLabel::Label(label.clone()))
-                            }
-                        }
+                        system.config_mut().run_criteria =
+                            Some(RunCriteriaDescriptorOrLabel::Label(label.clone()))
+                    }
+                    for system in exclusive_systems.iter_mut() {
+                        system.config_mut().run_criteria =
+                            Some(RunCriteriaDescriptorOrLabel::Label(label.clone()))
                     }
-
                     None
                 }
             }
@@ -286,6 +337,9 @@ impl SystemStage {
         for system in systems.drain(..) {
             self.add_system_inner(system, set_run_criteria_index);
         }
+        for system in exclusive_systems.drain(..) {
+            self.add_exclusive_inner(system, set_run_criteria_index);
+        }
         self
     }
 
@@ -894,13 +948,15 @@ impl Stage for SystemStage {
 mod tests {
     use crate::{
         entity::Entity,
+        prelude::{
+            AmbiguityConfig, ExclusiveConfig, IntoExclusiveSystem, RunCriteraConfig, ScheduleConfig,
+        },
         query::{ChangeTrackers, Changed},
         schedule::{
-            BoxedSystemLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
-            RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaPiping, ShouldRun,
-            SingleThreadedExecutor, Stage, SystemSet, SystemStage,
+            BoxedSystemLabel, RunCriteria, RunCriteriaDescriptorCoercion, RunCriteriaPiping,
+            ShouldRun, SingleThreadedExecutor, Stage, SystemSet, SystemStage,
         },
-        system::{In, IntoExclusiveSystem, IntoSystem, Local, Query, ResMut},
+        system::{In, IntoSystem, Local, Query, ResMut},
         world::World,
     };
 
@@ -926,10 +982,10 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(0).exclusive_system().at_start())
+            .with_exclusive(make_exclusive(0).exclusive_system().at_start())
             .with_system(make_parallel(1))
-            .with_system(make_exclusive(2).exclusive_system().before_commands())
-            .with_system(make_exclusive(3).exclusive_system().at_end());
+            .with_exclusive(make_exclusive(2).exclusive_system().before_commands())
+            .with_exclusive(make_exclusive(3).exclusive_system().at_end());
         stage.run(&mut world);
         assert_eq!(
             *world.get_resource_mut::<Vec<usize>>().unwrap(),
@@ -944,10 +1000,10 @@ mod tests {
 
         world.get_resource_mut::<Vec<usize>>().unwrap().clear();
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(2).exclusive_system().before_commands())
-            .with_system(make_exclusive(3).exclusive_system().at_end())
+            .with_exclusive(make_exclusive(2).exclusive_system().before_commands())
+            .with_exclusive(make_exclusive(3).exclusive_system().at_end())
             .with_system(make_parallel(1))
-            .with_system(make_exclusive(0).exclusive_system().at_start());
+            .with_exclusive(make_exclusive(0).exclusive_system().at_start());
         stage.run(&mut world);
         assert_eq!(
             *world.get_resource::<Vec<usize>>().unwrap(),
@@ -962,10 +1018,10 @@ mod tests {
 
         world.get_resource_mut::<Vec<usize>>().unwrap().clear();
         let mut stage = SystemStage::parallel()
-            .with_system(make_parallel(2).exclusive_system().before_commands())
-            .with_system(make_parallel(3).exclusive_system().at_end())
+            .with_exclusive(make_parallel(2).exclusive_system().before_commands())
+            .with_exclusive(make_parallel(3).exclusive_system().at_end())
             .with_system(make_parallel(1))
-            .with_system(make_parallel(0).exclusive_system().at_start());
+            .with_exclusive(make_parallel(0).exclusive_system().at_start());
         stage.run(&mut world);
         assert_eq!(
             *world.get_resource::<Vec<usize>>().unwrap(),
@@ -984,9 +1040,9 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(1).exclusive_system().label("1").after("0"))
-            .with_system(make_exclusive(2).exclusive_system().after("1"))
-            .with_system(make_exclusive(0).exclusive_system().label("0"));
+            .with_exclusive(make_exclusive(1).exclusive_system().label("1").after("0"))
+            .with_exclusive(make_exclusive(2).exclusive_system().after("1"))
+            .with_exclusive(make_exclusive(0).exclusive_system().label("0"));
         stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
         stage.run(&mut world);
@@ -1001,9 +1057,9 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(1).exclusive_system().label("1").before("2"))
-            .with_system(make_exclusive(2).exclusive_system().label("2"))
-            .with_system(make_exclusive(0).exclusive_system().before("1"));
+            .with_exclusive(make_exclusive(1).exclusive_system().label("1").before("2"))
+            .with_exclusive(make_exclusive(2).exclusive_system().label("2"))
+            .with_exclusive(make_exclusive(0).exclusive_system().before("1"));
         stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
         stage.run(&mut world);
@@ -1018,11 +1074,11 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(2).exclusive_system().label("2"))
-            .with_system(make_exclusive(1).exclusive_system().after("0").before("2"))
-            .with_system(make_exclusive(0).exclusive_system().label("0"))
-            .with_system(make_exclusive(4).exclusive_system().label("4"))
-            .with_system(make_exclusive(3).exclusive_system().after("2").before("4"));
+            .with_exclusive(make_exclusive(2).exclusive_system().label("2"))
+            .with_exclusive(make_exclusive(1).exclusive_system().after("0").before("2"))
+            .with_exclusive(make_exclusive(0).exclusive_system().label("0"))
+            .with_exclusive(make_exclusive(4).exclusive_system().label("4"))
+            .with_exclusive(make_exclusive(3).exclusive_system().after("2").before("4"));
         stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
         stage.run(&mut world);
@@ -1037,14 +1093,14 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(
+            .with_exclusive(
                 make_exclusive(1)
                     .exclusive_system()
                     .label("first")
                     .after("0"),
             )
-            .with_system(make_exclusive(2).exclusive_system().after("first"))
-            .with_system(
+            .with_exclusive(make_exclusive(2).exclusive_system().after("first"))
+            .with_exclusive(
                 make_exclusive(0)
                     .exclusive_system()
                     .label("first")
@@ -1060,11 +1116,11 @@ mod tests {
 
         world.get_resource_mut::<Vec<usize>>().unwrap().clear();
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(2).exclusive_system().after("01").label("2"))
-            .with_system(make_exclusive(1).exclusive_system().label("01").after("0"))
-            .with_system(make_exclusive(0).exclusive_system().label("01").label("0"))
-            .with_system(make_exclusive(4).exclusive_system().label("4"))
-            .with_system(make_exclusive(3).exclusive_system().after("2").before("4"));
+            .with_exclusive(make_exclusive(2).exclusive_system().after("01").label("2"))
+            .with_exclusive(make_exclusive(1).exclusive_system().label("01").after("0"))
+            .with_exclusive(make_exclusive(0).exclusive_system().label("01").label("0"))
+            .with_exclusive(make_exclusive(4).exclusive_system().label("4"))
+            .with_exclusive(make_exclusive(3).exclusive_system().after("2").before("4"));
         stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
         stage.run(&mut world);
@@ -1075,16 +1131,16 @@ mod tests {
 
         world.get_resource_mut::<Vec<usize>>().unwrap().clear();
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(2).exclusive_system().label("234").label("2"))
-            .with_system(
+            .with_exclusive(make_exclusive(2).exclusive_system().label("234").label("2"))
+            .with_exclusive(
                 make_exclusive(1)
                     .exclusive_system()
                     .before("234")
                     .after("0"),
             )
-            .with_system(make_exclusive(0).exclusive_system().label("0"))
-            .with_system(make_exclusive(4).exclusive_system().label("234").label("4"))
-            .with_system(
+            .with_exclusive(make_exclusive(0).exclusive_system().label("0"))
+            .with_exclusive(make_exclusive(4).exclusive_system().label("234").label("4"))
+            .with_exclusive(
                 make_exclusive(3)
                     .exclusive_system()
                     .label("234")
@@ -1105,7 +1161,7 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(
+            .with_exclusive(
                 make_exclusive(2)
                     .exclusive_system()
                     .label("2")
@@ -1113,7 +1169,7 @@ mod tests {
                     .before("3")
                     .before("3"),
             )
-            .with_system(
+            .with_exclusive(
                 make_exclusive(1)
                     .exclusive_system()
                     .label("1")
@@ -1121,9 +1177,9 @@ mod tests {
                     .after("0")
                     .before("2"),
             )
-            .with_system(make_exclusive(0).exclusive_system().label("0").before("1"))
-            .with_system(make_exclusive(4).exclusive_system().label("4").after("3"))
-            .with_system(
+            .with_exclusive(make_exclusive(0).exclusive_system().label("0").before("1"))
+            .with_exclusive(make_exclusive(4).exclusive_system().label("4").after("3"))
+            .with_exclusive(
                 make_exclusive(3)
                     .exclusive_system()
                     .label("3")
@@ -1144,14 +1200,14 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(2).exclusive_system().label("2"))
+            .with_exclusive(make_exclusive(2).exclusive_system().label("2"))
             .with_system_set(
                 SystemSet::new()
-                    .with_system(make_exclusive(0).exclusive_system().label("0"))
-                    .with_system(make_exclusive(4).exclusive_system().label("4"))
-                    .with_system(make_exclusive(3).exclusive_system().after("2").before("4")),
+                    .with_exclusive(make_exclusive(0).exclusive_system().label("0"))
+                    .with_exclusive(make_exclusive(4).exclusive_system().label("4"))
+                    .with_exclusive(make_exclusive(3).exclusive_system().after("2").before("4")),
             )
-            .with_system(make_exclusive(1).exclusive_system().after("0").before("2"));
+            .with_exclusive(make_exclusive(1).exclusive_system().after("0").before("2"));
         stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
         stage.run(&mut world);
@@ -1166,13 +1222,13 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(0).exclusive_system().before("1"))
+            .with_exclusive(make_exclusive(0).exclusive_system().before("1"))
             .with_system_set(
                 SystemSet::new()
                     .with_run_criteria(every_other_time)
-                    .with_system(make_exclusive(1).exclusive_system().label("1")),
+                    .with_exclusive(make_exclusive(1).exclusive_system().label("1")),
             )
-            .with_system(make_exclusive(2).exclusive_system().after("1"));
+            .with_exclusive(make_exclusive(2).exclusive_system().after("1"));
         stage.run(&mut world);
         stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
@@ -1190,7 +1246,7 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(0).exclusive_system().label("0").after("0"));
+            .with_exclusive(make_exclusive(0).exclusive_system().label("0").after("0"));
         stage.run(&mut world);
     }
 
@@ -1200,8 +1256,8 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(0).exclusive_system().label("0").after("1"))
-            .with_system(make_exclusive(1).exclusive_system().label("1").after("0"));
+            .with_exclusive(make_exclusive(0).exclusive_system().label("0").after("1"))
+            .with_exclusive(make_exclusive(1).exclusive_system().label("1").after("0"));
         stage.run(&mut world);
     }
 
@@ -1211,9 +1267,9 @@ mod tests {
         let mut world = World::new();
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
-            .with_system(make_exclusive(0).exclusive_system().label("0"))
-            .with_system(make_exclusive(1).exclusive_system().after("0").before("2"))
-            .with_system(make_exclusive(2).exclusive_system().label("2").before("0"));
+            .with_exclusive(make_exclusive(0).exclusive_system().label("0"))
+            .with_exclusive(make_exclusive(1).exclusive_system().after("0").before("2"))
+            .with_exclusive(make_exclusive(2).exclusive_system().label("2").before("0"));
         stage.run(&mut world);
     }
 
@@ -1840,26 +1896,26 @@ mod tests {
         assert_eq!(ambiguities.len(), 2);
 
         let mut stage = SystemStage::parallel()
-            .with_system(empty.exclusive_system().label("0"))
-            .with_system(empty.exclusive_system().label("1").after("0"))
-            .with_system(empty.exclusive_system().label("2").after("1"))
-            .with_system(empty.exclusive_system().label("3").after("2"))
-            .with_system(empty.exclusive_system().label("4").after("3"))
-            .with_system(empty.exclusive_system().label("5").after("4"))
-            .with_system(empty.exclusive_system().label("6").after("5"))
-            .with_system(empty.exclusive_system().label("7").after("6"));
+            .with_exclusive(empty.label("0"))
+            .with_exclusive(empty.label("1").after("0"))
+            .with_exclusive(empty.label("2").after("1"))
+            .with_exclusive(empty.label("3").after("2"))
+            .with_exclusive(empty.label("4").after("3"))
+            .with_exclusive(empty.label("5").after("4"))
+            .with_exclusive(empty.label("6").after("5"))
+            .with_exclusive(empty.label("7").after("6"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         assert_eq!(find_ambiguities(&stage.exclusive_at_start).len(), 0);
 
         let mut stage = SystemStage::parallel()
-            .with_system(empty.exclusive_system().label("0").before("1").before("3"))
-            .with_system(empty.exclusive_system().label("1"))
-            .with_system(empty.exclusive_system().label("2").after("1"))
-            .with_system(empty.exclusive_system().label("3"))
-            .with_system(empty.exclusive_system().label("4").after("3").before("5"))
-            .with_system(empty.exclusive_system().label("5"))
-            .with_system(empty.exclusive_system().label("6").after("2").after("5"));
+            .with_exclusive(empty.label("0").before("1").before("3"))
+            .with_exclusive(empty.label("1"))
+            .with_exclusive(empty.label("2").after("1"))
+            .with_exclusive(empty.label("3"))
+            .with_exclusive(empty.label("4").after("3").before("5"))
+            .with_exclusive(empty.label("5"))
+            .with_exclusive(empty.label("6").after("2").after("5"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_first_labels(&stage.exclusive_at_start);
@@ -1890,13 +1946,13 @@ mod tests {
         assert_eq!(ambiguities.len(), 6);
 
         let mut stage = SystemStage::parallel()
-            .with_system(empty.exclusive_system().label("0").before("1").before("3"))
-            .with_system(empty.exclusive_system().label("1").in_ambiguity_set("a"))
-            .with_system(empty.exclusive_system().label("2").after("1"))
-            .with_system(empty.exclusive_system().label("3").in_ambiguity_set("a"))
-            .with_system(empty.exclusive_system().label("4").after("3").before("5"))
-            .with_system(empty.exclusive_system().label("5").in_ambiguity_set("a"))
-            .with_system(empty.exclusive_system().label("6").after("2").after("5"));
+            .with_exclusive(empty.label("0").before("1").before("3"))
+            .with_exclusive(empty.label("1").in_ambiguity_set("a"))
+            .with_exclusive(empty.label("2").after("1"))
+            .with_exclusive(empty.label("3").in_ambiguity_set("a"))
+            .with_exclusive(empty.label("4").after("3").before("5"))
+            .with_exclusive(empty.label("5").in_ambiguity_set("a"))
+            .with_exclusive(empty.label("6").after("2").after("5"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_first_labels(&stage.exclusive_at_start);
@@ -1919,10 +1975,10 @@ mod tests {
         assert_eq!(ambiguities.len(), 4);
 
         let mut stage = SystemStage::parallel()
-            .with_system(empty.exclusive_system().label("0").in_ambiguity_set("a"))
-            .with_system(empty.exclusive_system().label("1").in_ambiguity_set("a"))
-            .with_system(empty.exclusive_system().label("2").in_ambiguity_set("a"))
-            .with_system(empty.exclusive_system().label("3").in_ambiguity_set("a"));
+            .with_exclusive(empty.label("0").in_ambiguity_set("a"))
+            .with_exclusive(empty.label("1").in_ambiguity_set("a"))
+            .with_exclusive(empty.label("2").in_ambiguity_set("a"))
+            .with_exclusive(empty.label("3").in_ambiguity_set("a"));
         stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_first_labels(&stage.exclusive_at_start);
diff --git a/crates/bevy_ecs/src/schedule/state.rs b/crates/bevy_ecs/src/schedule/state.rs
index c18b6fecdb202..777afc10e53bd 100644
--- a/crates/bevy_ecs/src/schedule/state.rs
+++ b/crates/bevy_ecs/src/schedule/state.rs
@@ -4,7 +4,7 @@ use crate::{
         RunCriteriaDescriptor, RunCriteriaDescriptorCoercion, RunCriteriaLabel, ShouldRun,
         SystemSet,
     },
-    system::{ConfigurableSystem, In, IntoChainSystem, Local, Res, ResMut},
+    system::{ConfigurableSystem, In, IntoChainSystem, Local, Res, ResMut, RunCriteraConfig},
 };
 use std::{any::TypeId, fmt::Debug, hash::Hash};
 use thiserror::Error;
diff --git a/crates/bevy_ecs/src/schedule/system_container.rs b/crates/bevy_ecs/src/schedule/system_container.rs
index 68e493da714b5..db07eddc83d91 100644
--- a/crates/bevy_ecs/src/schedule/system_container.rs
+++ b/crates/bevy_ecs/src/schedule/system_container.rs
@@ -1,11 +1,8 @@
 use crate::{
     component::ComponentId,
     query::Access,
-    schedule::{
-        BoxedAmbiguitySetLabel, BoxedRunCriteriaLabel, BoxedSystemLabel, ExclusiveSystemDescriptor,
-        GraphNode, ParallelSystemDescriptor,
-    },
-    system::{ExclusiveSystem, System},
+    schedule::{BoxedAmbiguitySetLabel, BoxedRunCriteriaLabel, BoxedSystemLabel, GraphNode},
+    system::{BoxedExclusiveSystem, BoxedSystem, ExclusiveSystem, System},
 };
 use std::{borrow::Cow, cell::UnsafeCell};
 
@@ -25,27 +22,19 @@ pub trait SystemContainer: GraphNode<Label = BoxedSystemLabel> {
 }
 
 pub(super) struct ExclusiveSystemContainer {
-    system: Box<dyn ExclusiveSystem>,
+    system: BoxedExclusiveSystem,
     pub(super) run_criteria_index: Option<usize>,
     pub(super) run_criteria_label: Option<BoxedRunCriteriaLabel>,
     dependencies: Vec<usize>,
-    labels: Vec<BoxedSystemLabel>,
-    before: Vec<BoxedSystemLabel>,
-    after: Vec<BoxedSystemLabel>,
-    ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
 }
 
 impl ExclusiveSystemContainer {
-    pub(super) fn from_descriptor(descriptor: ExclusiveSystemDescriptor) -> Self {
+    pub(super) fn from_system(system: BoxedExclusiveSystem) -> Self {
         ExclusiveSystemContainer {
-            system: descriptor.system,
+            system,
             run_criteria_index: None,
             run_criteria_label: None,
             dependencies: Vec::new(),
-            labels: descriptor.labels,
-            before: descriptor.before,
-            after: descriptor.after,
-            ambiguity_sets: descriptor.ambiguity_sets,
         }
     }
 
@@ -62,15 +51,15 @@ impl GraphNode for ExclusiveSystemContainer {
     }
 
     fn labels(&self) -> &[BoxedSystemLabel] {
-        &self.labels
+        &self.system.as_ref().config().labels
     }
 
     fn before(&self) -> &[BoxedSystemLabel] {
-        &self.before
+        &self.system.config().before
     }
 
     fn after(&self) -> &[BoxedSystemLabel] {
-        &self.after
+        &self.system.config().after
     }
 }
 
@@ -97,7 +86,7 @@ impl SystemContainer for ExclusiveSystemContainer {
     }
 
     fn ambiguity_sets(&self) -> &[BoxedAmbiguitySetLabel] {
-        &self.ambiguity_sets
+        &self.system.config().ambiguity_sets
     }
 
     fn component_access(&self) -> Option<&Access<ComponentId>> {
@@ -111,28 +100,20 @@ pub struct ParallelSystemContainer {
     pub(crate) run_criteria_label: Option<BoxedRunCriteriaLabel>,
     pub(crate) should_run: bool,
     dependencies: Vec<usize>,
-    labels: Vec<BoxedSystemLabel>,
-    before: Vec<BoxedSystemLabel>,
-    after: Vec<BoxedSystemLabel>,
-    ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
 }
 
 unsafe impl Send for ParallelSystemContainer {}
 unsafe impl Sync for ParallelSystemContainer {}
 
 impl ParallelSystemContainer {
-    pub(crate) fn from_descriptor(descriptor: ParallelSystemDescriptor) -> Self {
+    pub(crate) fn from_system(system: BoxedSystem) -> Self {
         ParallelSystemContainer {
             // SAFE: it is fine to wrap inner value with UnsafeCell, as it is repr(transparent)
-            system: unsafe { Box::from_raw(Box::into_raw(descriptor.system) as *mut _) },
+            system: unsafe { Box::from_raw(Box::into_raw(system) as *mut _) },
             should_run: false,
             run_criteria_index: None,
             run_criteria_label: None,
             dependencies: Vec::new(),
-            labels: descriptor.labels,
-            before: descriptor.before,
-            after: descriptor.after,
-            ambiguity_sets: descriptor.ambiguity_sets,
         }
     }
 
@@ -173,15 +154,15 @@ impl GraphNode for ParallelSystemContainer {
     }
 
     fn labels(&self) -> &[BoxedSystemLabel] {
-        &self.labels
+        &self.system().config().labels
     }
 
     fn before(&self) -> &[BoxedSystemLabel] {
-        &self.before
+        &self.system().config().before
     }
 
     fn after(&self) -> &[BoxedSystemLabel] {
-        &self.after
+        &self.system().config().after
     }
 }
 
@@ -208,7 +189,7 @@ impl SystemContainer for ParallelSystemContainer {
     }
 
     fn ambiguity_sets(&self) -> &[BoxedAmbiguitySetLabel] {
-        &self.ambiguity_sets
+        &self.system().config().ambiguity_sets
     }
 
     fn component_access(&self) -> Option<&Access<ComponentId>> {
diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
deleted file mode 100644
index 74a3963ca26d7..0000000000000
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ /dev/null
@@ -1,364 +0,0 @@
-use crate::{
-    schedule::{
-        AmbiguitySetLabel, BoxedAmbiguitySetLabel, BoxedSystemLabel, IntoRunCriteria,
-        RunCriteriaDescriptorOrLabel, SystemLabel,
-    },
-    system::{BoxedSystem, ExclusiveSystem, ExclusiveSystemCoerced, ExclusiveSystemFn, IntoSystem},
-};
-
-/// Encapsulates a system and information on when it run in a `SystemStage`.
-///
-/// Systems can be inserted into 4 different groups within the stage:
-/// * Parallel, accepts non-exclusive systems.
-/// * At start, accepts exclusive systems; runs before parallel systems.
-/// * Before commands, accepts exclusive systems; runs after parallel systems, but before their
-/// command buffers are applied.
-/// * At end, accepts exclusive systems; runs after parallel systems' command buffers have
-/// been applied.
-///
-/// Systems can have one or more labels attached to them; other systems in the same group
-/// can then specify that they have to run before or after systems with that label using the
-/// `before` and `after` methods.
-///
-/// # Example
-/// ```
-/// # use bevy_ecs::prelude::*;
-/// # fn do_something() {}
-/// # fn do_the_other_thing() {}
-/// # fn do_something_else() {}
-/// #[derive(SystemLabel, Debug, Clone, PartialEq, Eq, Hash)]
-/// struct Something;
-///
-/// SystemStage::parallel()
-///     .with_system(do_something.label(Something))
-///     .with_system(do_the_other_thing.after(Something))
-///     .with_system(do_something_else.exclusive_system().at_end());
-/// ```
-pub enum SystemDescriptor {
-    Parallel(ParallelSystemDescriptor),
-    Exclusive(ExclusiveSystemDescriptor),
-}
-
-pub trait IntoSystemDescriptor<Params> {
-    fn into_descriptor(self) -> SystemDescriptor;
-}
-
-pub struct SystemLabelMarker;
-
-impl IntoSystemDescriptor<()> for ParallelSystemDescriptor {
-    fn into_descriptor(self) -> SystemDescriptor {
-        SystemDescriptor::Parallel(self)
-    }
-}
-
-impl<Params, S> IntoSystemDescriptor<Params> for S
-where
-    S: IntoSystem<(), (), Params>,
-{
-    fn into_descriptor(self) -> SystemDescriptor {
-        new_parallel_descriptor(Box::new(self.system())).into_descriptor()
-    }
-}
-
-impl IntoSystemDescriptor<()> for SystemDescriptor {
-    fn into_descriptor(self) -> SystemDescriptor {
-        self
-    }
-}
-
-impl IntoSystemDescriptor<()> for BoxedSystem<(), ()> {
-    fn into_descriptor(self) -> SystemDescriptor {
-        new_parallel_descriptor(self).into_descriptor()
-    }
-}
-
-impl IntoSystemDescriptor<()> for ExclusiveSystemDescriptor {
-    fn into_descriptor(self) -> SystemDescriptor {
-        SystemDescriptor::Exclusive(self)
-    }
-}
-
-impl IntoSystemDescriptor<()> for ExclusiveSystemFn {
-    fn into_descriptor(self) -> SystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).into_descriptor()
-    }
-}
-
-impl IntoSystemDescriptor<()> for ExclusiveSystemCoerced {
-    fn into_descriptor(self) -> SystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).into_descriptor()
-    }
-}
-
-/// Encapsulates a parallel system and information on when it runs in a `SystemStage`.
-pub struct ParallelSystemDescriptor {
-    pub(crate) system: BoxedSystem<(), ()>,
-    pub(crate) run_criteria: Option<RunCriteriaDescriptorOrLabel>,
-    pub(crate) labels: Vec<BoxedSystemLabel>,
-    pub(crate) before: Vec<BoxedSystemLabel>,
-    pub(crate) after: Vec<BoxedSystemLabel>,
-    pub(crate) ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
-}
-
-fn new_parallel_descriptor(system: BoxedSystem<(), ()>) -> ParallelSystemDescriptor {
-    ParallelSystemDescriptor {
-        system,
-        run_criteria: None,
-        labels: Vec::new(),
-        before: Vec::new(),
-        after: Vec::new(),
-        ambiguity_sets: Vec::new(),
-    }
-}
-
-pub trait ParallelSystemDescriptorCoercion<Params> {
-    /// Assigns a run criteria to the system. Can be a new descriptor or a label of a
-    /// run criteria defined elsewhere.
-    fn with_run_criteria<Marker>(
-        self,
-        run_criteria: impl IntoRunCriteria<Marker>,
-    ) -> ParallelSystemDescriptor;
-
-    /// Assigns a label to the system; there can be more than one, and it doesn't have to be unique.
-    fn label(self, label: impl SystemLabel) -> ParallelSystemDescriptor;
-
-    /// Specifies that the system should run before systems with the given label.
-    fn before(self, label: impl SystemLabel) -> ParallelSystemDescriptor;
-
-    /// Specifies that the system should run after systems with the given label.
-    fn after(self, label: impl SystemLabel) -> ParallelSystemDescriptor;
-
-    /// Specifies that the system is exempt from execution order ambiguity detection
-    /// with other systems in this set.
-    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor;
-}
-
-impl ParallelSystemDescriptorCoercion<()> for ParallelSystemDescriptor {
-    fn with_run_criteria<Marker>(
-        mut self,
-        run_criteria: impl IntoRunCriteria<Marker>,
-    ) -> ParallelSystemDescriptor {
-        self.run_criteria = Some(run_criteria.into());
-        self
-    }
-
-    fn label(mut self, label: impl SystemLabel) -> ParallelSystemDescriptor {
-        self.labels.push(Box::new(label));
-        self
-    }
-
-    fn before(mut self, label: impl SystemLabel) -> ParallelSystemDescriptor {
-        self.before.push(Box::new(label));
-        self
-    }
-
-    fn after(mut self, label: impl SystemLabel) -> ParallelSystemDescriptor {
-        self.after.push(Box::new(label));
-        self
-    }
-
-    fn in_ambiguity_set(mut self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
-        self.ambiguity_sets.push(Box::new(set));
-        self
-    }
-}
-
-impl<S, Params> ParallelSystemDescriptorCoercion<Params> for S
-where
-    S: IntoSystem<(), (), Params>,
-{
-    fn with_run_criteria<Marker>(
-        self,
-        run_criteria: impl IntoRunCriteria<Marker>,
-    ) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(Box::new(self.system())).with_run_criteria(run_criteria)
-    }
-
-    fn label(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(Box::new(self.system())).label(label)
-    }
-
-    fn before(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(Box::new(self.system())).before(label)
-    }
-
-    fn after(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(Box::new(self.system())).after(label)
-    }
-
-    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(Box::new(self.system())).in_ambiguity_set(set)
-    }
-}
-
-impl ParallelSystemDescriptorCoercion<()> for BoxedSystem<(), ()> {
-    fn with_run_criteria<Marker>(
-        self,
-        run_criteria: impl IntoRunCriteria<Marker>,
-    ) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(self).with_run_criteria(run_criteria)
-    }
-
-    fn label(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(self).label(label)
-    }
-
-    fn before(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(self).before(label)
-    }
-
-    fn after(self, label: impl SystemLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(self).after(label)
-    }
-
-    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ParallelSystemDescriptor {
-        new_parallel_descriptor(self).in_ambiguity_set(set)
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-pub(crate) enum InsertionPoint {
-    AtStart,
-    BeforeCommands,
-    AtEnd,
-}
-
-/// Encapsulates an exclusive system and information on when it runs in a `SystemStage`.
-pub struct ExclusiveSystemDescriptor {
-    pub(crate) system: Box<dyn ExclusiveSystem>,
-    pub(crate) run_criteria: Option<RunCriteriaDescriptorOrLabel>,
-    pub(crate) labels: Vec<BoxedSystemLabel>,
-    pub(crate) before: Vec<BoxedSystemLabel>,
-    pub(crate) after: Vec<BoxedSystemLabel>,
-    pub(crate) ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
-    pub(crate) insertion_point: InsertionPoint,
-}
-
-fn new_exclusive_descriptor(system: Box<dyn ExclusiveSystem>) -> ExclusiveSystemDescriptor {
-    ExclusiveSystemDescriptor {
-        system,
-        run_criteria: None,
-        labels: Vec::new(),
-        before: Vec::new(),
-        after: Vec::new(),
-        ambiguity_sets: Vec::new(),
-        insertion_point: InsertionPoint::AtStart,
-    }
-}
-
-pub trait ExclusiveSystemDescriptorCoercion {
-    /// Assigns a run criteria to the system. Can be a new descriptor or a label of a
-    /// run criteria defined elsewhere.
-    fn with_run_criteria<Marker>(
-        self,
-        run_criteria: impl IntoRunCriteria<Marker>,
-    ) -> ExclusiveSystemDescriptor;
-
-    /// Assigns a label to the system; there can be more than one, and it doesn't have to be unique.
-    fn label(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor;
-
-    /// Specifies that the system should run before systems with the given label.
-    fn before(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor;
-
-    /// Specifies that the system should run after systems with the given label.
-    fn after(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor;
-
-    /// Specifies that the system is exempt from execution order ambiguity detection
-    /// with other systems in this set.
-    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ExclusiveSystemDescriptor;
-
-    /// Specifies that the system should run with other exclusive systems at the start of stage.
-    fn at_start(self) -> ExclusiveSystemDescriptor;
-
-    /// Specifies that the system should run with other exclusive systems after the parallel
-    /// systems and before command buffer application.
-    fn before_commands(self) -> ExclusiveSystemDescriptor;
-
-    /// Specifies that the system should run with other exclusive systems at the end of stage.
-    fn at_end(self) -> ExclusiveSystemDescriptor;
-}
-
-impl ExclusiveSystemDescriptorCoercion for ExclusiveSystemDescriptor {
-    fn with_run_criteria<Marker>(
-        mut self,
-        run_criteria: impl IntoRunCriteria<Marker>,
-    ) -> ExclusiveSystemDescriptor {
-        self.run_criteria = Some(run_criteria.into());
-        self
-    }
-
-    fn label(mut self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
-        self.labels.push(Box::new(label));
-        self
-    }
-
-    fn before(mut self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
-        self.before.push(Box::new(label));
-        self
-    }
-
-    fn after(mut self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
-        self.after.push(Box::new(label));
-        self
-    }
-
-    fn in_ambiguity_set(mut self, set: impl AmbiguitySetLabel) -> ExclusiveSystemDescriptor {
-        self.ambiguity_sets.push(Box::new(set));
-        self
-    }
-
-    fn at_start(mut self) -> ExclusiveSystemDescriptor {
-        self.insertion_point = InsertionPoint::AtStart;
-        self
-    }
-
-    fn before_commands(mut self) -> ExclusiveSystemDescriptor {
-        self.insertion_point = InsertionPoint::BeforeCommands;
-        self
-    }
-
-    fn at_end(mut self) -> ExclusiveSystemDescriptor {
-        self.insertion_point = InsertionPoint::AtEnd;
-        self
-    }
-}
-
-impl<T> ExclusiveSystemDescriptorCoercion for T
-where
-    T: ExclusiveSystem + 'static,
-{
-    fn with_run_criteria<Marker>(
-        self,
-        run_criteria: impl IntoRunCriteria<Marker>,
-    ) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).with_run_criteria(run_criteria)
-    }
-
-    fn label(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).label(label)
-    }
-
-    fn before(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).before(label)
-    }
-
-    fn after(self, label: impl SystemLabel) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).after(label)
-    }
-
-    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).in_ambiguity_set(set)
-    }
-
-    fn at_start(self) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).at_start()
-    }
-
-    fn before_commands(self) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).before_commands()
-    }
-
-    fn at_end(self) -> ExclusiveSystemDescriptor {
-        new_exclusive_descriptor(Box::new(self)).at_end()
-    }
-}
diff --git a/crates/bevy_ecs/src/schedule/system_set.rs b/crates/bevy_ecs/src/schedule/system_set.rs
index 2fe7fc10c786f..5c24c02be1c93 100644
--- a/crates/bevy_ecs/src/schedule/system_set.rs
+++ b/crates/bevy_ecs/src/schedule/system_set.rs
@@ -1,35 +1,17 @@
 use crate::{
     component::Component,
-    schedule::{
-        AmbiguitySetLabel, BoxedAmbiguitySetLabel, BoxedSystemLabel, IntoRunCriteria,
-        RunCriteriaDescriptorOrLabel, State, SystemDescriptor, SystemLabel,
-    },
+    prelude::{ExclusiveSystem, IntoExclusiveSystem, IntoSystem},
+    schedule::{RunCriteriaDescriptorOrLabel, State},
+    system::{BoxedExclusiveSystem, BoxedSystem, RunCriteraConfig, SystemConfig},
 };
 use std::{fmt::Debug, hash::Hash};
 
-use super::IntoSystemDescriptor;
-
 /// A builder for describing several systems at the same time.
+#[derive(Default)]
 pub struct SystemSet {
-    pub(crate) systems: Vec<SystemDescriptor>,
-    pub(crate) run_criteria: Option<RunCriteriaDescriptorOrLabel>,
-    pub(crate) labels: Vec<BoxedSystemLabel>,
-    pub(crate) before: Vec<BoxedSystemLabel>,
-    pub(crate) after: Vec<BoxedSystemLabel>,
-    pub(crate) ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
-}
-
-impl Default for SystemSet {
-    fn default() -> SystemSet {
-        SystemSet {
-            systems: Vec::new(),
-            run_criteria: None,
-            labels: Vec::new(),
-            before: Vec::new(),
-            after: Vec::new(),
-            ambiguity_sets: Vec::new(),
-        }
-    }
+    pub systems: Vec<BoxedSystem>,
+    pub exclusive_systems: Vec<BoxedExclusiveSystem>,
+    pub(crate) config: SystemConfig,
 }
 
 impl SystemSet {
@@ -86,65 +68,78 @@ impl SystemSet {
         Self::new().with_run_criteria(State::<T>::on_resume(s))
     }
 
-    pub fn in_ambiguity_set(mut self, set: impl AmbiguitySetLabel) -> Self {
-        self.ambiguity_sets.push(Box::new(set));
-        self
-    }
-
-    pub fn with_system<Params>(mut self, system: impl IntoSystemDescriptor<Params>) -> Self {
-        self.systems.push(system.into_descriptor());
-        self
-    }
-
-    pub fn with_run_criteria<Marker>(mut self, run_criteria: impl IntoRunCriteria<Marker>) -> Self {
-        self.run_criteria = Some(run_criteria.into());
+    pub fn with_system<Params>(mut self, system: impl IntoSystem<(), (), Params>) -> Self {
+        self.systems.push(Box::new(system.system()));
         self
     }
 
-    pub fn label(mut self, label: impl SystemLabel) -> Self {
-        self.labels.push(Box::new(label));
-        self
-    }
-
-    pub fn before(mut self, label: impl SystemLabel) -> Self {
-        self.before.push(Box::new(label));
-        self
-    }
-
-    pub fn after(mut self, label: impl SystemLabel) -> Self {
-        self.after.push(Box::new(label));
+    pub fn with_exclusive<Params, SystemType>(
+        mut self,
+        system: impl IntoExclusiveSystem<Params, SystemType>,
+    ) -> Self
+    where
+        SystemType: ExclusiveSystem,
+    {
+        self.exclusive_systems
+            .push(Box::new(system.exclusive_system()));
         self
     }
 
-    pub(crate) fn bake(self) -> (Option<RunCriteriaDescriptorOrLabel>, Vec<SystemDescriptor>) {
+    pub(crate) fn bake(
+        self,
+    ) -> (
+        Option<RunCriteriaDescriptorOrLabel>,
+        Vec<BoxedSystem>,
+        Vec<BoxedExclusiveSystem>,
+    ) {
         let SystemSet {
             mut systems,
-            run_criteria,
-            labels,
-            before,
-            after,
-            ambiguity_sets,
+            mut exclusive_systems,
+            config,
         } = self;
-        for descriptor in &mut systems {
-            match descriptor {
-                SystemDescriptor::Parallel(descriptor) => {
-                    descriptor.labels.extend(labels.iter().cloned());
-                    descriptor.before.extend(before.iter().cloned());
-                    descriptor.after.extend(after.iter().cloned());
-                    descriptor
-                        .ambiguity_sets
-                        .extend(ambiguity_sets.iter().cloned());
-                }
-                SystemDescriptor::Exclusive(descriptor) => {
-                    descriptor.labels.extend(labels.iter().cloned());
-                    descriptor.before.extend(before.iter().cloned());
-                    descriptor.after.extend(after.iter().cloned());
-                    descriptor
-                        .ambiguity_sets
-                        .extend(ambiguity_sets.iter().cloned());
-                }
-            }
+        for system in &mut systems {
+            system
+                .config_mut()
+                .labels
+                .extend(config.labels.iter().cloned());
+            system
+                .config_mut()
+                .before
+                .extend(config.before.iter().cloned());
+            system
+                .config_mut()
+                .after
+                .extend(config.after.iter().cloned());
+            system
+                .config_mut()
+                .ambiguity_sets
+                .extend(config.ambiguity_sets.iter().cloned());
+        }
+        for system in &mut exclusive_systems {
+            system
+                .config_mut()
+                .labels
+                .extend(config.labels.iter().cloned());
+            system
+                .config_mut()
+                .before
+                .extend(config.before.iter().cloned());
+            system
+                .config_mut()
+                .after
+                .extend(config.after.iter().cloned());
+            system
+                .config_mut()
+                .ambiguity_sets
+                .extend(config.ambiguity_sets.iter().cloned());
         }
-        (run_criteria, systems)
+        (config.run_criteria, systems, exclusive_systems)
+    }
+
+    pub fn config(&self) -> &SystemConfig {
+        &self.config
+    }
+    pub fn config_mut(&mut self) -> &mut SystemConfig {
+        &mut self.config
     }
 }
diff --git a/crates/bevy_ecs/src/system/config/ambiguity_config.rs b/crates/bevy_ecs/src/system/config/ambiguity_config.rs
new file mode 100644
index 0000000000000..9f496a1f044f2
--- /dev/null
+++ b/crates/bevy_ecs/src/system/config/ambiguity_config.rs
@@ -0,0 +1,49 @@
+use crate::{
+    prelude::{ExclusiveSystem, IntoExclusiveSystem, IntoSystem, System},
+    schedule::{AmbiguitySetLabel, SystemSet},
+    system::{AlreadyWasSystem, ExclusiveSystemCoerced, ExclusiveSystemFn},
+};
+
+use super::{ParallelSystemKind, SystemSetKind};
+
+/// Allows configuration of a [System](System)'s [ambiguity set](https://docs.rs/bevy/0.5.0/bevy/ecs/schedule/struct.ReportExecutionOrderAmbiguities.html).
+pub trait AmbiguityConfig<Params, Configured> {
+    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> Configured;
+}
+
+impl<T, Params, Configured> AmbiguityConfig<(ParallelSystemKind, Params), Configured> for T
+where
+    T: IntoSystem<(), (), Params, System = Configured>,
+    Configured: System + IntoSystem<(), (), AlreadyWasSystem>,
+{
+    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> Configured {
+        let mut system = self.system();
+        system.config_mut().add_ambiguity_set(set);
+        system
+    }
+}
+
+impl AmbiguityConfig<SystemSetKind, SystemSet> for SystemSet {
+    fn in_ambiguity_set(mut self, set: impl AmbiguitySetLabel) -> Self {
+        self.config_mut().add_ambiguity_set(set);
+        self
+    }
+}
+
+impl<Params> AmbiguityConfig<Params, ExclusiveSystemCoerced> for ExclusiveSystemCoerced {
+    fn in_ambiguity_set(mut self, set: impl AmbiguitySetLabel) -> Self {
+        self.config_mut().add_ambiguity_set(set);
+        self
+    }
+}
+
+impl<T, Params> AmbiguityConfig<Params, ExclusiveSystemFn> for T
+where
+    T: IntoExclusiveSystem<Params, ExclusiveSystemFn>,
+{
+    fn in_ambiguity_set(self, set: impl AmbiguitySetLabel) -> ExclusiveSystemFn {
+        let mut system = self.exclusive_system();
+        system.config_mut().add_ambiguity_set(set);
+        system
+    }
+}
diff --git a/crates/bevy_ecs/src/system/config/exclusive_config.rs b/crates/bevy_ecs/src/system/config/exclusive_config.rs
new file mode 100644
index 0000000000000..1c03b0a71c789
--- /dev/null
+++ b/crates/bevy_ecs/src/system/config/exclusive_config.rs
@@ -0,0 +1,65 @@
+use crate::{
+    prelude::{ExclusiveSystem, IntoExclusiveSystem},
+    system::{ExclusiveSystemCoerced, ExclusiveSystemFn, InsertionPoint},
+};
+
+/// Allows configuration of an [ExclusiveSystem](ExclusiveSystem) to run at a specific [InsertionPoint](InsertionPoint).
+pub trait ExclusiveConfig<Params, Configured> {
+    fn at_start(self) -> Configured;
+    fn before_commands(self) -> Configured;
+    fn at_end(self) -> Configured;
+}
+
+impl<T, Params> ExclusiveConfig<Params, ExclusiveSystemCoerced> for T
+where
+    T: IntoExclusiveSystem<Params, ExclusiveSystemCoerced>,
+{
+    fn at_start(self) -> ExclusiveSystemCoerced {
+        let mut system = self.exclusive_system();
+        system
+            .config_mut()
+            .set_insertion_point(InsertionPoint::AtStart);
+        system
+    }
+    fn before_commands(self) -> ExclusiveSystemCoerced {
+        let mut system = self.exclusive_system();
+        system
+            .config_mut()
+            .set_insertion_point(InsertionPoint::BeforeCommands);
+        system
+    }
+    fn at_end(self) -> ExclusiveSystemCoerced {
+        let mut system = self.exclusive_system();
+        system
+            .config_mut()
+            .set_insertion_point(InsertionPoint::AtEnd);
+        system
+    }
+}
+
+impl<T, Params> ExclusiveConfig<Params, ExclusiveSystemFn> for T
+where
+    T: IntoExclusiveSystem<Params, ExclusiveSystemFn>,
+{
+    fn at_start(self) -> ExclusiveSystemFn {
+        let mut system = self.exclusive_system();
+        system
+            .config_mut()
+            .set_insertion_point(InsertionPoint::AtStart);
+        system
+    }
+    fn before_commands(self) -> ExclusiveSystemFn {
+        let mut system = self.exclusive_system();
+        system
+            .config_mut()
+            .set_insertion_point(InsertionPoint::BeforeCommands);
+        system
+    }
+    fn at_end(self) -> ExclusiveSystemFn {
+        let mut system = self.exclusive_system();
+        system
+            .config_mut()
+            .set_insertion_point(InsertionPoint::AtEnd);
+        system
+    }
+}
diff --git a/crates/bevy_ecs/src/system/config/mod.rs b/crates/bevy_ecs/src/system/config/mod.rs
new file mode 100644
index 0000000000000..e9a2d86476908
--- /dev/null
+++ b/crates/bevy_ecs/src/system/config/mod.rs
@@ -0,0 +1,15 @@
+mod ambiguity_config;
+mod exclusive_config;
+mod run_criteria_config;
+mod schedule_config;
+mod stage_config;
+mod startup_config;
+mod system_config;
+
+pub use ambiguity_config::*;
+pub use exclusive_config::*;
+pub use run_criteria_config::*;
+pub use schedule_config::*;
+pub use stage_config::*;
+pub use startup_config::*;
+pub use system_config::*;
diff --git a/crates/bevy_ecs/src/system/config/run_criteria_config.rs b/crates/bevy_ecs/src/system/config/run_criteria_config.rs
new file mode 100644
index 0000000000000..9fc614cbb206b
--- /dev/null
+++ b/crates/bevy_ecs/src/system/config/run_criteria_config.rs
@@ -0,0 +1,52 @@
+use crate::{
+    prelude::{ExclusiveSystem, IntoExclusiveSystem, IntoSystem, System},
+    schedule::{IntoRunCriteria, SystemSet},
+    system::{AlreadyWasSystem, ExclusiveSystemCoerced, ExclusiveSystemFn},
+};
+
+use super::{ParallelSystemKind, SystemSetKind};
+
+/// Allows configuration of a [System](System) with a specific [RunCriteriaDescriptorOrLabel](crate::schedule::RunCriteriaDescriptorOrLabel).
+pub trait RunCriteraConfig<Params, Configured> {
+    fn with_run_criteria<Marker>(self, run_criteria: impl IntoRunCriteria<Marker>) -> Configured;
+}
+
+impl<T, Params, Configured> RunCriteraConfig<(ParallelSystemKind, Params), Configured> for T
+where
+    T: IntoSystem<(), (), Params, System = Configured>,
+    Configured: System + IntoSystem<(), (), AlreadyWasSystem>,
+{
+    fn with_run_criteria<Marker>(self, run_criteria: impl IntoRunCriteria<Marker>) -> Configured {
+        let mut system = self.system();
+        system.config_mut().set_run_criteria(run_criteria.into());
+        system
+    }
+}
+
+impl RunCriteraConfig<SystemSetKind, SystemSet> for SystemSet {
+    fn with_run_criteria<Marker>(mut self, run_criteria: impl IntoRunCriteria<Marker>) -> Self {
+        self.config_mut().set_run_criteria(run_criteria.into());
+        self
+    }
+}
+
+impl<Params> RunCriteraConfig<Params, ExclusiveSystemCoerced> for ExclusiveSystemCoerced {
+    fn with_run_criteria<Marker>(mut self, run_criteria: impl IntoRunCriteria<Marker>) -> Self {
+        self.config_mut().set_run_criteria(run_criteria.into());
+        self
+    }
+}
+
+impl<T, Params> RunCriteraConfig<Params, ExclusiveSystemFn> for T
+where
+    T: IntoExclusiveSystem<Params, ExclusiveSystemFn>,
+{
+    fn with_run_criteria<Marker>(
+        self,
+        run_criteria: impl IntoRunCriteria<Marker>,
+    ) -> ExclusiveSystemFn {
+        let mut system = self.exclusive_system();
+        system.config_mut().set_run_criteria(run_criteria.into());
+        system
+    }
+}
diff --git a/crates/bevy_ecs/src/system/config/schedule_config.rs b/crates/bevy_ecs/src/system/config/schedule_config.rs
new file mode 100644
index 0000000000000..b21cee92b0ac5
--- /dev/null
+++ b/crates/bevy_ecs/src/system/config/schedule_config.rs
@@ -0,0 +1,87 @@
+use crate::{
+    prelude::{ExclusiveSystem, IntoExclusiveSystem, IntoSystem, System},
+    schedule::{SystemLabel, SystemSet},
+    system::{AlreadyWasSystem, ExclusiveSystemCoerced, ExclusiveSystemFn},
+};
+
+use super::{ParallelSystemKind, SystemSetKind};
+
+/// Allows configuration of a [System](System) to run in order with other Systems in the same [Stage](crate::schedule::Stage).
+pub trait ScheduleConfig<Params, Configured> {
+    fn label(self, label: impl SystemLabel) -> Configured;
+    fn before(self, label: impl SystemLabel) -> Configured;
+    fn after(self, label: impl SystemLabel) -> Configured;
+}
+
+impl<T, Params, Configured> ScheduleConfig<(ParallelSystemKind, Params), Configured> for T
+where
+    T: IntoSystem<(), (), Params, System = Configured>,
+    Configured: System + IntoSystem<(), (), AlreadyWasSystem>,
+{
+    fn label(self, label: impl SystemLabel) -> Configured {
+        let mut system = self.system();
+        system.config_mut().add_label(label);
+        system
+    }
+    fn before(self, label: impl SystemLabel) -> Configured {
+        let mut system = self.system();
+        system.config_mut().add_before(label);
+        system
+    }
+    fn after(self, label: impl SystemLabel) -> Configured {
+        let mut system = self.system();
+        system.config_mut().add_after(label);
+        system
+    }
+}
+
+impl ScheduleConfig<SystemSetKind, SystemSet> for SystemSet {
+    fn label(mut self, label: impl SystemLabel) -> Self {
+        self.config_mut().add_label(label);
+        self
+    }
+    fn before(mut self, label: impl SystemLabel) -> Self {
+        self.config_mut().add_before(label);
+        self
+    }
+    fn after(mut self, label: impl SystemLabel) -> Self {
+        self.config_mut().add_after(label);
+        self
+    }
+}
+
+impl<Params> ScheduleConfig<Params, ExclusiveSystemCoerced> for ExclusiveSystemCoerced {
+    fn label(mut self, label: impl SystemLabel) -> Self {
+        self.config_mut().add_label(label);
+        self
+    }
+    fn before(mut self, label: impl SystemLabel) -> Self {
+        self.config_mut().add_before(label);
+        self
+    }
+    fn after(mut self, label: impl SystemLabel) -> Self {
+        self.config_mut().add_after(label);
+        self
+    }
+}
+
+impl<T, Params> ScheduleConfig<Params, ExclusiveSystemFn> for T
+where
+    T: IntoExclusiveSystem<Params, ExclusiveSystemFn>,
+{
+    fn label(self, label: impl SystemLabel) -> ExclusiveSystemFn {
+        let mut system = self.exclusive_system();
+        system.config_mut().add_label(label);
+        system
+    }
+    fn before(self, label: impl SystemLabel) -> ExclusiveSystemFn {
+        let mut system = self.exclusive_system();
+        system.config_mut().add_before(label);
+        system
+    }
+    fn after(self, label: impl SystemLabel) -> ExclusiveSystemFn {
+        let mut system = self.exclusive_system();
+        system.config_mut().add_after(label);
+        system
+    }
+}
diff --git a/crates/bevy_ecs/src/system/config/stage_config.rs b/crates/bevy_ecs/src/system/config/stage_config.rs
new file mode 100644
index 0000000000000..8154bf10445ac
--- /dev/null
+++ b/crates/bevy_ecs/src/system/config/stage_config.rs
@@ -0,0 +1,49 @@
+use crate::{
+    prelude::{ExclusiveSystem, IntoExclusiveSystem, IntoSystem, System},
+    schedule::{StageLabel, SystemSet},
+    system::{AlreadyWasSystem, ExclusiveSystemCoerced, ExclusiveSystemFn},
+};
+
+use super::{ParallelSystemKind, SystemSetKind};
+
+/// Allows configuration of a [System](System) to run in a specific [Stage](crate::schedule::Stage).
+pub trait StageConfig<Params, Configured> {
+    fn stage(self, label: impl StageLabel) -> Configured;
+}
+
+impl<T, Params, Configured> StageConfig<(ParallelSystemKind, Params), Configured> for T
+where
+    T: IntoSystem<(), (), Params, System = Configured>,
+    Configured: System + IntoSystem<(), (), AlreadyWasSystem>,
+{
+    fn stage(self, label: impl StageLabel) -> Configured {
+        let mut system = self.system();
+        system.config_mut().set_stage(label);
+        system
+    }
+}
+
+impl StageConfig<SystemSetKind, SystemSet> for SystemSet {
+    fn stage(mut self, label: impl StageLabel) -> SystemSet {
+        self.config_mut().set_stage(label);
+        self
+    }
+}
+
+impl<Params> StageConfig<Params, ExclusiveSystemCoerced> for ExclusiveSystemCoerced {
+    fn stage(mut self, label: impl StageLabel) -> ExclusiveSystemCoerced {
+        self.config_mut().set_stage(label);
+        self
+    }
+}
+
+impl<T, Params> StageConfig<Params, ExclusiveSystemFn> for T
+where
+    T: IntoExclusiveSystem<Params, ExclusiveSystemFn>,
+{
+    fn stage(self, label: impl StageLabel) -> ExclusiveSystemFn {
+        let mut system = self.exclusive_system();
+        system.config_mut().set_stage(label);
+        system
+    }
+}
diff --git a/crates/bevy_ecs/src/system/config/startup_config.rs b/crates/bevy_ecs/src/system/config/startup_config.rs
new file mode 100644
index 0000000000000..01c06a4a9a286
--- /dev/null
+++ b/crates/bevy_ecs/src/system/config/startup_config.rs
@@ -0,0 +1,49 @@
+use crate::{
+    prelude::{ExclusiveSystem, IntoExclusiveSystem, IntoSystem, System},
+    schedule::SystemSet,
+    system::{AlreadyWasSystem, ExclusiveSystemCoerced, ExclusiveSystemFn},
+};
+
+use super::{ParallelSystemKind, SystemSetKind};
+
+/// Allows configuration of a [System](super::System) to run at startup, optionally in a given [Stage](crate::schedule::Stage).
+pub trait StartupConfig<Params, Configured> {
+    fn startup(self) -> Configured;
+}
+
+impl<T, Params, Configured> StartupConfig<(ParallelSystemKind, Params), Configured> for T
+where
+    T: IntoSystem<(), (), Params, System = Configured>,
+    Configured: System + IntoSystem<(), (), AlreadyWasSystem>,
+{
+    fn startup(self) -> Configured {
+        let mut system = self.system();
+        system.config_mut().startup();
+        system
+    }
+}
+
+impl StartupConfig<SystemSetKind, SystemSet> for SystemSet {
+    fn startup(mut self) -> SystemSet {
+        self.config_mut().startup();
+        self
+    }
+}
+
+impl<Params> StartupConfig<Params, ExclusiveSystemCoerced> for ExclusiveSystemCoerced {
+    fn startup(mut self) -> ExclusiveSystemCoerced {
+        self.config_mut().startup();
+        self
+    }
+}
+
+impl<T, Params> StartupConfig<Params, ExclusiveSystemFn> for T
+where
+    T: IntoExclusiveSystem<Params, ExclusiveSystemFn>,
+{
+    fn startup(self) -> ExclusiveSystemFn {
+        let mut system = self.exclusive_system();
+        system.config_mut().startup();
+        system
+    }
+}
diff --git a/crates/bevy_ecs/src/system/config/system_config.rs b/crates/bevy_ecs/src/system/config/system_config.rs
new file mode 100644
index 0000000000000..4842ff3d55822
--- /dev/null
+++ b/crates/bevy_ecs/src/system/config/system_config.rs
@@ -0,0 +1,46 @@
+use crate::{schedule::*, system::InsertionPoint};
+
+/// Controls when and how a [`System`] is run
+///
+/// The traits in this [module](super) are used to update these settings.
+#[derive(Default)]
+pub struct SystemConfig {
+    pub labels: Vec<BoxedSystemLabel>,
+    pub before: Vec<BoxedSystemLabel>,
+    pub after: Vec<BoxedSystemLabel>,
+    pub stage: Option<BoxedStageLabel>,
+    pub ambiguity_sets: Vec<BoxedAmbiguitySetLabel>,
+    pub run_criteria: Option<RunCriteriaDescriptorOrLabel>,
+    pub insertion_point: InsertionPoint,
+    pub startup: bool,
+}
+
+impl SystemConfig {
+    pub(crate) fn add_label(&mut self, label: impl SystemLabel) {
+        self.labels.push(Box::new(label));
+    }
+    pub(crate) fn add_before(&mut self, label: impl SystemLabel) {
+        self.before.push(Box::new(label));
+    }
+    pub(crate) fn add_after(&mut self, label: impl SystemLabel) {
+        self.after.push(Box::new(label));
+    }
+    pub(crate) fn set_stage(&mut self, label: impl StageLabel) {
+        self.stage = Some(Box::new(label));
+    }
+    pub(crate) fn add_ambiguity_set(&mut self, set: impl AmbiguitySetLabel) {
+        self.ambiguity_sets.push(Box::new(set));
+    }
+    pub(crate) fn set_run_criteria(&mut self, criteria: RunCriteriaDescriptorOrLabel) {
+        self.run_criteria = Some(criteria);
+    }
+    pub(crate) fn startup(&mut self) {
+        self.startup = true;
+    }
+    pub(crate) fn set_insertion_point(&mut self, insertion_point: InsertionPoint) {
+        self.insertion_point = insertion_point;
+    }
+}
+
+pub struct ParallelSystemKind;
+pub struct SystemSetKind;
diff --git a/crates/bevy_ecs/src/system/exclusive_system.rs b/crates/bevy_ecs/src/system/exclusive_system.rs
index 7050355b6b8fe..e463432509ab3 100644
--- a/crates/bevy_ecs/src/system/exclusive_system.rs
+++ b/crates/bevy_ecs/src/system/exclusive_system.rs
@@ -5,6 +5,8 @@ use crate::{
 };
 use std::borrow::Cow;
 
+use super::SystemConfig;
+
 pub trait ExclusiveSystem: Send + Sync + 'static {
     fn name(&self) -> Cow<'static, str>;
 
@@ -15,6 +17,27 @@ pub trait ExclusiveSystem: Send + Sync + 'static {
     fn initialize(&mut self, world: &mut World);
 
     fn check_change_tick(&mut self, change_tick: u32);
+
+    fn config(&self) -> &SystemConfig;
+
+    fn config_mut(&mut self) -> &mut SystemConfig;
+}
+
+trait ConfigExclusiveSystem {}
+
+pub type BoxedExclusiveSystem = Box<dyn ExclusiveSystem>;
+
+#[derive(Debug, Clone, Copy)]
+pub enum InsertionPoint {
+    AtStart,
+    BeforeCommands,
+    AtEnd,
+}
+
+impl Default for InsertionPoint {
+    fn default() -> Self {
+        Self::AtStart
+    }
 }
 
 pub struct ExclusiveSystemFn {
@@ -22,6 +45,7 @@ pub struct ExclusiveSystemFn {
     name: Cow<'static, str>,
     id: SystemId,
     last_change_tick: u32,
+    config: SystemConfig,
 }
 
 impl ExclusiveSystem for ExclusiveSystemFn {
@@ -53,12 +77,28 @@ impl ExclusiveSystem for ExclusiveSystemFn {
     fn check_change_tick(&mut self, change_tick: u32) {
         check_system_change_tick(&mut self.last_change_tick, change_tick, self.name.as_ref());
     }
+
+    fn config(&self) -> &SystemConfig {
+        &self.config
+    }
+
+    fn config_mut(&mut self) -> &mut SystemConfig {
+        &mut self.config
+    }
 }
 
 pub trait IntoExclusiveSystem<Params, SystemType> {
     fn exclusive_system(self) -> SystemType;
 }
 
+pub struct AlreadyWasExclusiveSystem;
+
+impl<Sys: ExclusiveSystem> IntoExclusiveSystem<AlreadyWasExclusiveSystem, Sys> for Sys {
+    fn exclusive_system(self) -> Sys {
+        self
+    }
+}
+
 impl<F> IntoExclusiveSystem<&mut World, ExclusiveSystemFn> for F
 where
     F: FnMut(&mut World) + Send + Sync + 'static,
@@ -69,6 +109,7 @@ where
             name: core::any::type_name::<F>().into(),
             id: SystemId::new(),
             last_change_tick: 0,
+            config: SystemConfig::default(),
         }
     }
 }
@@ -108,6 +149,14 @@ impl ExclusiveSystem for ExclusiveSystemCoerced {
     fn check_change_tick(&mut self, change_tick: u32) {
         self.system.check_change_tick(change_tick);
     }
+
+    fn config(&self) -> &SystemConfig {
+        self.system.config()
+    }
+
+    fn config_mut(&mut self) -> &mut SystemConfig {
+        self.system.config_mut()
+    }
 }
 
 impl<S, Params> IntoExclusiveSystem<Params, ExclusiveSystemCoerced> for S
@@ -128,7 +177,7 @@ mod tests {
         entity::Entity,
         query::With,
         schedule::{Stage, SystemStage},
-        system::{Commands, IntoExclusiveSystem, Query, ResMut},
+        system::{Commands, Query, ResMut},
         world::World,
     };
     #[test]
@@ -153,7 +202,7 @@ mod tests {
         stage.run(&mut world);
         assert_eq!(*world.get_resource::<usize>().unwrap(), 1);
 
-        let mut stage = SystemStage::parallel().with_system(removal.exclusive_system());
+        let mut stage = SystemStage::parallel().with_exclusive(removal);
         world.spawn().insert(0.0f32);
         world.insert_resource(0usize);
         stage.run(&mut world);
@@ -177,7 +226,7 @@ mod tests {
         world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(spawn_entity)
-            .with_system(count_entities.exclusive_system());
+            .with_exclusive(count_entities);
         stage.run(&mut world);
         stage.run(&mut world);
         assert_eq!(*world.get_resource::<Vec<usize>>().unwrap(), vec![0, 1]);
diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index c37653c078567..1f4e11ec33cd3 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -11,10 +11,13 @@ use crate::{
 use bevy_ecs_macros::all_tuples;
 use std::{borrow::Cow, marker::PhantomData};
 
+use super::SystemConfig;
+
 /// The metadata of a [`System`].
 pub struct SystemMeta {
     pub(crate) id: SystemId,
     pub(crate) name: Cow<'static, str>,
+    pub(crate) config: SystemConfig,
     pub(crate) component_access_set: FilteredAccessSet<ComponentId>,
     pub(crate) archetype_component_access: Access<ArchetypeComponentId>,
     // NOTE: this must be kept private. making a SystemMeta non-send is irreversible to prevent
@@ -27,6 +30,7 @@ impl SystemMeta {
     fn new<T>() -> Self {
         Self {
             name: std::any::type_name::<T>().into(),
+            config: SystemConfig::default(),
             archetype_component_access: Access::default(),
             component_access_set: FilteredAccessSet::default(),
             is_send: true,
@@ -403,8 +407,15 @@ where
             self.system_meta.name.as_ref(),
         );
     }
-}
 
+    fn config(&self) -> &SystemConfig {
+        &self.system_meta.config
+    }
+
+    fn config_mut(&mut self) -> &mut SystemConfig {
+        &mut self.system_meta.config
+    }
+}
 /// A trait implemented for all functions that can be used as [`System`]s.
 pub trait SystemParamFunction<In, Out, Param: SystemParam, Marker>: Send + Sync + 'static {
     /// # Safety
diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs
index d4fd0ad79909c..02ff5df3ab6fd 100644
--- a/crates/bevy_ecs/src/system/mod.rs
+++ b/crates/bevy_ecs/src/system/mod.rs
@@ -1,4 +1,5 @@
 mod commands;
+mod config;
 mod exclusive_system;
 mod function_system;
 mod query;
@@ -8,6 +9,7 @@ mod system_chaining;
 mod system_param;
 
 pub use commands::*;
+pub use config::*;
 pub use exclusive_system::*;
 pub use function_system::*;
 pub use query::*;
@@ -27,8 +29,8 @@ mod tests {
         query::{Added, Changed, Or, QueryState, With, Without},
         schedule::{Schedule, Stage, SystemStage},
         system::{
-            ConfigurableSystem, IntoExclusiveSystem, IntoSystem, Local, NonSend, NonSendMut, Query,
-            QuerySet, RemovedComponents, Res, ResMut, System, SystemState,
+            ConfigurableSystem, IntoSystem, Local, NonSend, NonSendMut, Query, QuerySet,
+            RemovedComponents, Res, ResMut, System, SystemState,
         },
         world::{FromWorld, World},
     };
@@ -183,7 +185,7 @@ mod tests {
         schedule.add_stage("update", update);
         schedule.add_stage(
             "clear_trackers",
-            SystemStage::single(World::clear_trackers.exclusive_system()),
+            SystemStage::single_exclusive(World::clear_trackers),
         );
 
         schedule.run(&mut world);
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index eabf476730340..ec0d779bf18b3 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -8,6 +8,8 @@ use crate::{
 };
 use std::borrow::Cow;
 
+use super::SystemConfig;
+
 /// A [`System`] identifier.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct SystemId(pub usize);
@@ -29,7 +31,7 @@ impl SystemId {
 ///
 /// Systems are executed in parallel, in opportunistic order; data access is managed automatically.
 /// It's possible to specify explicit execution order between specific systems,
-/// see [SystemDescriptor](crate::schedule::SystemDescriptor).
+/// see [SystemConfig](super::SystemConfig) and the other members of the [`config` module](super::config).
 pub trait System: Send + Sync + 'static {
     /// The system's input. See [`In`](crate::system::In) for
     /// [`FunctionSystem`](crate::system::FunctionSystem)s.
@@ -69,6 +71,9 @@ pub trait System: Send + Sync + 'static {
     /// Initialize the system.
     fn initialize(&mut self, _world: &mut World);
     fn check_change_tick(&mut self, change_tick: u32);
+
+    fn config_mut(&mut self) -> &mut SystemConfig;
+    fn config(&self) -> &SystemConfig;
 }
 
 /// A convenience type alias for a boxed [`System`] trait object.
diff --git a/crates/bevy_ecs/src/system/system_chaining.rs b/crates/bevy_ecs/src/system/system_chaining.rs
index 736bf066331ea..a39b62b6c967d 100644
--- a/crates/bevy_ecs/src/system/system_chaining.rs
+++ b/crates/bevy_ecs/src/system/system_chaining.rs
@@ -7,6 +7,8 @@ use crate::{
 };
 use std::borrow::Cow;
 
+use super::SystemConfig;
+
 /// A [`System`] that chains two systems together, creating a new system that routes the output of
 /// the first system into the input of the second system, yielding the output of the second system.
 ///
@@ -49,6 +51,7 @@ pub struct ChainSystem<SystemA, SystemB> {
     system_b: SystemB,
     name: Cow<'static, str>,
     id: SystemId,
+    config: SystemConfig,
     component_access: Access<ComponentId>,
     archetype_component_access: Access<ArchetypeComponentId>,
 }
@@ -75,14 +78,14 @@ impl<SystemA: System, SystemB: System<In = SystemA::Out>> System for ChainSystem
             .extend(self.system_b.archetype_component_access());
     }
 
-    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> {
-        &self.archetype_component_access
-    }
-
     fn component_access(&self) -> &Access<ComponentId> {
         &self.component_access
     }
 
+    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> {
+        &self.archetype_component_access
+    }
+
     fn is_send(&self) -> bool {
         self.system_a.is_send() && self.system_b.is_send()
     }
@@ -110,6 +113,13 @@ impl<SystemA: System, SystemB: System<In = SystemA::Out>> System for ChainSystem
         self.system_a.check_change_tick(change_tick);
         self.system_b.check_change_tick(change_tick);
     }
+    fn config(&self) -> &SystemConfig {
+        &self.config
+    }
+
+    fn config_mut(&mut self) -> &mut SystemConfig {
+        &mut self.config
+    }
 }
 
 /// An extension trait providing the [`IntoChainSystem::chain`] method for convenient [`System`]
@@ -139,6 +149,7 @@ where
         let system_b = system.system();
         ChainSystem {
             name: Cow::Owned(format!("Chain({}, {})", system_a.name(), system_b.name())),
+            config: SystemConfig::default(),
             system_a,
             system_b,
             archetype_component_access: Default::default(),
diff --git a/crates/bevy_gilrs/src/lib.rs b/crates/bevy_gilrs/src/lib.rs
index 406b947cc2350..9bc4ffb409f02 100644
--- a/crates/bevy_gilrs/src/lib.rs
+++ b/crates/bevy_gilrs/src/lib.rs
@@ -2,7 +2,7 @@ mod converter;
 mod gilrs_system;
 
 use bevy_app::{App, CoreStage, Plugin, StartupStage};
-use bevy_ecs::system::IntoExclusiveSystem;
+use bevy_ecs::prelude::{IntoExclusiveSystem, StageConfig, StartupConfig};
 use bevy_utils::tracing::error;
 use gilrs::GilrsBuilder;
 use gilrs_system::{gilrs_event_startup_system, gilrs_event_system};
@@ -19,14 +19,13 @@ impl Plugin for GilrsPlugin {
         {
             Ok(gilrs) => {
                 app.insert_non_send_resource(gilrs)
-                    .add_startup_system_to_stage(
-                        StartupStage::PreStartup,
-                        gilrs_event_startup_system.exclusive_system(),
+                    .add_exclusive(
+                        gilrs_event_startup_system
+                            .exclusive_system()
+                            .startup()
+                            .stage(StartupStage::PreStartup),
                     )
-                    .add_system_to_stage(
-                        CoreStage::PreUpdate,
-                        gilrs_event_system.exclusive_system(),
-                    );
+                    .add_exclusive(gilrs_event_system.stage(CoreStage::PreUpdate));
             }
             Err(err) => error!("Failed to start Gilrs. {}", err),
         }
diff --git a/crates/bevy_input/src/lib.rs b/crates/bevy_input/src/lib.rs
index 65c70d754912e..be3b8bc489a3c 100644
--- a/crates/bevy_input/src/lib.rs
+++ b/crates/bevy_input/src/lib.rs
@@ -7,7 +7,7 @@ pub mod system;
 pub mod touch;
 
 pub use axis::*;
-use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
+use bevy_ecs::{prelude::*, schedule::SystemLabel};
 pub use input::*;
 
 pub mod prelude {
@@ -47,18 +47,20 @@ impl Plugin for InputPlugin {
             // keyboard
             .add_event::<KeyboardInput>()
             .init_resource::<Input<KeyCode>>()
-            .add_system_to_stage(
-                CoreStage::PreUpdate,
-                keyboard_input_system.label(InputSystem),
+            .add_system(
+                keyboard_input_system
+                    .stage(CoreStage::PreUpdate)
+                    .label(InputSystem),
             )
             // mouse
             .add_event::<MouseButtonInput>()
             .add_event::<MouseMotion>()
             .add_event::<MouseWheel>()
             .init_resource::<Input<MouseButton>>()
-            .add_system_to_stage(
-                CoreStage::PreUpdate,
-                mouse_button_input_system.label(InputSystem),
+            .add_system(
+                mouse_button_input_system
+                    .stage(CoreStage::PreUpdate)
+                    .label(InputSystem),
             )
             // gamepad
             .add_event::<GamepadEvent>()
@@ -67,16 +69,18 @@ impl Plugin for InputPlugin {
             .init_resource::<Input<GamepadButton>>()
             .init_resource::<Axis<GamepadAxis>>()
             .init_resource::<Axis<GamepadButton>>()
-            .add_system_to_stage(
-                CoreStage::PreUpdate,
-                gamepad_event_system.label(InputSystem),
+            .add_system(
+                gamepad_event_system
+                    .stage(CoreStage::PreUpdate)
+                    .label(InputSystem),
             )
             // touch
             .add_event::<TouchInput>()
             .init_resource::<Touches>()
-            .add_system_to_stage(
-                CoreStage::PreUpdate,
-                touch_screen_input_system.label(InputSystem),
+            .add_system(
+                touch_screen_input_system
+                    .stage(CoreStage::PreUpdate)
+                    .label(InputSystem),
             );
     }
 }
diff --git a/crates/bevy_pbr/src/lib.rs b/crates/bevy_pbr/src/lib.rs
index a99bb80513284..1b04246341d09 100644
--- a/crates/bevy_pbr/src/lib.rs
+++ b/crates/bevy_pbr/src/lib.rs
@@ -4,6 +4,7 @@ mod entity;
 mod light;
 mod material;
 
+use bevy_ecs::prelude::StageConfig;
 pub use entity::*;
 pub use light::*;
 pub use material::*;
@@ -31,9 +32,8 @@ impl Plugin for PbrPlugin {
     fn build(&self, app: &mut App) {
         app.add_asset::<StandardMaterial>()
             .register_type::<PointLight>()
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                shader::asset_shader_defs_system::<StandardMaterial>,
+            .add_system(
+                shader::asset_shader_defs_system::<StandardMaterial>.stage(CoreStage::PostUpdate),
             )
             .init_resource::<AmbientLight>();
         add_pbr_graph(&mut app.world);
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index e26be98280c1c..73a0f975d60fc 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -13,7 +13,8 @@ pub mod texture;
 pub mod wireframe;
 
 use bevy_ecs::{
-    schedule::{ParallelSystemDescriptorCoercion, SystemStage},
+    prelude::{ScheduleConfig, StageConfig, StartupConfig},
+    schedule::SystemStage,
     system::{IntoExclusiveSystem, Res},
 };
 use bevy_transform::TransformSystem;
@@ -174,38 +175,45 @@ impl Plugin for RenderPlugin {
         .init_resource::<RenderResourceBindings>()
         .init_resource::<AssetRenderResourceBindings>()
         .init_resource::<ActiveCameras>()
-        .add_startup_system_to_stage(StartupStage::PreStartup, check_for_render_resource_context)
-        .add_system_to_stage(CoreStage::PreUpdate, draw::clear_draw_system)
-        .add_system_to_stage(CoreStage::PostUpdate, camera::active_cameras_system)
-        .add_system_to_stage(
-            CoreStage::PostUpdate,
-            camera::camera_system::<OrthographicProjection>.before(RenderSystem::VisibleEntities),
+        .add_system(
+            check_for_render_resource_context
+                .startup()
+                .stage(StartupStage::PreStartup),
         )
-        .add_system_to_stage(
-            CoreStage::PostUpdate,
-            camera::camera_system::<PerspectiveProjection>.before(RenderSystem::VisibleEntities),
+        .add_system(draw::clear_draw_system.stage(CoreStage::PreUpdate))
+        .add_system(camera::active_cameras_system.stage(CoreStage::PostUpdate))
+        .add_system(
+            camera::camera_system::<OrthographicProjection>
+                .stage(CoreStage::PostUpdate)
+                .before(RenderSystem::VisibleEntities),
         )
-        .add_system_to_stage(
-            CoreStage::PostUpdate,
+        .add_system(
+            camera::camera_system::<PerspectiveProjection>
+                .stage(CoreStage::PostUpdate)
+                .before(RenderSystem::VisibleEntities),
+        )
+        .add_system(
             camera::visible_entities_system
+                .stage(CoreStage::PostUpdate)
                 .label(RenderSystem::VisibleEntities)
                 .after(TransformSystem::TransformPropagate),
         )
-        .add_system_to_stage(RenderStage::RenderResource, shader::shader_update_system)
-        .add_system_to_stage(
-            RenderStage::RenderResource,
-            mesh::mesh_resource_provider_system,
+        .add_system(shader::shader_update_system.stage(RenderStage::RenderResource))
+        .add_system(mesh::mesh_resource_provider_system.stage(RenderStage::RenderResource))
+        .add_system(Texture::texture_resource_system.stage(RenderStage::RenderResource))
+        .add_exclusive(
+            render_graph::render_graph_schedule_executor_system
+                .exclusive_system()
+                .stage(RenderStage::RenderGraphSystems),
         )
-        .add_system_to_stage(
-            RenderStage::RenderResource,
-            Texture::texture_resource_system,
-        )
-        .add_system_to_stage(
-            RenderStage::RenderGraphSystems,
-            render_graph::render_graph_schedule_executor_system.exclusive_system(),
+        .add_system(Texture::texture_resource_system.stage(RenderStage::RenderResource))
+        .add_exclusive(
+            render_graph::render_graph_schedule_executor_system
+                .exclusive_system()
+                .stage(RenderStage::RenderGraphSystems),
         )
-        .add_system_to_stage(RenderStage::Draw, pipeline::draw_render_pipelines_system)
-        .add_system_to_stage(RenderStage::PostRender, shader::clear_shader_defs_system);
+        .add_system(pipeline::draw_render_pipelines_system.stage(RenderStage::Draw))
+        .add_system(shader::clear_shader_defs_system.stage(RenderStage::PostRender));
 
         if let Some(ref config) = self.base_render_graph_config {
             crate::base::add_base_graph(config, &mut app.world);
diff --git a/crates/bevy_render/src/render_graph/graph.rs b/crates/bevy_render/src/render_graph/graph.rs
index 503bce7578e09..8dec865804b59 100644
--- a/crates/bevy_render/src/render_graph/graph.rs
+++ b/crates/bevy_render/src/render_graph/graph.rs
@@ -48,7 +48,7 @@ impl RenderGraph {
         let stage = schedule
             .get_stage_mut::<SystemStage>(&RenderGraphUpdate)
             .unwrap();
-        stage.add_system(node.get_system());
+        stage.add_boxed_system(node.get_system());
         self.add_node(name, node)
     }
 
diff --git a/crates/bevy_render/src/wireframe/mod.rs b/crates/bevy_render/src/wireframe/mod.rs
index fc958163238f2..878b03da25580 100644
--- a/crates/bevy_render/src/wireframe/mod.rs
+++ b/crates/bevy_render/src/wireframe/mod.rs
@@ -8,6 +8,7 @@ use crate::{
 use bevy_app::prelude::*;
 use bevy_asset::{Assets, Handle, HandleUntyped};
 use bevy_ecs::{
+    prelude::StageConfig,
     query::{QueryState, With},
     reflect::ReflectComponent,
     system::{QuerySet, Res},
@@ -27,7 +28,7 @@ pub struct WireframePlugin;
 impl Plugin for WireframePlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<WireframeConfig>()
-            .add_system_to_stage(crate::RenderStage::Draw, draw_wireframes_system);
+            .add_system(draw_wireframes_system.stage(crate::RenderStage::Draw));
         let world = app.world.cell();
         let mut shaders = world.get_resource_mut::<Assets<Shader>>().unwrap();
         let mut pipelines = world
diff --git a/crates/bevy_scene/src/lib.rs b/crates/bevy_scene/src/lib.rs
index 7c35b9ba11fd3..0fba563a9a85a 100644
--- a/crates/bevy_scene/src/lib.rs
+++ b/crates/bevy_scene/src/lib.rs
@@ -20,7 +20,10 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::{schedule::ExclusiveSystemDescriptorCoercion, system::IntoExclusiveSystem};
+use bevy_ecs::{
+    prelude::{ExclusiveConfig, StageConfig},
+    system::IntoExclusiveSystem,
+};
 
 #[derive(Default)]
 pub struct ScenePlugin;
@@ -31,9 +34,11 @@ impl Plugin for ScenePlugin {
             .add_asset::<Scene>()
             .init_asset_loader::<SceneLoader>()
             .init_resource::<SceneSpawner>()
-            .add_system_to_stage(
-                CoreStage::PreUpdate,
-                scene_spawner_system.exclusive_system().at_end(),
+            .add_exclusive(
+                scene_spawner_system
+                    .exclusive_system()
+                    .stage(CoreStage::PreUpdate)
+                    .at_end(),
             );
     }
 }
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index 4dfdb7884979d..2c90a4e1114d4 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -28,7 +28,10 @@ pub use texture_atlas_builder::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
-use bevy_ecs::component::{ComponentDescriptor, StorageType};
+use bevy_ecs::{
+    component::{ComponentDescriptor, StorageType},
+    prelude::StageConfig,
+};
 use bevy_math::Vec2;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
@@ -69,26 +72,19 @@ impl Plugin for SpritePlugin {
             .add_asset::<TextureAtlas>()
             .register_type::<Sprite>()
             .register_type::<SpriteResizeMode>()
-            .add_system_to_stage(CoreStage::PostUpdate, sprite_system)
-            .add_system_to_stage(CoreStage::PostUpdate, material_texture_detection_system)
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                asset_shader_defs_system::<ColorMaterial>,
-            );
+            .add_system(sprite_system.stage(CoreStage::PostUpdate))
+            .add_system(material_texture_detection_system.stage(CoreStage::PostUpdate))
+            .add_system(asset_shader_defs_system::<ColorMaterial>.stage(CoreStage::PostUpdate));
 
         let sprite_settings = app
             .world
             .get_resource_or_insert_with(SpriteSettings::default)
             .clone();
         if sprite_settings.frustum_culling_enabled {
-            app.add_system_to_stage(
-                CoreStage::PostUpdate,
-                frustum_culling::sprite_frustum_culling_system,
+            app.add_system(
+                frustum_culling::sprite_frustum_culling_system.stage(CoreStage::PostUpdate),
             )
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                frustum_culling::atlas_frustum_culling_system,
-            );
+            .add_system(frustum_culling::atlas_frustum_culling_system.stage(CoreStage::PostUpdate));
         }
         app.world
             .register_component(ComponentDescriptor::new::<OutsideFrustum>(
diff --git a/crates/bevy_text/src/lib.rs b/crates/bevy_text/src/lib.rs
index ce91d4a2e8ba3..eba3b24d7f2d8 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -29,7 +29,7 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::entity::Entity;
+use bevy_ecs::{entity::Entity, prelude::StageConfig};
 use bevy_render::RenderStage;
 
 pub type DefaultTextPipeline = TextPipeline<Entity>;
@@ -43,7 +43,7 @@ impl Plugin for TextPlugin {
             .add_asset::<FontAtlasSet>()
             .init_asset_loader::<FontLoader>()
             .insert_resource(DefaultTextPipeline::default())
-            .add_system_to_stage(CoreStage::PostUpdate, text2d_system)
-            .add_system_to_stage(RenderStage::Draw, text2d::draw_text2d_system);
+            .add_system(text2d_system.stage(CoreStage::PostUpdate))
+            .add_system(text2d::draw_text2d_system.stage(RenderStage::Draw));
     }
 }
diff --git a/crates/bevy_transform/src/lib.rs b/crates/bevy_transform/src/lib.rs
index f255c613db814..497809e931c87 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -8,7 +8,10 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
+use bevy_ecs::{
+    prelude::{ScheduleConfig, StageConfig, StartupConfig},
+    schedule::SystemLabel,
+};
 use prelude::{parent_update_system, Children, GlobalTransform, Parent, PreviousParent, Transform};
 
 #[derive(Default)]
@@ -28,23 +31,27 @@ impl Plugin for TransformPlugin {
             .register_type::<Transform>()
             .register_type::<GlobalTransform>()
             // add transform systems to startup so the first update is "correct"
-            .add_startup_system_to_stage(
-                StartupStage::PostStartup,
-                parent_update_system.label(TransformSystem::ParentUpdate),
+            .add_system(
+                parent_update_system
+                    .startup()
+                    .stage(StartupStage::PostStartup)
+                    .label(TransformSystem::ParentUpdate),
             )
-            .add_startup_system_to_stage(
-                StartupStage::PostStartup,
+            .add_system(
                 transform_propagate_system::transform_propagate_system
+                    .startup()
+                    .stage(StartupStage::PostStartup)
                     .label(TransformSystem::TransformPropagate)
                     .after(TransformSystem::ParentUpdate),
             )
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                parent_update_system.label(TransformSystem::ParentUpdate),
+            .add_system(
+                parent_update_system
+                    .stage(CoreStage::PostUpdate)
+                    .label(TransformSystem::ParentUpdate),
             )
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
+            .add_system(
                 transform_propagate_system::transform_propagate_system
+                    .stage(CoreStage::PostUpdate)
                     .label(TransformSystem::TransformPropagate)
                     .after(TransformSystem::ParentUpdate),
             );
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index e9ca5b3b328f8..df789caafdf9a 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -22,7 +22,10 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::schedule::{ParallelSystemDescriptorCoercion, SystemLabel};
+use bevy_ecs::{
+    prelude::{ScheduleConfig, StageConfig},
+    schedule::SystemLabel,
+};
 use bevy_input::InputSystem;
 use bevy_math::{Rect, Size};
 use bevy_render::RenderStage;
@@ -57,32 +60,36 @@ impl Plugin for UiPlugin {
             .register_type::<Rect<Val>>()
             .register_type::<Style>()
             .register_type::<Val>()
-            .add_system_to_stage(
-                CoreStage::PreUpdate,
-                ui_focus_system.label(UiSystem::Focus).after(InputSystem),
+            .add_system(
+                ui_focus_system
+                    .stage(CoreStage::PreUpdate)
+                    .label(UiSystem::Focus)
+                    .after(InputSystem),
             )
             // add these stages to front because these must run before transform update systems
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                widget::text_system.before(UiSystem::Flex),
+            .add_system(
+                widget::text_system
+                    .stage(CoreStage::PostUpdate)
+                    .before(UiSystem::Flex),
             )
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                widget::image_node_system.before(UiSystem::Flex),
+            .add_system(
+                widget::image_node_system
+                    .stage(CoreStage::PostUpdate)
+                    .before(UiSystem::Flex),
             )
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
+            .add_system(
                 flex_node_system
+                    .stage(CoreStage::PostUpdate)
                     .label(UiSystem::Flex)
                     .before(TransformSystem::TransformPropagate),
             )
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
+            .add_system(
                 ui_z_system
+                    .stage(CoreStage::PostUpdate)
                     .after(UiSystem::Flex)
                     .before(TransformSystem::TransformPropagate),
             )
-            .add_system_to_stage(RenderStage::Draw, widget::draw_text_system);
+            .add_system(widget::draw_text_system.stage(RenderStage::Draw));
 
         crate::render::add_ui_graph(&mut app.world);
     }
diff --git a/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs b/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
index b696b7bbc0662..88148e3ff96d1 100644
--- a/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
+++ b/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
@@ -1,7 +1,10 @@
 use crate::renderer::WgpuRenderResourceContext;
 use bevy_app::prelude::*;
 use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics};
-use bevy_ecs::system::{Res, ResMut};
+use bevy_ecs::{
+    prelude::StartupConfig,
+    system::{Res, ResMut},
+};
 use bevy_render::renderer::RenderResourceContext;
 
 #[derive(Default)]
@@ -9,7 +12,7 @@ pub struct WgpuResourceDiagnosticsPlugin;
 
 impl Plugin for WgpuResourceDiagnosticsPlugin {
     fn build(&self, app: &mut App) {
-        app.add_startup_system(Self::setup_system)
+        app.add_system(Self::setup_system.startup())
             .add_system(Self::diagnostic_system);
     }
 }
diff --git a/crates/bevy_wgpu/src/lib.rs b/crates/bevy_wgpu/src/lib.rs
index 0adb26dc066f0..dad55fcf75aab 100644
--- a/crates/bevy_wgpu/src/lib.rs
+++ b/crates/bevy_wgpu/src/lib.rs
@@ -10,7 +10,7 @@ pub use wgpu_renderer::*;
 pub use wgpu_resources::*;
 
 use bevy_app::prelude::*;
-use bevy_ecs::{system::IntoExclusiveSystem, world::World};
+use bevy_ecs::{prelude::StageConfig, system::IntoExclusiveSystem, world::World};
 use bevy_render::{
     renderer::{shared_buffers_update_system, RenderResourceContext, SharedBuffers},
     RenderStage,
@@ -103,8 +103,8 @@ pub struct WgpuPlugin;
 impl Plugin for WgpuPlugin {
     fn build(&self, app: &mut App) {
         let render_system = get_wgpu_render_system(&mut app.world);
-        app.add_system_to_stage(RenderStage::Render, render_system.exclusive_system())
-            .add_system_to_stage(RenderStage::PostRender, shared_buffers_update_system);
+        app.add_exclusive(render_system.exclusive_system().stage(RenderStage::Render))
+            .add_system(shared_buffers_update_system.stage(RenderStage::PostRender));
     }
 }
 
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index af072b7a60f9f..e287fcc860d6b 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -11,7 +11,7 @@ pub use winit_config::*;
 pub use winit_windows::*;
 
 use bevy_app::{App, AppExit, CoreStage, Events, ManualEventReader, Plugin};
-use bevy_ecs::{system::IntoExclusiveSystem, world::World};
+use bevy_ecs::{prelude::StageConfig, world::World};
 use bevy_math::{ivec2, Vec2};
 use bevy_utils::tracing::{error, trace, warn};
 use bevy_window::{
@@ -42,7 +42,7 @@ impl Plugin for WinitPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<WinitWindows>()
             .set_runner(winit_runner)
-            .add_system_to_stage(CoreStage::PostUpdate, change_window.exclusive_system());
+            .add_exclusive(change_window.stage(CoreStage::PostUpdate));
     }
 }
 
diff --git a/examples/2d/contributors.rs b/examples/2d/contributors.rs
index 6186bb78dd5fe..1d94abc08bdd0 100644
--- a/examples/2d/contributors.rs
+++ b/examples/2d/contributors.rs
@@ -9,7 +9,7 @@ use std::{
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(velocity_system)
         .add_system(move_system)
         .add_system(collision_system)
diff --git a/examples/2d/many_sprites.rs b/examples/2d/many_sprites.rs
index 203efe376488f..e783fc5504204 100644
--- a/examples/2d/many_sprites.rs
+++ b/examples/2d/many_sprites.rs
@@ -23,7 +23,7 @@ fn main() {
             frustum_culling_enabled: true,
         })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(tick.label("Tick"))
         .add_system(move_camera.after("Tick"))
         .run()
diff --git a/examples/2d/mesh.rs b/examples/2d/mesh.rs
index 9a89d678a4d4b..ed2b6ef223041 100644
--- a/examples/2d/mesh.rs
+++ b/examples/2d/mesh.rs
@@ -9,7 +9,7 @@ use bevy::{
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(star)
+        .add_system(star.startup())
         .run();
 }
 
diff --git a/examples/2d/sprite.rs b/examples/2d/sprite.rs
index 9d0560020380a..dddc8ac0aef67 100644
--- a/examples/2d/sprite.rs
+++ b/examples/2d/sprite.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/2d/sprite_flipping.rs b/examples/2d/sprite_flipping.rs
index e53a49af6ed80..2b930b5c32637 100644
--- a/examples/2d/sprite_flipping.rs
+++ b/examples/2d/sprite_flipping.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/2d/sprite_sheet.rs b/examples/2d/sprite_sheet.rs
index 678e4cb6b3903..9478be1de0567 100644
--- a/examples/2d/sprite_sheet.rs
+++ b/examples/2d/sprite_sheet.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(animate_sprite_system)
         .run();
 }
diff --git a/examples/2d/text2d.rs b/examples/2d/text2d.rs
index 7dae1046f5881..6db46cb1c17af 100644
--- a/examples/2d/text2d.rs
+++ b/examples/2d/text2d.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(animate_translation)
         .add_system(animate_rotation)
         .add_system(animate_scale)
diff --git a/examples/3d/3d_scene.rs b/examples/3d/3d_scene.rs
index 7bbe026d2b206..7a9246c1764b5 100644
--- a/examples/3d/3d_scene.rs
+++ b/examples/3d/3d_scene.rs
@@ -4,7 +4,7 @@ fn main() {
     App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/3d/load_gltf.rs b/examples/3d/load_gltf.rs
index 280c8172bc929..36dec85099692 100644
--- a/examples/3d/load_gltf.rs
+++ b/examples/3d/load_gltf.rs
@@ -8,7 +8,7 @@ fn main() {
         })
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(rotator_system)
         .run();
 }
diff --git a/examples/3d/msaa.rs b/examples/3d/msaa.rs
index 8878da9f0273b..dc048c63494c0 100644
--- a/examples/3d/msaa.rs
+++ b/examples/3d/msaa.rs
@@ -8,7 +8,7 @@ fn main() {
     App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/3d/orthographic.rs b/examples/3d/orthographic.rs
index ec8a1d296bef6..de35c89f95950 100644
--- a/examples/3d/orthographic.rs
+++ b/examples/3d/orthographic.rs
@@ -4,7 +4,7 @@ fn main() {
     App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/3d/parenting.rs b/examples/3d/parenting.rs
index 4d54464a8c8fa..4c844afb8bee8 100644
--- a/examples/3d/parenting.rs
+++ b/examples/3d/parenting.rs
@@ -6,7 +6,7 @@ fn main() {
     App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(rotator_system)
         .run();
 }
diff --git a/examples/3d/pbr.rs b/examples/3d/pbr.rs
index 0bd93545aa60e..d8fb973ea494f 100644
--- a/examples/3d/pbr.rs
+++ b/examples/3d/pbr.rs
@@ -5,7 +5,7 @@ fn main() {
     App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/3d/render_to_texture.rs b/examples/3d/render_to_texture.rs
index 1cb34f27faa32..eb24a444ee5d5 100644
--- a/examples/3d/render_to_texture.rs
+++ b/examples/3d/render_to_texture.rs
@@ -226,7 +226,7 @@ fn setup(
 fn main() {
     let mut app = App::new();
     app.add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(cube_rotator_system)
         .add_system(rotator_system)
         .run();
diff --git a/examples/3d/spawner.rs b/examples/3d/spawner.rs
index 60e52d163d528..2ef4e3614dd4c 100644
--- a/examples/3d/spawner.rs
+++ b/examples/3d/spawner.rs
@@ -17,7 +17,7 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
         .add_plugin(LogDiagnosticsPlugin::default())
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(move_cubes)
         .run();
 }
diff --git a/examples/3d/texture.rs b/examples/3d/texture.rs
index 75e5f1f9cce27..1c1a0558cbded 100644
--- a/examples/3d/texture.rs
+++ b/examples/3d/texture.rs
@@ -4,7 +4,7 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/3d/update_gltf_scene.rs b/examples/3d/update_gltf_scene.rs
index 15a84a4919938..274f779e12afd 100644
--- a/examples/3d/update_gltf_scene.rs
+++ b/examples/3d/update_gltf_scene.rs
@@ -5,7 +5,7 @@ fn main() {
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
         .insert_resource(SceneInstance::default())
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(scene_update)
         .add_system(move_scene_entities)
         .run();
diff --git a/examples/3d/wireframe.rs b/examples/3d/wireframe.rs
index c07483cfb25d1..4ef7ded71efe7 100644
--- a/examples/3d/wireframe.rs
+++ b/examples/3d/wireframe.rs
@@ -16,7 +16,7 @@ fn main() {
         })
         .add_plugins(DefaultPlugins)
         .add_plugin(WireframePlugin)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/3d/z_sort_debug.rs b/examples/3d/z_sort_debug.rs
index 6484fda893ef3..0e7cb2814ad58 100644
--- a/examples/3d/z_sort_debug.rs
+++ b/examples/3d/z_sort_debug.rs
@@ -11,7 +11,7 @@ use bevy::{
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(rotator_system)
         .add_system(camera_order_color_system)
         .run();
diff --git a/examples/android/android.rs b/examples/android/android.rs
index 006dd37486a04..6522c1c6b85e0 100644
--- a/examples/android/android.rs
+++ b/examples/android/android.rs
@@ -6,7 +6,7 @@ fn main() {
     App::new()
         .insert_resource(Msaa { samples: 2 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/asset/asset_loading.rs b/examples/asset/asset_loading.rs
index 4c0f6b926d5cd..d0ee42a3b13f9 100644
--- a/examples/asset/asset_loading.rs
+++ b/examples/asset/asset_loading.rs
@@ -5,7 +5,7 @@ fn main() {
     App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/asset/custom_asset.rs b/examples/asset/custom_asset.rs
index 820d62394eeb0..f4577058d961d 100644
--- a/examples/asset/custom_asset.rs
+++ b/examples/asset/custom_asset.rs
@@ -39,7 +39,7 @@ fn main() {
         .init_resource::<State>()
         .add_asset::<CustomAsset>()
         .init_asset_loader::<CustomAssetLoader>()
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(print_on_load)
         .run();
 }
diff --git a/examples/asset/custom_asset_io.rs b/examples/asset/custom_asset_io.rs
index 718cbc1047731..ddddfc3833e4f 100644
--- a/examples/asset/custom_asset_io.rs
+++ b/examples/asset/custom_asset_io.rs
@@ -85,7 +85,7 @@ fn main() {
             // asset system are initialized correctly.
             group.add_before::<bevy::asset::AssetPlugin, _>(CustomAssetIoPlugin)
         })
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/asset/hot_asset_reloading.rs b/examples/asset/hot_asset_reloading.rs
index 9216b1031100f..b6e4d5140106a 100644
--- a/examples/asset/hot_asset_reloading.rs
+++ b/examples/asset/hot_asset_reloading.rs
@@ -6,7 +6,7 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/async_tasks/async_compute.rs b/examples/async_tasks/async_compute.rs
index 9e0b50b05a3ea..dc400b3e0ca88 100644
--- a/examples/async_tasks/async_compute.rs
+++ b/examples/async_tasks/async_compute.rs
@@ -12,9 +12,9 @@ fn main() {
     App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup_env)
-        .add_startup_system(add_assets)
-        .add_startup_system(spawn_tasks)
+        .add_system(setup_env.startup())
+        .add_system(add_assets.startup())
+        .add_system(spawn_tasks.startup())
         .add_system(handle_tasks)
         .run();
 }
diff --git a/examples/audio/audio.rs b/examples/audio/audio.rs
index b093b88d94803..208d2c150be1b 100644
--- a/examples/audio/audio.rs
+++ b/examples/audio/audio.rs
@@ -4,7 +4,7 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/diagnostics/custom_diagnostic.rs b/examples/diagnostics/custom_diagnostic.rs
index 7f289d9f5b71e..8be62db5973a5 100644
--- a/examples/diagnostics/custom_diagnostic.rs
+++ b/examples/diagnostics/custom_diagnostic.rs
@@ -10,7 +10,7 @@ fn main() {
         // The "print diagnostics" plugin is optional. It just visualizes our diagnostics in the
         // console
         .add_plugin(LogDiagnosticsPlugin::default())
-        .add_startup_system(setup_diagnostic_system)
+        .add_system(setup_diagnostic_system.startup())
         .add_system(my_system)
         .run();
 }
diff --git a/examples/ecs/component_change_detection.rs b/examples/ecs/component_change_detection.rs
index 7ece27bebc579..9d49e0fd2bda0 100644
--- a/examples/ecs/component_change_detection.rs
+++ b/examples/ecs/component_change_detection.rs
@@ -5,7 +5,7 @@ use rand::Rng;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(change_component)
         .add_system(change_detection)
         .add_system(tracker_monitoring)
diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index ae51cb6b3d49a..79147fce1edeb 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -141,7 +141,7 @@ fn game_over_system(
 // This is a "startup" system that runs exactly once when the app starts up. Startup systems are
 // generally used to create the initial "state" of our game. The only thing that distinguishes a
 // "startup" system from a "normal" system is how it is registered:      Startup:
-// app.add_startup_system(startup_system)      Normal:  app.add_system(normal_system)
+// app.add_system(startup_system.startup())      Normal:  app.add_system(normal_system)
 fn startup_system(mut commands: Commands, mut game_state: ResMut<GameState>) {
     // Create our game rules resource
     commands.insert_resource(GameRules {
@@ -276,7 +276,7 @@ fn main() {
         .init_resource::<GameState>()
         // Startup systems run exactly once BEFORE all other systems. These are generally used for
         // app initialization code (ex: adding entities and resources)
-        .add_startup_system(startup_system)
+        .add_system(startup_system.startup())
         // my_system calls converts normal rust functions into ECS systems:
         .add_system(print_message_system)
         // SYSTEM EXECUTION ORDER
@@ -310,7 +310,7 @@ fn main() {
         // add_system(system) adds systems to the UPDATE stage by default
         // However we can manually specify the stage if we want to. The following is equivalent to
         // add_system(score_system)
-        .add_system_to_stage(CoreStage::Update, score_system)
+        .add_system(score_system.stage(CoreStage::Update))
         // We can also create new stages. Here is what our games stage order will look like:
         // "before_round": new_player_system, new_round_system
         // "update": print_message_system, score_system
@@ -325,18 +325,20 @@ fn main() {
             MyStage::AfterRound,
             SystemStage::parallel(),
         )
-        .add_system_to_stage(MyStage::BeforeRound, new_round_system)
-        .add_system_to_stage(MyStage::BeforeRound, new_player_system)
+        .add_system(new_round_system.stage(MyStage::BeforeRound))
+        .add_system(new_player_system.stage(MyStage::BeforeRound))
         // We can ensure that game_over system runs after score_check_system using explicit ordering
         // constraints First, we label the system we want to refer to using `.label`
         // Then, we use either `.before` or `.after` to describe the order we want the relationship
-        .add_system_to_stage(
-            MyStage::AfterRound,
-            score_check_system.label(MyLabels::ScoreCheck),
+        .add_system(
+            score_check_system
+                .stage(MyStage::AfterRound)
+                .label(MyLabels::ScoreCheck),
         )
-        .add_system_to_stage(
-            MyStage::AfterRound,
-            game_over_system.after(MyLabels::ScoreCheck),
+        .add_system(
+            game_over_system
+                .stage(MyStage::AfterRound)
+                .after(MyLabels::ScoreCheck),
         )
         // We can check our systems for execution order ambiguities by examining the output produced
         // in the console by using the `LogPlugin` and adding the following Resource to our App :)
diff --git a/examples/ecs/hierarchy.rs b/examples/ecs/hierarchy.rs
index 96a51f72d0e2d..7fc891160f6d8 100644
--- a/examples/ecs/hierarchy.rs
+++ b/examples/ecs/hierarchy.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(rotate)
         .run();
 }
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index 69e8811a6a74b..0eada0672eb8f 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -10,7 +10,7 @@ fn main() {
     App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(generate_bodies)
+        .add_system(generate_bodies.startup())
         .add_stage_after(
             CoreStage::Update,
             FixedUpdateStage,
diff --git a/examples/ecs/parallel_query.rs b/examples/ecs/parallel_query.rs
index 3c770f5d2bc5e..78ae5eb1d45ef 100644
--- a/examples/ecs/parallel_query.rs
+++ b/examples/ecs/parallel_query.rs
@@ -70,7 +70,7 @@ fn bounce_system(
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(spawn_system)
+        .add_system(spawn_system.startup())
         .add_system(move_system)
         .add_system(bounce_system)
         .run();
diff --git a/examples/ecs/removal_detection.rs b/examples/ecs/removal_detection.rs
index de4275e348c7f..a80c192073a8a 100644
--- a/examples/ecs/removal_detection.rs
+++ b/examples/ecs/removal_detection.rs
@@ -15,9 +15,9 @@ fn main() {
     // `CoreStage::PostUpdate` stage.
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
-        .add_system_to_stage(CoreStage::Update, remove_component)
-        .add_system_to_stage(CoreStage::PostUpdate, react_on_removal)
+        .add_system(setup.startup())
+        .add_system(remove_component.stage(CoreStage::Update))
+        .add_system(react_on_removal.stage(CoreStage::PostUpdate))
         .run();
 }
 
diff --git a/examples/ecs/startup_system.rs b/examples/ecs/startup_system.rs
index 82437b03af99e..7f1013ce0718a 100644
--- a/examples/ecs/startup_system.rs
+++ b/examples/ecs/startup_system.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 fn main() {
     App::new()
-        .add_startup_system(startup_system)
+        .add_system(startup_system.startup())
         .add_system(normal_system)
         .run();
 }
diff --git a/examples/ecs/system_param.rs b/examples/ecs/system_param.rs
index 4f56b7b5a89a5..1e757caf1a96c 100644
--- a/examples/ecs/system_param.rs
+++ b/examples/ecs/system_param.rs
@@ -4,7 +4,7 @@ use bevy::{ecs::system::SystemParam, prelude::*};
 fn main() {
     App::new()
         .insert_resource(PlayerCount(0))
-        .add_startup_system(spawn)
+        .add_system(spawn.startup())
         .add_system(count_players)
         .run();
 }
diff --git a/examples/ecs/timers.rs b/examples/ecs/timers.rs
index 12f3bfb1f1770..a08bc26eb29cf 100644
--- a/examples/ecs/timers.rs
+++ b/examples/ecs/timers.rs
@@ -4,7 +4,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .insert_resource(Countdown::default())
-        .add_startup_system(setup_system)
+        .add_system(setup_system.startup())
         .add_system(countdown_system)
         .add_system(timer_system)
         .run();
diff --git a/examples/game/alien_cake_addict.rs b/examples/game/alien_cake_addict.rs
index a9158614012c5..6ee46213a956c 100644
--- a/examples/game/alien_cake_addict.rs
+++ b/examples/game/alien_cake_addict.rs
@@ -18,7 +18,7 @@ fn main() {
         .init_resource::<Game>()
         .add_plugins(DefaultPlugins)
         .add_state(GameState::Playing)
-        .add_startup_system(setup_cameras)
+        .add_system(setup_cameras.startup())
         .add_system_set(SystemSet::on_enter(GameState::Playing).with_system(setup))
         .add_system_set(
             SystemSet::on_update(GameState::Playing)
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index 26ef9bdcbe0c7..c4258e12c10a8 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -12,7 +12,7 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .insert_resource(Scoreboard { score: 0 })
         .insert_resource(ClearColor(Color::rgb(0.9, 0.9, 0.9)))
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system_set(
             SystemSet::new()
                 .with_run_criteria(FixedTimestep::step(TIME_STEP as f64))
diff --git a/examples/input/gamepad_input.rs b/examples/input/gamepad_input.rs
index 24bd872f48ab8..06ceb0f47a353 100644
--- a/examples/input/gamepad_input.rs
+++ b/examples/input/gamepad_input.rs
@@ -8,7 +8,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .init_resource::<GamepadLobby>()
-        .add_system_to_stage(CoreStage::PreUpdate, connection_system)
+        .add_system(connection_system.stage(CoreStage::PreUpdate))
         .add_system(gamepad_system)
         .run();
 }
diff --git a/examples/ios/src/lib.rs b/examples/ios/src/lib.rs
index 978390d1a77a8..aaa1e36c20773 100644
--- a/examples/ios/src/lib.rs
+++ b/examples/ios/src/lib.rs
@@ -12,8 +12,8 @@ fn main() {
         })
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup_scene)
-        .add_startup_system(setup_music)
+        .add_system(setup_scene.startup())
+        .add_system(setup_music.startup())
         .run();
 }
 /// set up a simple 3D scene
diff --git a/examples/reflection/generic_reflection.rs b/examples/reflection/generic_reflection.rs
index 9fba61831cec1..1019f393adf55 100644
--- a/examples/reflection/generic_reflection.rs
+++ b/examples/reflection/generic_reflection.rs
@@ -6,7 +6,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .register_type::<MyType<u32>>()
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/reflection/reflection.rs b/examples/reflection/reflection.rs
index 24f522614e07e..13fdaaabedd56 100644
--- a/examples/reflection/reflection.rs
+++ b/examples/reflection/reflection.rs
@@ -15,7 +15,7 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .register_type::<Foo>()
         .register_type::<Bar>()
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/reflection/reflection_types.rs b/examples/reflection/reflection_types.rs
index c19f25e27443e..a2cfcf892a914 100644
--- a/examples/reflection/reflection_types.rs
+++ b/examples/reflection/reflection_types.rs
@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/reflection/trait_reflection.rs b/examples/reflection/trait_reflection.rs
index 9dba2f34ffc51..83f40c5c4eeed 100644
--- a/examples/reflection/trait_reflection.rs
+++ b/examples/reflection/trait_reflection.rs
@@ -3,7 +3,7 @@ use bevy::{prelude::*, reflect::TypeRegistry};
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .register_type::<MyType>()
         .run();
 }
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index 9cf53e5db7a85..06ef978f0943f 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -6,9 +6,9 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .register_type::<ComponentA>()
         .register_type::<ComponentB>()
-        .add_startup_system(save_scene_system.exclusive_system())
-        .add_startup_system(load_scene_system)
-        .add_startup_system(infotext_system)
+        .add_exclusive(save_scene_system.exclusive_system().startup())
+        .add_system(load_scene_system.startup())
+        .add_system(infotext_system.startup())
         .add_system(log_system)
         .run();
 }
diff --git a/examples/shader/animate_shader.rs b/examples/shader/animate_shader.rs
index aff72e3e6a44f..a3f1e695909c5 100644
--- a/examples/shader/animate_shader.rs
+++ b/examples/shader/animate_shader.rs
@@ -15,7 +15,7 @@ use bevy::{
 pub fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(animate_shader)
         .run();
 }
diff --git a/examples/shader/array_texture.rs b/examples/shader/array_texture.rs
index fba6d5800d6f3..c2f3ae7042e28 100644
--- a/examples/shader/array_texture.rs
+++ b/examples/shader/array_texture.rs
@@ -16,7 +16,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyArrayTexture>()
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(create_array_texture)
         .run();
 }
diff --git a/examples/shader/hot_shader_reloading.rs b/examples/shader/hot_shader_reloading.rs
index 08fc65189a5c2..c5a6d5188cfeb 100644
--- a/examples/shader/hot_shader_reloading.rs
+++ b/examples/shader/hot_shader_reloading.rs
@@ -16,7 +16,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyMaterial>()
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/shader/mesh_custom_attribute.rs b/examples/shader/mesh_custom_attribute.rs
index c9a188aef9b5b..6dba155e405a4 100644
--- a/examples/shader/mesh_custom_attribute.rs
+++ b/examples/shader/mesh_custom_attribute.rs
@@ -11,7 +11,7 @@ use bevy::{
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/shader/shader_custom_material.rs b/examples/shader/shader_custom_material.rs
index 4be05c87fed6c..d28f808f9489c 100644
--- a/examples/shader/shader_custom_material.rs
+++ b/examples/shader/shader_custom_material.rs
@@ -16,7 +16,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyMaterial>()
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/shader/shader_defs.rs b/examples/shader/shader_defs.rs
index ab9e4f8c4623e..4b48e1c0abab9 100644
--- a/examples/shader/shader_defs.rs
+++ b/examples/shader/shader_defs.rs
@@ -17,11 +17,8 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyMaterial>()
-        .add_startup_system(setup)
-        .add_system_to_stage(
-            CoreStage::PostUpdate,
-            asset_shader_defs_system::<MyMaterial>,
-        )
+        .add_system(setup.startup())
+        .add_system(asset_shader_defs_system::<MyMaterial>.stage(CoreStage::PostUpdate))
         .run();
 }
 
diff --git a/examples/tools/bevymark.rs b/examples/tools/bevymark.rs
index 26abaec4ff6af..4bcef1622e063 100644
--- a/examples/tools/bevymark.rs
+++ b/examples/tools/bevymark.rs
@@ -44,7 +44,7 @@ fn main() {
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
         .insert_resource(BevyCounter { count: 0 })
         .init_resource::<BirdMaterial>()
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(mouse_handler)
         .add_system(movement_system)
         .add_system(collision_system)
diff --git a/examples/ui/button.rs b/examples/ui/button.rs
index 144c7dad22316..1a80a43e6854f 100644
--- a/examples/ui/button.rs
+++ b/examples/ui/button.rs
@@ -6,7 +6,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .init_resource::<ButtonMaterials>()
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(button_system)
         .run();
 }
diff --git a/examples/ui/font_atlas_debug.rs b/examples/ui/font_atlas_debug.rs
index 163a7181d6e0a..50383c3ca69ea 100644
--- a/examples/ui/font_atlas_debug.rs
+++ b/examples/ui/font_atlas_debug.rs
@@ -8,7 +8,7 @@ fn main() {
         .init_resource::<State>()
         .insert_resource(ClearColor(Color::BLACK))
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(text_update_system)
         .add_system(atlas_render_system)
         .run();
diff --git a/examples/ui/text.rs b/examples/ui/text.rs
index 2b0b96fc0dac3..f7ee6db2de294 100644
--- a/examples/ui/text.rs
+++ b/examples/ui/text.rs
@@ -10,7 +10,7 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(text_update_system)
         .add_system(text_color_system)
         .run();
diff --git a/examples/ui/text_debug.rs b/examples/ui/text_debug.rs
index 938f49c5e5fe8..f1c27d0a08e6e 100644
--- a/examples/ui/text_debug.rs
+++ b/examples/ui/text_debug.rs
@@ -12,7 +12,7 @@ fn main() {
         })
         .add_plugins(DefaultPlugins)
         .add_plugin(FrameTimeDiagnosticsPlugin)
-        .add_startup_system(infotext_system)
+        .add_system(infotext_system.startup())
         .add_system(change_text_system)
         .run();
 }
diff --git a/examples/ui/ui.rs b/examples/ui/ui.rs
index 7278ce21cef93..c39695b3d6599 100644
--- a/examples/ui/ui.rs
+++ b/examples/ui/ui.rs
@@ -4,7 +4,7 @@ use bevy::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .run();
 }
 
diff --git a/examples/wasm/assets_wasm.rs b/examples/wasm/assets_wasm.rs
index e1dc3ba00c49e..581f5f5e82b8f 100644
--- a/examples/wasm/assets_wasm.rs
+++ b/examples/wasm/assets_wasm.rs
@@ -13,7 +13,7 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .add_asset::<RustSourceCode>()
         .init_asset_loader::<RustSourceCodeLoader>()
-        .add_startup_system(load_asset)
+        .add_system(load_asset.startup())
         .add_system(print_asset)
         .run();
 }
diff --git a/examples/wasm/headless_wasm.rs b/examples/wasm/headless_wasm.rs
index 50af3837dfc67..02e5637def668 100644
--- a/examples/wasm/headless_wasm.rs
+++ b/examples/wasm/headless_wasm.rs
@@ -12,7 +12,7 @@ fn main() {
         )))
         .add_plugin(ScheduleRunnerPlugin::default())
         .add_plugin(LogPlugin::default())
-        .add_startup_system(hello_world_system)
+        .add_system(hello_world_system.startup())
         .add_system(counter)
         .run();
 }
diff --git a/examples/wasm/winit_wasm.rs b/examples/wasm/winit_wasm.rs
index f7a4353dfc3f2..8711432faa7f7 100644
--- a/examples/wasm/winit_wasm.rs
+++ b/examples/wasm/winit_wasm.rs
@@ -15,7 +15,7 @@ fn main() {
         })
         .add_plugins(DefaultPlugins)
         // One time greet
-        .add_startup_system(hello_wasm_system)
+        .add_system(hello_wasm_system.startup())
         // Track ticks (sanity check, whether game loop is running)
         .add_system(counter)
         // Track input events
diff --git a/examples/window/scale_factor_override.rs b/examples/window/scale_factor_override.rs
index e8ba75869f624..f541ff4b65ee5 100644
--- a/examples/window/scale_factor_override.rs
+++ b/examples/window/scale_factor_override.rs
@@ -9,7 +9,7 @@ fn main() {
             ..Default::default()
         })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_system(setup.startup())
         .add_system(toggle_override)
         .add_system(change_scale_factor)
         .run();