Revived #18741, Remove SimpleExecutor. (#21176)

# Objective

Revive #18741 :

Reduce complexity and code duplication of schedule executors. This is an
alternative to fix #18453.

It sounds like `SimpleExecutor` was a temporary solution to "sync
points" in schedules, but now those can be inferred, so `SimpleExecutor`
is unnecessary now.

Further, `SimpleExecutor` and `SingleThreadedExecutor` were *very*
similar, which was becoming a consistency and code quality headache.

## Solution

Remove `SimpleExecutor`.

## Testing

CI

Author: ElliottjPierce

benches/benches/bevy_ecs/scheduling/schedule.rs

@@ -136,11 +136,5 @@ pub fn empty_schedule_run(criterion: &mut Criterion) {
         bencher.iter(|| schedule.run(app.world_mut()));
     });
 
-    let mut schedule = Schedule::default();
-    #[expect(deprecated, reason = "We still need to test/bench this.")]
-    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,14 +1,12 @@
 #[cfg(feature = "std")]
 mod multi_threaded;
-mod simple;
 mod single_threaded;
 
 use alloc::{vec, vec::Vec};
 use bevy_utils::prelude::DebugName;
 use core::any::TypeId;
 
-#[expect(deprecated, reason = "We still need to support this.")]
-pub use self::{simple::SimpleExecutor, single_threaded::SingleThreadedExecutor};
+pub use self::single_threaded::SingleThreadedExecutor;
 
 #[cfg(feature = "std")]
 pub use self::multi_threaded::{MainThreadExecutor, MultiThreadedExecutor};
@@ -62,13 +60,6 @@ pub enum ExecutorKind {
         default
     )]
     SingleThreaded,
-    /// Like [`SingleThreaded`](ExecutorKind::SingleThreaded) but calls [`apply_deferred`](crate::system::System::apply_deferred)
-    /// immediately after running each system.
-    #[deprecated(
-        since = "0.17.0",
-        note = "Use SingleThreaded instead. See https://github.com/bevyengine/bevy/issues/18453 for motivation."
-    )]
-    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)]
@@ -288,6 +279,7 @@ mod __rust_begin_short_backtrace {
         black_box(system.run_unsafe((), world))
     }
 
+    #[cfg(feature = "std")]
     #[inline(never)]
     pub(super) fn run(
         system: &mut ScheduleSystem,
@@ -332,12 +324,8 @@ mod tests {
     #[derive(Component)]
     struct TestComponent;
 
-    const EXECUTORS: [ExecutorKind; 3] = [
-        #[expect(deprecated, reason = "We still need to test this.")]
-        ExecutorKind::Simple,
-        ExecutorKind::SingleThreaded,
-        ExecutorKind::MultiThreaded,
-    ];
+    const EXECUTORS: [ExecutorKind; 2] =
+        [ExecutorKind::SingleThreaded, ExecutorKind::MultiThreaded];
 
     #[derive(Resource, Default)]
     struct TestState {
@@ -388,18 +376,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();
-
-        #[expect(deprecated, reason = "We still need to test this.")]
-        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/executor/simple.rs

@@ -1283,13 +1283,6 @@ mod tests {
             };
         }
 
-        /// verify the [`SimpleExecutor`] supports stepping
-        #[test]
-        #[expect(deprecated, reason = "We still need to test this.")]
-        fn simple_executor() {
-            assert_executor_supports_stepping!(ExecutorKind::Simple);
-        }
-
         /// verify the [`SingleThreadedExecutor`] supports stepping
         #[test]
         fn single_threaded_executor() {

crates/bevy_ecs/src/schedule/mod.rs

@@ -216,8 +216,6 @@ impl Schedules {
 
 fn make_executor(kind: ExecutorKind) -> Box<dyn SystemExecutor> {
     match kind {
-        #[expect(deprecated, reason = "We still need to support this.")]
-        ExecutorKind::Simple => Box::new(SimpleExecutor::new()),
         ExecutorKind::SingleThreaded => Box::new(SingleThreadedExecutor::new()),
         #[cfg(feature = "std")]
         ExecutorKind::MultiThreaded => Box::new(MultiThreadedExecutor::new()),

crates/bevy_ecs/src/schedule/schedule.rs

@@ -0,0 +1,16 @@
+---
+title: Removed `SimpleExecutor`
+pull_requests: [21176]
+---
+
+Bevy has removed the previously deprecated `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 burdens 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`.
+If you are looking for a quick fix, `chain` is the easiest way to do this.