#dom #ui #react #gui #ui-framework #ui-elements

dioxus-core

Core functionality for Dioxus - a concurrent renderer-agnostic Virtual DOM for interactive user experiences

28 releases

0.6.0-alpha.2 Aug 7, 2024
0.5.6 Jul 18, 2024
0.5.0 Mar 28, 2024
0.4.3 Dec 7, 2023
0.1.2 Feb 28, 2021

#2119 in Web programming

Download history 4389/week @ 2024-06-09 5078/week @ 2024-06-16 5148/week @ 2024-06-23 3462/week @ 2024-06-30 2925/week @ 2024-07-07 4424/week @ 2024-07-14 4403/week @ 2024-07-21 5216/week @ 2024-07-28 4237/week @ 2024-08-04 4458/week @ 2024-08-11 3980/week @ 2024-08-18 4681/week @ 2024-08-25 4941/week @ 2024-09-01 4134/week @ 2024-09-08 3995/week @ 2024-09-15 4117/week @ 2024-09-22

17,711 downloads per month
Used in 137 crates (34 directly)

MIT/Apache

420KB
8K SLoC

dioxus-core

dioxus-core provides a fast and featureful VirtualDom implementation for Rust.

# tokio::runtime::Runtime::new().unwrap().block_on(async {
use dioxus_core::prelude::*;
use dioxus_core::*;

let mut vdom = VirtualDom::new(app);
let real_dom = SomeRenderer::new();

loop {
    tokio::select! {
        evt = real_dom.event() => vdom.handle_event("onclick", evt, ElementId(0), true),
        _ = vdom.wait_for_work() => {}
    }
    vdom.render_immediate(&mut real_dom.apply())
}

# fn app() -> Element { VNode::empty() }
# struct SomeRenderer; impl SomeRenderer { fn new() -> SomeRenderer { SomeRenderer } async fn event(&self) -> std::rc::Rc<dyn std::any::Any> { unimplemented!() } fn apply(&self) -> Mutations { Mutations::default() } }
# });

Features

A virtualdom is an efficient and flexible tree data structure that allows you to manage state for a graphical user interface. The Dioxus VirtualDom is perhaps the most fully-featured virtualdom implementation in Rust and powers renderers running across Web, Desktop, Mobile, SSR, TUI, LiveView, and more. When you use the Dioxus VirtualDom, you immediately enable users of your renderer to leverage the wide ecosystem of Dioxus components, hooks, and associated tooling.

Some features of dioxus-core include:

  • UI components are just functions
  • State is provided by hooks
  • Deep integration with async
  • Strong focus on performance
  • Integrated hotreloading support
  • Extensible system for UI elements and their attributes

If you are just starting, check out the Guides first.

Understanding the implementation

dioxus-core is designed to be a lightweight crate that. It exposes a number of flexible primitives without being deeply concerned about the intracices of state management itself. We provide a number of useful abstractions built on these primitives in the dioxus-hooks crate as well as the dioxus-signals crate.

The important abstractions to understand are:

Usage

The dioxus crate exports the rsx macro which transforms a helpful, simpler syntax of Rust.

First, start with your app:

# use dioxus::dioxus_core::Mutations;
use dioxus::prelude::*;

// First, declare a root component
fn app() -> Element {
    rsx!{
        div { "hello world" }
    }
}

fn main() {
    // Next, create a new VirtualDom using this app as the root component.
    let mut dom = VirtualDom::new(app);

    // The initial render of the dom will generate a stream of edits for the real dom to apply
    let mutations = dom.rebuild_to_vec();
}

Contributing

License

This project is licensed under the MIT license.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Dioxus by you, shall be licensed as MIT, without any additional terms or conditions.

Dependencies

~2.4–8.5MB
~66K SLoC