dioxus-mirror/docs/guide/src/en/contributing/walkthrough_readme.md

Walkthrough of the Hello World Example Internals

This walkthrough will take you through the internals of the Hello World example program. It will explain how major parts of Dioxus internals interact with each other to take the readme example from a source file to a running application. This guide should serve as a high-level overview of the internals of Dioxus. It is not meant to be a comprehensive guide.

The Source File

We start will a hello world program. This program renders a desktop app with the text "Hello World" in a webview.

{{#include ../../../../../examples/readme.rs}}

The rsx! Macro

Before the Rust compiler runs the program, it will expand all macros. Here is what the hello world example looks like expanded:

{{#include ../../../examples/readme_expanded.rs}}

The rsx macro separates the static parts of the rsx (the template) and the dynamic parts (the dynamic_nodes and dynamic_attributes).

The static template only contains the parts of the rsx that cannot change at runtime with holes for the dynamic parts:

The dynamic_nodes and dynamic_attributes are the parts of the rsx that can change at runtime:

Launching the App

The app is launched by calling the launch function with the root component. Internally, this function will create a new web view using wry and create a virtual dom with the root component (fn app() in the readme example). This guide will not explain the renderer in-depth, but you can read more about it in the custom renderer section.

The Virtual DOM

Before we dive into the initial render in the virtual DOM, we need to discuss what the virtual DOM is. The virtual DOM is a representation of the DOM that is used to diff the current DOM from the new DOM. This diff is then used to create a list of mutations that need to be applied to the DOM to bring it into sync with the virtual DOM.

The Virtual DOM roughly looks like this:

pub struct VirtualDom {
    // All the templates that have been created or set during hot reloading
    pub(crate) templates: FxHashMap<TemplateId, FxHashMap<usize, Template<'static>>>,

    // A slab of all the scopes that have been created
    pub(crate) scopes: ScopeSlab,

    // All scopes that have been marked as dirty
    pub(crate) dirty_scopes: BTreeSet<DirtyScope>,

    // Every element is actually a dual reference - one to the template and the other to the dynamic node in that template
    pub(crate) elements: Slab<ElementRef>,

    // This receiver is used to receive messages from hooks about what scopes need to be marked as dirty
    pub(crate) rx: futures_channel::mpsc::UnboundedReceiver<SchedulerMsg>,

    // The changes queued up to be sent to the renderer
    pub(crate) mutations: Mutations<'static>,
}

What is a slab?

A slab acts like a hashmap with integer keys if you don't care about the value of the keys. It is internally backed by a dense vector which makes it more efficient than a hashmap. When you insert a value into a slab, it returns an integer key that you can use to retrieve the value later.

How does Dioxus use slabs?

Dioxus uses "synchronized slabs" to communicate between the renderer and the VDOM. When a node is created in the Virtual DOM, an (elementId, mutation) pair is passed to the renderer to identify that node, which the renderer will then render in actual DOM. These ids are also used by the Virtual Dom to reference that node in future mutations, like setting an attribute on a node or removing a node. When the renderer sends an event to the Virtual Dom, it sends the ElementId of the node that the event was triggered on. The Virtual DOM uses this id to find that node in the slab and then run the necessary event handlers.

The virtual DOM is a tree of scopes. A new Scope is created for every component when it is first rendered and recycled when the component is unmounted.

Scopes serve three main purposes:

1. They store the state of hooks used by the component
2. They store the state for the context API (for example: using use_shared_state_provider).
3. They store the current and previous versions of the VNode that was rendered, so they can be diffed to generate the set of mutations needed to re-render it.

The Initial Render

The root scope is created and rebuilt:

1. The root component is run
2. The root component returns a VNode
3. Mutations for this VNode are created and added to the mutation list (this may involve creating new child components)
4. The VNode is stored in the root's Scope.

After the root's Scope is built, all generated mutations are sent to the renderer, which applies them to the DOM.

After the initial render, the root Scope looks like this:

Waiting for Events

The Virtual DOM will only ever re-render a Scope if it is marked as dirty. Each hook is responsible for marking the Scope as dirty if the state has changed. Hooks can mark a scope as dirty by sending a message to the Virtual Dom's channel. You can see the implementations for the hooks dioxus includes by default on how this is done. Calling needs_update() on a hook will also cause it to mark its scope as dirty.

There are generally two ways a scope is marked as dirty:

1. The renderer triggers an event: An event listener on this event may be called, which may mark a component as dirty, if processing the event resulted in any generated any mutations.
2. The renderer calls wait_for_work: This polls dioxus internal future queue. One of these futures may mark a component as dirty.

Once at least one Scope is marked as dirty, the renderer can call render_with_deadline to diff the dirty scopes.

Diffing Scopes

When a user clicks the "up high" button, the root Scope will be marked as dirty by the use_state hook. The desktop renderer will then call render_with_deadline, which will diff the root Scope.

To start the diffing process, the component function is run. After the root component is run it, the root Scope will look like this:

Next, the Virtual DOM will compare the new VNode with the previous VNode and only update the parts of the tree that have changed. Because of this approach, when a component is re-rendered only the parts of the tree that have changed will be updated in the DOM by the renderer.

The diffing algorithm goes through the list of dynamic attributes and nodes and compares them to the previous VNode. If the attribute or node has changed, a mutation that describes the change is added to the mutation list.

Here is what the diffing algorithm looks like for the root Scope (red lines indicate that a mutation was generated, and green lines indicate that no mutation was generated)

Conclusion

This is only a brief overview of how the Virtual Dom works. There are several aspects not yet covered in this guide including:

• How the Virtual DOM handles async-components
• Keyed diffing
• Using bump allocation to efficiently allocate VNodes.

If you need more information about the Virtual Dom, you can read the code of the core crate or reach out to us on Discord.