Remove SimpleExecutor

benches/benches/bevy_ecs/scheduling/schedule.rs

@@ -136,10 +136,5 @@ pub fn empty_schedule_run(criterion: &mut Criterion) {
         bencher.iter(|| schedule.run(app.world_mut()));
     });
 
-    let mut schedule = Schedule::default();
-    schedule.set_executor_kind(bevy_ecs::schedule::ExecutorKind::Simple);
-    group.bench_function("Simple", |bencher| {
-        bencher.iter(|| schedule.run(app.world_mut()));
-    });
     group.finish();
 }

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

@@ -1,12 +1,11 @@
 #[cfg(feature = "std")]
 mod multi_threaded;
-mod simple;
 mod single_threaded;
 
 use alloc::{borrow::Cow, vec, vec::Vec};
 use core::any::TypeId;
 
-pub use self::{simple::SimpleExecutor, single_threaded::SingleThreadedExecutor};
+pub use self::single_threaded::SingleThreadedExecutor;
 
 #[cfg(feature = "std")]
 pub use self::multi_threaded::{MainThreadExecutor, MultiThreadedExecutor};
@@ -51,9 +50,6 @@ pub enum ExecutorKind {
     /// other things, or just trying minimize overhead.
     #[cfg_attr(any(target_arch = "wasm32", not(feature = "multi_threaded")), default)]
     SingleThreaded,
-    /// Like [`SingleThreaded`](ExecutorKind::SingleThreaded) but calls [`apply_deferred`](crate::system::System::apply_deferred)
-    /// immediately after running each system.
-    Simple,
     /// Runs the schedule using a thread pool. Non-conflicting systems can run in parallel.
     #[cfg(feature = "std")]
     #[cfg_attr(all(not(target_arch = "wasm32"), feature = "multi_threaded"), default)]
@@ -324,11 +320,8 @@ mod tests {
     #[derive(Component)]
     struct TestComponent;
 
-    const EXECUTORS: [ExecutorKind; 3] = [
-        ExecutorKind::Simple,
-        ExecutorKind::SingleThreaded,
-        ExecutorKind::MultiThreaded,
-    ];
+    const EXECUTORS: [ExecutorKind; 2] =
+        [ExecutorKind::SingleThreaded, ExecutorKind::MultiThreaded];
 
     #[derive(Resource, Default)]
     struct TestState {
@@ -376,17 +369,6 @@ mod tests {
 
     fn look_for_missing_resource(_res: Res<TestState>) {}
 
-    #[test]
-    #[should_panic]
-    fn missing_resource_panics_simple() {
-        let mut world = World::new();
-        let mut schedule = Schedule::default();
-
-        schedule.set_executor_kind(ExecutorKind::Simple);
-        schedule.add_systems(look_for_missing_resource);
-        schedule.run(&mut world);
-    }
-
     #[test]
     #[should_panic]
     fn missing_resource_panics_single_threaded() {

crates/bevy_ecs/src/schedule/mod.rs

@@ -1235,12 +1235,6 @@ mod tests {
             };
         }
 
-        /// verify the [`SimpleExecutor`] supports stepping
-        #[test]
-        fn simple_executor() {
-            assert_executor_supports_stepping!(ExecutorKind::Simple);
-        }
-
         /// verify the [`SingleThreadedExecutor`] supports stepping
         #[test]
         fn single_threaded_executor() {

crates/bevy_ecs/src/schedule/schedule.rs

@@ -218,7 +218,6 @@ impl Schedules {
 
 fn make_executor(kind: ExecutorKind) -> Box<dyn SystemExecutor> {
     match kind {
-        ExecutorKind::Simple => Box::new(SimpleExecutor::new()),
         ExecutorKind::SingleThreaded => Box::new(SingleThreadedExecutor::new()),
         #[cfg(feature = "std")]
         ExecutorKind::MultiThreaded => Box::new(MultiThreadedExecutor::new()),

release-content/migration-guides/removed_simple_executor.md

@@ -0,0 +1,15 @@
+---
+title: Removed Simple Executor
+pull_requests: [18741]
+---
+
+Bevy has removed `SimpleExecutor`, one of the `SystemExecutor`s in Bevy alongside `SingleThreadedExecutor` and `MultiThreadedExecutor` (which aren't going anywhere any time soon).
+The `MultiThreadedExecutor` is great at large schedules and async heavy work, and the `SingleThreadedExecutor` is good at smaller schedules or schedules that have fewer parallelizable systems.
+So what was `SimpleExecutor` good at? Not much. That's why it was removed. Removing it reduced some maintenance and consistency burdons on maintainers, allowing them to focus on more exciting features!
+
+If you were using `SimpleExecutor`, consider upgrading to `SingleThreadedExecutor` instead, or try `MultiThreadedExecutor` if if fits the schedule.
+It's worth mentioning that `SimpleExecutor` ran deferred commands inbetween *each* system, regardless of it it was needed.
+The other executors are more efficient about this, but that means they need extra information about when to run those commands.
+In most schedules, that information comes from the contents and ordering of systems, via `before`, `after`, `chain`, etc.
+If a schedule that was previously using `SimpleExecutor` still needs commands from one system to be applied before another system runs,
+make sure that ordering is enforced explicitly by these methods, rather than implicitly by the order of `add_systems`.