Struct App 

pub struct App { /* private fields */ }

The central application object: owns the ECS world, resources, and every registered system, organized into SystemStages.

Built by chaining .add_plugin(...)/.add_system(...)/etc. calls — every builder method takes self by value and returns Self, so a typical setup reads as one expression ending in App::run:

App::new()
    .add_plugin(GraphicsPlugin)
    .add_system(SystemStage::Ready, setup)
    .add_system(SystemStage::Update, my_game_logic)
    .run();

Implementations

impl App

pub fn new() -> Self

Creates a fresh App with no plugins, systems, or resources beyond the small set every app needs internally (a command buffer, AppExit, BackendReady). Nothing is registered automatically — windowing, the GPU backend, Time are all opt-in via .add_plugin(...).

pub fn insert_resource<T: 'static>(self, resource: T) -> Self

Inserts a resource, replacing any existing value of the same type.

pub fn remove_resource<T: 'static>(self) -> Self

Removes a resource, if present. A no-op if it wasn’t there.

pub fn add_plugin<P: Plugin>(self, plugin: P) -> Self

Runs a Plugin’s build, which may insert resources, register systems, or add further plugins of its own.

pub fn add_system<S, Params>( self, stage: SystemStage, system: impl Into<SystemConfig<S, Params>>, ) -> Self

where Params: 'static, S: IntoSystem<Params> + 'static,

Registers system to run on stage, every tick that stage runs. See SystemStage for what each stage is for and when it runs. system may be a bare system, or one wrapped with .after(...)/.before(...)/.priority(...) to order/prioritize it relative to another system on the same stage — see IntoSystemConfig.

pub fn add_systems(self, stage: SystemStage, chain: SystemChain) -> Self

Registers every system in chain — built by calling .chain() on a tuple of systems, see Chain — to run on stage, in that exact relative order.

pub fn add_event<T: 'static + Send + Sync>(self) -> Self

Registers event type T, making EventReader<T>/ EventWriter<T> usable as system parameters. Idempotent — calling this twice for the same T (e.g. from two different plugins that both want it) is a no-op the second time, not a double registration.

pub fn add_observer<E: 'static + Send + Sync, Params: 'static>( self, observer: impl IntoObserverSystem<E, Params> + 'static, ) -> Self

Registers observer to run whenever Commands::trigger sends an E, once the current stage finishes syncing (same tick, not deferred to the next one). Multiple observers can be registered for the same E — every one of them runs.

pub fn set_runner(self, runner: impl FnOnce(App) + 'static) -> Self

Overrides how the main loop is driven — e.g. a windowing plugin installs one that hands control to its own event loop instead of the default headless polling loop.

pub fn with_logging(self) -> Self

Initializes a tracing_subscriber formatter so tracing::info!/ warn!/error! calls made throughout the engine actually print somewhere.

pub fn update(&mut self)

Runs every schedule for a single tick: while the GPU backend isn’t ready yet, only the internal gpu_schedules run; once it is, SystemStage::Ready runs (if anything is still registered there, exactly once ever), then every other stage runs in order. Called automatically by the default loop in App::run — call it yourself only if you’re driving the loop from somewhere else (e.g. inside a custom runner installed via App::set_runner).

pub fn should_exit(&self) -> bool

true once AppExit has been set — the default loop in App::run checks this after every tick.

pub fn run(self)

Consumes the app and runs it. SystemStage::Startup runs first, exactly once, before anything else. Then, if a runner was installed (e.g. by a windowing plugin via App::set_runner), control is handed to it — this call doesn’t return until that runner decides to stop. Otherwise, falls back to a default headless loop that calls App::update repeatedly until App::should_exit.

Trait Implementations

impl Default for App

fn default() -> Self

Returns the “default value” for a type.