DioxusLabs/dioxus

Features

• Component Architectures - Creates reusable interface components as functions that map arguments to properties.
• Cross-Platform Rendering Engines - Converts standard interface markup into native widgets or web elements for consistent cross-platform development.
• Cross-Platform UI Frameworks - Renders declarative user interfaces as native desktop, mobile, or web applications from a single codebase.
• Signal-Based Reactivity - Tracks individual state dependencies to trigger targeted component updates without re-rendering the entire application tree.
• Signals - Creates signals that automatically notify and update dependent components whenever values change.
• State Management - Controls application state through explicit signal-based reactivity that tracks reads and writes.
• Server-Side Rendering - Generates initial application state as static HTML on the server to improve load times.
• Component Property Systems - Defines properties as function arguments or structures to ensure efficient data-driven re-rendering.
• Declarative UI Macros - Transforms XML-like syntax into efficient code for high-performance rendering.
• Reactive State Management Libraries - Uses a signal-based reactivity model that automatically tracks data dependencies to trigger granular interface updates.
• Reactive UI Frameworks - Creates dynamic user interfaces that automatically update in response to state changes.
• Client-Side Hydration - Attaches event listeners to server-rendered HTML to make the page interactive.
• Cross-Platform Development Frameworks - Builds native desktop, mobile, and web applications from a single codebase with shared business logic.
• Full-Stack Web Frameworks - Builds integrated web applications with seamless communication between server-side logic and client-side interactive components.
• Reactivity Primitives - Converts non-reactive raw values into tracked dependencies to enable reactivity.
• Remote Procedure Calls - Defines functions that execute exclusively on the server with automatic argument serialization.
• Hot Reloading - Updates application code at runtime without manual rebuilds by patching functions directly.
• Data Flow Patterns - Shares data and state-modifying functions across the component tree as properties.
• Component Composition Patterns - Enables flexible interface structures by injecting nested elements into parent layouts.
• Cross-Platform Abstraction Layers - Maps a unified component model to native desktop, mobile, and web rendering targets.
• Declarative Component Libraries - Uses macro-powered syntax to define reusable interface elements and nested layouts with unidirectional data flow.
• Hooks - Initializes and retrieves persistent values that remain stable across re-renders.
• HTML Element Bindings - Defines interface elements using inline attributes and supports standard web tags.
• Change Observers - Monitors reactive values automatically to trigger side-effects or re-renders.
• Full-Stack Web Runtimes - Handles data fetching, HTML streaming, and hydration for high-performance web applications.
• HTML Streaming - Streams HTML content to the client in chunks for faster initial page loads.
• Alternative Frameworks - React-like library for multi-platform user interface development.
• UI Frameworks - Cross-platform, React-like gui library.
• Conditional Rendering Logic - Displays conditional interface blocks directly within markup using inline logic.
• List Rendering Utilities - Displays dynamic lists of elements using iterator mapping or specialized loop syntax.
• Macro-Based UI Compilers - Transforms XML-like syntax into efficient tree-building code at compile time to minimize runtime overhead.
• Effect Handlers - Executes logic automatically whenever tracked values read within an effect closure change.
• Hydration State Management - Ensures component state remains deterministic across environments through serialization and caching.
• Memoized Derivations - Calculates derived values from tracked inputs using memoized hooks that update only on dependency changes.
• Nested Routing - Organizes complex application structures by nesting route paths and grouping related views.
• Server-Side Endpoints - Creates server-side HTTP endpoints using procedural macros on asynchronous functions.
• Server-Side Rendering Engines - Generates initial HTML on the server to improve search engine visibility and provide faster page loads.
• WebSocket Managers - Manages bidirectional communication with reactive handles that track connection status.
• Desktop Integration Frameworks - Manages system windows, hardware access, and binary distribution to create standalone desktop applications.
• Dependency Injection - Shares data across a component tree by providing values at a parent level.
• Layout Systems - Arranges interface elements using standard CSS layout systems like Flexbox and Grid.
• Reactive Contexts - Bundles signals into context structures to enable descendant components to read and update shared state.
• Update Batching - Optimizes interface performance by grouping multiple state updates into single render cycles.
• Hydration Mechanisms - Serializes initial application state into static HTML and re-attaches reactive event listeners on the client.
• Layout Composition - Supports building nested layouts that update content based on route parameters.
• Route Pattern Mappers - Maps URL patterns to specific components using derived structures supporting dynamic parameters.
• Static Generation - Generates static files in a designated directory to store pre-rendered pages.
• Static Site Generators - Packages the application into a static folder containing all necessary assets for deployment.
• Data Streaming - Transfers text chunks between client and server using asynchronous generators for real-time updates.
• Asynchronous Effect Handlers - Integrates asynchronous tasks directly into the reactive lifecycle for efficient side-effect management.
• Asynchronous State Derivation - Runs asynchronous logic that automatically restarts whenever any tracked signals read within the closure are updated.
• Event Handling - Manages state updates by passing event handlers to child components.
• Expression Rendering - Inserts arbitrary code expressions directly into interface markup to dynamically render content.
• Interface State Derivations - Computes interface values dynamically from source state during rendering to maintain unidirectional data flow.
• Property Spreading Utilities - Enables flexible data injection and field overrides using spread syntax within component calls.
• State Hoisting - Shares state between components by passing reactive signals or memos down the component tree.
• Virtual DOM Reconciliation - Compares current and previous UI trees to calculate minimal patches for efficient updates.
• Programmatic Navigation - Triggers navigation by pushing or replacing history entries using a dedicated navigator.
• Route Parameter Parsers - Extracts dynamic URL segments into custom types by validating and mapping parameters.
• Server Data Streaming - Manages real-time communication using WebSockets and HTTP streams with reactive hooks.

Star history