Struct MvuRuntime 

pub struct MvuRuntime<Event, Model, Props, Logic, Render, Spawn>
where
    Event: EventTrait,
    Model: Clone,
    Logic: MvuLogic<Event, Model, Props>,
    Render: Renderer<Props>,
    Spawn: Spawner,
{ /* private fields */ }

The MVU runtime that orchestrates the event loop.

This is the core of the framework. It:

1. Initializes the Model and initial Effects via MvuLogic::init
2. Processes events through MvuLogic::update
3. Reduces the Model to Props via MvuLogic::view
4. Delivers Props to the Renderer for rendering

The runtime creates a single Emitter that can send events from any thread. Events are queued via a lock-free MPMC channel and processed on the thread where MvuRuntime::run was called.

For testing with manual control, use TestMvuRuntime with TestRenderer (both available with the testing feature).

See the crate-level documentation for a complete example.

Type Parameters

• Event - The event type for your application
• Model - The model/state type for your application
• Props - The props type produced by the view function
• Logic - The logic implementation type (implements MvuLogic)
• Render - The renderer implementation type (implements Renderer)
• Spawn - The spawner implementation type (implements Spawner)

Implementations

impl<Event, Model, Props, Logic, Render, Spawn> MvuRuntime<Event, Model, Props, Logic, Render, Spawn>

where Event: EventTrait, Model: Clone + 'static, Props: 'static, Logic: MvuLogic<Event, Model, Props>, Render: Renderer<Props>, Spawn: Spawner,

pub fn builder( init_model: Model, logic: Logic, renderer: Render, spawner: Spawn, ) -> MvuRuntimeBuilder<Event, Model, Props, Logic, Render, Spawn>

Create a builder for configuring the runtime.

Use this when you need to customize runtime parameters like event buffer capacity.

Arguments

• init_model - The initial state
• logic - Application logic implementing MvuLogic
• renderer - Platform rendering implementation for rendering Props
• spawner - Spawner to execute async effects on your chosen runtime

Example

// For memory-constrained embedded systems
let runtime = MvuRuntime::builder(Model, MyLogic, MyRenderer, |_| {})
    .capacity(8)
    .build();

pub async fn run(self)

Initialize the runtime and run the event processing loop.

• Uses the MvuLogic::init function to create and enqueue initial side effects.
• Reduces the initial Model provided at construction to Props via MvuLogic::view.
• Renders the initial Props.
• Processes events from the channel in a loop.

This is an async function that runs the event loop. You can spawn it on your chosen runtime using the spawner, or await it directly.

Events can be emitted from any thread via the Emitter, but are always processed sequentially on the thread where this future is awaited/polled.

pub fn spawn_effect( spawner: &Spawn, emitter: &Emitter<Event>, effect: Effect<Event>, )