Struct App 

pub struct App { /* private fields */ }

Main application struct that manages the game loop and plugin lifecycle

The App coordinates:

• Plugin registration and initialization
• System scheduling (startup and per-frame)
• Main loop execution
• Resource cleanup on shutdown

Example

use kon::prelude::*;

fn main() {
    Kon::new()
        .add_plugin(DefaultPlugins)
        .add_startup_system(setup)
        .add_system(update)
        .run();

Implementations

impl App

pub fn new() -> App

Creates a new App instance

Initializes logging and installs custom panic handler

pub fn set_driver<D>(&mut self, driver: D) -> &mut App

where D: Driver + 'static,

Sets a custom driver for the game loop

Replaces the default driver with a custom implementation. This allows control over how the application lifecycle executes (e.g., fixed timestep, event-driven loops, or headless simulation).

Must be called before run(). If not set, DefaultDriver is used.

Returns

Self reference for method chaining

Example

Kon::new()
    .set_driver(CustomDriver)
    .run();

pub fn add_plugin<P>(&mut self, plugin: P) -> &mut App

where P: Plugin,

Adds a plugin to the application

Plugins extend engine functionality. Common examples:

• EcsPlugin - Registers the World
• WindowPlugin - Creates the game window
• DefaultPlugins - Bundle of core plugins

Returns

Self reference for method chaining

pub fn add_startup_system<F>(&mut self, system: F) -> &mut App

where F: FnMut(&mut Context) + 'static,

Adds a startup system that runs once at application start

Returns

Self reference for method chaining

pub fn add_system<F>(&mut self, system: F) -> &mut App

where F: FnMut(&mut Context) + 'static,

Adds a system that runs every frame

Returns

Self reference for method chaining

pub fn add_sync_system<F>(&mut self, system: F) -> &mut App

where F: FnMut(&mut Context) + 'static,

Adds a system that runs at the end of every frame

Returns

Self reference for method chaining

pub fn register<R>(&mut self, resource: R) -> &mut App

where R: Any + Send + Sync + 'static,

Registers a global resource accessible from all systems

Resources are stored in Context and accessible via ctx.global::<T>().

Returns

Self reference for method chaining

pub fn context(&self) -> &Context

Returns an immutable reference to the engine context

pub fn context_mut(&mut self) -> &mut Context

Returns a mutable reference to the engine context

pub fn initialize(&mut self)

Initializes the application

Called automatically by the driver. This method:

1. Calls ready() on all registered plugins
2. Executes all startup systems once

Should not be called manually unless implementing a custom driver.

pub fn tick(&mut self)

Executes a single frame update

Called automatically by the driver each frame. This method:

1. Updates time tracking
2. Runs all registered systems
3. Clears frame events

Should not be called manually unless implementing a custom driver.

pub fn cleanup(&mut self)

Cleans up the application

Called automatically by the driver on exit. This method calls cleanup() on all registered plugins, allowing them to release resources.

Should not be called manually unless implementing a custom driver.

pub fn run(&mut self)

Starts the application and runs the game loop

This is the entry point for executing the engine. It:

1. Transfers ownership of the app to the configured driver
2. The driver handles initialization, update loop, and cleanup
3. Blocks until the application exits

The driver is consumed during execution. If no custom driver was set via set_driver(), the DefaultDriver is used.

Example

Kon::new()
    .add_plugin(DefaultPlugins)
    .add_system(update_system)
    .run();  // Blocks here until exit

Trait Implementations

impl Default for App

fn default() -> App

Returns the “default value” for a type.