Hide fixed_update behind a feature flag

Cargo.toml

@@ -85,8 +85,12 @@ default = [
   "default_font",
   "webgl2",
   "sysinfo_plugin",
+  "fixed_time",
 ]
 
+# Provides the fixed update schedules
+fixed_time = ["bevy_internal/fixed_time"]
+
 # Force dynamic linking, which improves iterative compile times
 dynamic_linking = ["dep:bevy_dylib", "bevy_internal/dynamic_linking"]
 

crates/bevy_app/Cargo.toml

@@ -11,13 +11,14 @@ keywords = ["bevy"]
 [features]
 trace = []
 bevy_debug_stepping = []
-default = ["bevy_reflect"]
+default = ["bevy_reflect", "fixed_time"]
 bevy_reflect = ["dep:bevy_reflect", "bevy_ecs/bevy_reflect"]
 reflect_functions = [
   "bevy_reflect",
   "bevy_reflect/functions",
   "bevy_ecs/reflect_functions",
 ]
+fixed_time = []
 
 [dependencies]
 # bevy

crates/bevy_app/src/lib.rs

@@ -31,13 +31,17 @@ pub use terminal_ctrl_c_handler::*;
 ///
 /// This includes the most common types in this crate, re-exported for your convenience.
 pub mod prelude {
+    #[cfg(feature = "fixed_time")]
+    pub use crate::main_schedule::{
+        FixedFirst, FixedLast, FixedPostUpdate, FixedPreUpdate, FixedUpdate, RunFixedMainLoop,
+        RunFixedMainLoopSystem,
+    };
     #[doc(hidden)]
     pub use crate::{
         app::{App, AppExit},
         main_schedule::{
-            First, FixedFirst, FixedLast, FixedPostUpdate, FixedPreUpdate, FixedUpdate, Last, Main,
-            PostStartup, PostUpdate, PreStartup, PreUpdate, RunFixedMainLoop,
-            RunFixedMainLoopSystem, SpawnScene, Startup, Update,
+            First, Last, Main, PostStartup, PostUpdate, PreStartup, PreUpdate, SpawnScene, Startup,
+            Update,
         },
         sub_app::SubApp,
         Plugin, PluginGroup,

crates/bevy_app/src/main_schedule.rs

@@ -1,13 +1,11 @@
 use crate::{App, Plugin};
+#[cfg(feature = "fixed_time")]
+use bevy_ecs::schedule::IntoSystemSetConfigs;
 use bevy_ecs::{
-    schedule::{
-        ExecutorKind, InternedScheduleLabel, IntoSystemSetConfigs, Schedule, ScheduleLabel,
-        SystemSet,
-    },
+    schedule::{ExecutorKind, InternedScheduleLabel, Schedule, ScheduleLabel, SystemSet},
     system::{Local, Resource},
     world::{Mut, World},
 };
-
 /// The schedule that contains the app logic that is evaluated each tick of [`App::update()`].
 ///
 /// By default, it will run the following schedules in the given order:
@@ -85,20 +83,23 @@ pub struct PreUpdate;
 /// [`RunFixedMainLoop`] will *not* be parallelized between each other.
 ///
 /// See the [`Main`] schedule for some details about how schedules are run.
+#[cfg(feature = "fixed_time")]
 #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct RunFixedMainLoop;
 
 /// Runs first in the [`FixedMain`] schedule.
 ///
 /// See the [`FixedMain`] schedule for details on how fixed updates work.
 /// See the [`Main`] schedule for some details about how schedules are run.
+#[cfg(feature = "fixed_time")]
 #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct FixedFirst;
 
 /// The schedule that contains logic that must run before [`FixedUpdate`].
 ///
 /// See the [`FixedMain`] schedule for details on how fixed updates work.
 /// See the [`Main`] schedule for some details about how schedules are run.
+#[cfg(feature = "fixed_time")]
 #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct FixedPreUpdate;
 
@@ -114,6 +115,7 @@ pub struct FixedPreUpdate;
 /// See the [`Update`] schedule for examples of systems that *should not* use this schedule.
 /// See the [`FixedMain`] schedule for details on how fixed updates work.
 /// See the [`Main`] schedule for some details about how schedules are run.
+#[cfg(feature = "fixed_time")]
 #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct FixedUpdate;
 
@@ -122,13 +124,15 @@ pub struct FixedUpdate;
 ///
 /// See the [`FixedMain`] schedule for details on how fixed updates work.
 /// See the [`Main`] schedule for some details about how schedules are run.
+#[cfg(feature = "fixed_time")]
 #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct FixedPostUpdate;
 
 /// The schedule that runs last in [`FixedMain`]
 ///
 /// See the [`FixedMain`] schedule for details on how fixed updates work.
 /// See the [`Main`] schedule for some details about how schedules are run.
+#[cfg(feature = "fixed_time")]
 #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct FixedLast;
 
@@ -141,6 +145,7 @@ pub struct FixedLast;
 /// See [this example](https://github.com/bevyengine/bevy/blob/latest/examples/time/time.rs).
 ///
 /// See the [`Main`] schedule for some details about how schedules are run.
+#[cfg(feature = "fixed_time")]
 #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct FixedMain;
 
@@ -196,6 +201,7 @@ impl Default for MainScheduleOrder {
             labels: vec![
                 First.intern(),
                 PreUpdate.intern(),
+                #[cfg(feature = "fixed_time")]
                 RunFixedMainLoop.intern(),
                 Update.intern(),
                 SpawnScene.intern(),
@@ -285,28 +291,31 @@ impl Plugin for MainSchedulePlugin {
         // simple "facilitator" schedules benefit from simpler single threaded scheduling
         let mut main_schedule = Schedule::new(Main);
         main_schedule.set_executor_kind(ExecutorKind::SingleThreaded);
-        let mut fixed_main_schedule = Schedule::new(FixedMain);
-        fixed_main_schedule.set_executor_kind(ExecutorKind::SingleThreaded);
-        let mut fixed_main_loop_schedule = Schedule::new(RunFixedMainLoop);
-        fixed_main_loop_schedule.set_executor_kind(ExecutorKind::SingleThreaded);
 
         app.add_schedule(main_schedule)
-            .add_schedule(fixed_main_schedule)
-            .add_schedule(fixed_main_loop_schedule)
             .init_resource::<MainScheduleOrder>()
-            .init_resource::<FixedMainScheduleOrder>()
-            .add_systems(Main, Main::run_main)
-            .add_systems(FixedMain, FixedMain::run_fixed_main)
-            .configure_sets(
-                RunFixedMainLoop,
-                (
-                    RunFixedMainLoopSystem::BeforeFixedMainLoop,
-                    RunFixedMainLoopSystem::FixedMainLoop,
-                    RunFixedMainLoopSystem::AfterFixedMainLoop,
-                )
-                    .chain(),
-            );
+            .add_systems(Main, Main::run_main);
 
+        #[cfg(feature = "fixed_time")]
+        {
+            let mut fixed_main_schedule = Schedule::new(FixedMain);
+            fixed_main_schedule.set_executor_kind(ExecutorKind::SingleThreaded);
+            let mut fixed_main_loop_schedule = Schedule::new(RunFixedMainLoop);
+            fixed_main_loop_schedule.set_executor_kind(ExecutorKind::SingleThreaded);
+            app.add_schedule(fixed_main_schedule)
+                .add_schedule(fixed_main_loop_schedule)
+                .init_resource::<FixedMainScheduleOrder>()
+                .add_systems(FixedMain, FixedMain::run_fixed_main)
+                .configure_sets(
+                    RunFixedMainLoop,
+                    (
+                        RunFixedMainLoopSystem::BeforeFixedMainLoop,
+                        RunFixedMainLoopSystem::FixedMainLoop,
+                        RunFixedMainLoopSystem::AfterFixedMainLoop,
+                    )
+                        .chain(),
+                );
+        }
         #[cfg(feature = "bevy_debug_stepping")]
         {
             use bevy_ecs::schedule::{IntoSystemConfigs, Stepping};
@@ -317,12 +326,14 @@ impl Plugin for MainSchedulePlugin {
 
 /// Defines the schedules to be run for the [`FixedMain`] schedule, including
 /// their order.
+#[cfg(feature = "fixed_time")]
 #[derive(Resource, Debug)]
 pub struct FixedMainScheduleOrder {
     /// The labels to run for the [`FixedMain`] schedule (in the order they will be run).
     pub labels: Vec<InternedScheduleLabel>,
 }
 
+#[cfg(feature = "fixed_time")]
 impl Default for FixedMainScheduleOrder {
     fn default() -> Self {
         Self {
@@ -337,6 +348,7 @@ impl Default for FixedMainScheduleOrder {
     }
 }
 
+#[cfg(feature = "fixed_time")]
 impl FixedMainScheduleOrder {
     /// Adds the given `schedule` after the `after` schedule
     pub fn insert_after(&mut self, after: impl ScheduleLabel, schedule: impl ScheduleLabel) {
@@ -359,6 +371,7 @@ impl FixedMainScheduleOrder {
     }
 }
 
+#[cfg(feature = "fixed_time")]
 impl FixedMain {
     /// A system that runs the fixed timestep's "main schedule"
     pub fn run_fixed_main(world: &mut World) {
@@ -381,6 +394,7 @@ impl FixedMain {
 ///
 /// Note that in contrast to most other Bevy schedules, systems added directly to
 /// [`RunFixedMainLoop`] will *not* be parallelized between each other.
+#[cfg(feature = "fixed_time")]
 #[derive(Debug, Hash, PartialEq, Eq, Copy, Clone, SystemSet)]
 pub enum RunFixedMainLoopSystem {
     /// Runs before the fixed update logic.

crates/bevy_gizmos/Cargo.toml

@@ -9,8 +9,10 @@ license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
 [features]
+default = ["fixed_time"]
 webgl = []
 webgpu = []
+fixed_time = ["bevy_app/fixed_time"]
 bevy_render = ["dep:bevy_render", "bevy_core_pipeline"]
 
 [dependencies]

crates/bevy_gizmos/src/lib.rs

@@ -72,6 +72,15 @@ pub mod prelude {
     pub use crate::light::{LightGizmoColor, LightGizmoConfigGroup, ShowLightGizmo};
 }
 
+#[cfg(not(feature = "fixed_time"))]
+use bevy_app::First;
+use bevy_app::{App, Last, Plugin};
+#[cfg(feature = "fixed_time")]
+use bevy_app::{FixedFirst, FixedLast, RunFixedMainLoop};
+use bevy_asset::{Asset, AssetApp, Assets, Handle};
+use bevy_color::LinearRgba;
+#[cfg(feature = "bevy_render")]
+use bevy_ecs::component::Component;
 #[cfg(feature = "bevy_render")]
 use bevy_ecs::{
     query::ROQueryItem,
@@ -80,12 +89,6 @@ use bevy_ecs::{
         Commands, SystemParamItem,
     },
 };
-
-use bevy_app::{App, FixedFirst, FixedLast, Last, Plugin, RunFixedMainLoop};
-use bevy_asset::{Asset, AssetApp, Assets, Handle};
-use bevy_color::LinearRgba;
-#[cfg(feature = "bevy_render")]
-use bevy_ecs::component::Component;
 use bevy_ecs::{
     schedule::{IntoSystemConfigs, SystemSet},
     system::{Res, ResMut, Resource},
@@ -246,29 +249,46 @@ impl AppGizmoBuilder for App {
 
         // These handles are safe to mutate in any order
         self.allow_ambiguous_resource::<LineGizmoHandles>();
-
-        self.init_resource::<GizmoStorage<Config, ()>>()
-            .init_resource::<GizmoStorage<Config, Fixed>>()
-            .init_resource::<GizmoStorage<Config, Swap<Fixed>>>()
-            .add_systems(
-                RunFixedMainLoop,
-                start_gizmo_context::<Config, Fixed>
-                    .in_set(bevy_app::RunFixedMainLoopSystem::BeforeFixedMainLoop),
-            )
-            .add_systems(FixedFirst, clear_gizmo_context::<Config, Fixed>)
-            .add_systems(FixedLast, collect_requested_gizmos::<Config, Fixed>)
-            .add_systems(
-                RunFixedMainLoop,
-                end_gizmo_context::<Config, Fixed>
-                    .in_set(bevy_app::RunFixedMainLoopSystem::AfterFixedMainLoop),
-            )
-            .add_systems(
-                Last,
-                (
-                    propagate_gizmos::<Config, Fixed>.before(UpdateGizmoMeshes),
-                    update_gizmo_meshes::<Config>.in_set(UpdateGizmoMeshes),
-                ),
-            );
+        #[cfg(feature = "fixed_time")]
+        {
+            self.init_resource::<GizmoStorage<Config, ()>>()
+                .init_resource::<GizmoStorage<Config, Fixed>>()
+                .init_resource::<GizmoStorage<Config, Swap<Fixed>>>()
+                .add_systems(
+                    RunFixedMainLoop,
+                    start_gizmo_context::<Config, Fixed>
+                        .in_set(bevy_app::RunFixedMainLoopSystem::BeforeFixedMainLoop),
+                )
+                .add_systems(FixedFirst, clear_gizmo_context::<Config, Fixed>)
+                .add_systems(FixedLast, collect_requested_gizmos::<Config, Fixed>)
+                .add_systems(
+                    RunFixedMainLoop,
+                    end_gizmo_context::<Config, Fixed>
+                        .in_set(bevy_app::RunFixedMainLoopSystem::AfterFixedMainLoop),
+                )
+                .add_systems(
+                    Last,
+                    (
+                        propagate_gizmos::<Config, Fixed>.before(UpdateGizmoMeshes),
+                        update_gizmo_meshes::<Config>.in_set(UpdateGizmoMeshes),
+                    ),
+                );
+        }
+        #[cfg(not(feature = "fixed_time"))]
+        {
+            self.init_resource::<GizmoStorage<Config, ()>>()
+                .init_resource::<GizmoStorage<Config, Fixed>>()
+                .init_resource::<GizmoStorage<Config, Swap<Fixed>>>()
+                .add_systems(First, clear_gizmo_context::<Config, Fixed>)
+                .add_systems(
+                    Last,
+                    (
+                        collect_requested_gizmos::<Config, Fixed>,
+                        propagate_gizmos::<Config, Fixed>.before(UpdateGizmoMeshes),
+                        update_gizmo_meshes::<Config>.in_set(UpdateGizmoMeshes),
+                    ),
+                );
+        }
 
         self
     }

crates/bevy_internal/Cargo.toml

@@ -21,6 +21,13 @@ trace = [
   "bevy_hierarchy/trace",
   "bevy_winit?/trace",
 ]
+
+fixed_time = [
+  "bevy_gizmos/fixed_time",
+  "bevy_app/fixed_time",
+  "bevy_time/fixed_time",
+]
+
 trace_chrome = ["bevy_log/tracing-chrome"]
 trace_tracy = ["bevy_render?/tracing-tracy", "bevy_log/tracing-tracy"]
 trace_tracy_memory = ["bevy_log/trace_tracy_memory"]

crates/bevy_time/Cargo.toml

@@ -9,8 +9,9 @@ license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
 [features]
-default = ["bevy_reflect"]
+default = ["bevy_reflect", "fixed_time"]
 serialize = ["serde"]
+fixed_time = ["bevy_app/fixed_time"]
 
 [dependencies]
 # bevy