Dioxus Rust Framework

dioxus-autofmt is a pretty printer designed specifically for the rsx syntax tree. It uses a manual set of formatting rules to produce formatted RSX output.

Note on Stability: The output format is not guaranteed to be stable between minor versions of the crate, as formatting rules may be tweaked.

Dioxus Liveview provides adapters for running the Dioxus VirtualDom over a WebSocket connection. This allows you to run your Dioxus application logic on a server while the UI is rendered in a client browser via WebSockets.

Currently, the supported backend framework is:

• Axum

To integrate Dioxus Liveview into an existing backend framework, the library provides several primitives:

• A ThreadPool for spawning the !Send VirtualDom and interacting with it from WebSockets.
• An adapter for transforming various socket types into the LiveViewSocket type.
• Glue code to load the interpreter into your application.

dioxus-core provides a high-performance VirtualDom implementation for Rust. It serves as the engine that powers Dioxus renderers across various platforms including Web, Desktop, Mobile, SSR, TUI, and LiveView. By using dioxus-core, you gain access to the ecosystem of Dioxus components, hooks, and tooling.

Key features include:

• UI components defined as functions.
• State management via hooks.
• Deep integration with async Rust.
• High performance and integrated hot-reloading support.
• An extensible system for UI elements and attributes.

The dioxus-fullstack package provides high-level abstractions for building fullstack applications with Dioxus. It serves two primary purposes:

1. Wraps dioxus-server: It provides a simplified interface for managing the server-side component of a Dioxus application.
2. Exposes an RPC system: It enables seamless communication between the client and the server via a Remote Procedure Call (RPC) system, allowing you to call server-side functions directly from your client-side code.

The dioxus-hooks crate provides essential reactive primitives for Dioxus applications. Unlike React, these hooks are not foundational but are built on top of the primitive use_hook.

Core hooks include:

• use_signal: For managing local state.
• use_effect: For side effects.
• use_resource: For asynchronous state.
• use_memo: For derived, memoized state.
• use_coroutine: For managing long-running tasks or communication.

You can extend these capabilities by creating custom hooks.

Dioxus Fullstack provides utilities for building truly fullstack applications using the Dioxus framework. It enables features like:

• Server Functions: Call server-side code from the client as if it were a local function.
• Axum Integration: Utilities for serving and rendering Dioxus applications using the Axum server framework.
• Root Prop Passing: Passing initial props from the server to the client.
• Hot Reloading: Support for instant RSX hot reloading via dioxus-hot-reload.

rsx-rosetta is a library designed to facilitate the transition from HTML to Dioxus's native RSX (Rust Syntax Extension) templating language. It provides a central Abstract Syntax Tree (AST) that can ingest various input formats and convert them into strings or other AST representations.

Supported Inputs (Planned/Current):

• HTML
• Syn (Planned)
• Akama (Planned)
• Jinja (Planned)

This tool is useful for developers migrating existing web codebases into Dioxus, as RSX is designed to be more concise than HTML and integrates more naturally with Rust's syntax (enabling better IDE support for folding, highlighting, and block selection within .rs files).

A bare-bones Dioxus project uses a minimal organization pattern. The entry point for your application logic is src/main.rs, and any static assets required by your application should be placed in the assets/ directory. Dependencies and feature flags are managed via Cargo.toml.

project/
├─ assets/ # Any assets that are used by the app should be placed here
├─ src/
│  ├─ main.rs # main.rs is the entry point to your application
├─ Cargo.toml # Defines dependencies and feature flags