No description
Find a file
2022-01-05 16:36:42 -05:00
.github/workflows wip: add backtrace 2022-01-03 17:44:38 -05:00
.vscode docs: getting stated guides 2022-01-03 11:32:03 -05:00
docs Merge pull request #67 from DioxusLabs/jk/router2dotoh 2022-01-05 16:35:02 -05:00
examples feat: add prevent default attribute and upgrade router 2022-01-05 16:34:24 -05:00
notes wip: remove runner on hook and then update docs 2022-01-02 02:15:04 -05:00
packages chore: switch to log tracing 2022-01-05 16:36:42 -05:00
src wip: remove runner on hook and then update docs 2022-01-02 02:15:04 -05:00
.gitignore chore: tweak gitignore to hide unnecessary vscode files 2021-06-16 11:27:10 -04:00
Cargo.toml wip: memoize dom in the prescence of identical components 2022-01-05 00:27:22 -05:00
CHANGELOG.md Release dioxus-core v0.1.3, dioxus-core-macro v0.1.2, dioxus-html v0.1.0, dioxus-desktop v0.0.0, dioxus-hooks v0.1.3, dioxus-liveview v0.1.0, dioxus-mobile v0.0.0, dioxus-router v0.1.0, dioxus-ssr v0.1.0, dioxus-web v0.0.0, dioxus v0.1.1 2021-12-15 16:07:09 -05:00
LICENSE Feat: wire up a very basic dom updater 2021-02-14 23:39:46 -05:00
README.md fix: release post link 2022-01-03 14:42:36 -05:00

🌗🚀 Dioxus

Frontend that scales.


Dioxus is a portable, performant, and ergonomic framework for building cross-platform user interfaces in Rust.

fn app(cx: Scope) -> Element {
    let mut count = use_state(&cx, || 0);

    cx.render(rsx!(
        h1 { "High-Five counter: {count}" }
        button { onclick: move |_| count += 1, "Up high!" }
        button { onclick: move |_| count -= 1, "Down low!" }
    ))
}

Dioxus can be used to deliver webapps, desktop apps, static sites, liveview apps, mobile apps (WIP), and more. At its core, Dioxus is entirely renderer agnostic and has great documentation for creating new renderers for any platform.

If you know React, then you already know Dioxus.

Unique features:

  • Desktop apps running natively (no Electron!) in less than 10 lines of code.
  • Incredibly ergonomic and powerful state management.
  • Comprehensive inline documentation - hover and guides for all HTML elements, listeners, and events.
  • Extremely memory efficient - 0 global allocations for steady-state components.
  • Multi-channel asynchronous scheduler for first-class async support.
  • And more! Read the full release post here.

Examples

All examples in this repo are desktop apps. To run an example, simply clone this repo and use cargo with the desktop feature enabled. For SSR examples, you might need to enable SSR instead.

cargo run --features desktop --example EXAMPLE

Get Started with...

Tutorial Web Desktop SSR Mobile State

Example Projects:

File Navigator (Desktop) WiFi scanner (Desktop) TodoMVC (All platforms) E-commerce w/ Tailwind (SSR/LiveView)
File Explorer Wifi Scanner Demo TodoMVC example E-commerce Example

See the awesome-dioxus page for a curated list of content in the Dioxus Ecosystem.

Why Dioxus and why Rust?

TypeScript is a fantastic addition to JavaScript, but it's still fundamentally JavaScript. TS code runs slightly slower, has tons of configuration options, and not every package is properly typed.

In contrast, Dioxus is written in Rust - which is almost like "TypeScript on steroids".

By using Rust, we gain:

  • Static types for every library
  • Immutability by default
  • A simple and intuitive module system
  • Integrated documentation (go to source actually goes to source)
  • Advanced pattern matching
  • Clean, efficient, composable iterators
  • Inline built-in unit/integration testing
  • Best-in-class error handling
  • Powerful and sane standard library
  • Flexible macro system
  • Access to crates.io

Specifically, Dioxus provides us many other assurances:

  • Proper use of immutable datastructures
  • Guaranteed error handling (so you can sleep easy at night not worrying about cannot read property of undefined)
  • Native performance on mobile
  • Direct access to system IO

And much more. Dioxus makes Rust apps just as fast to write as React apps, but affords more robustness, giving your frontend team greater confidence in making big changes in shorter time.

Why NOT Dioxus?

You shouldn't use Dioxus if:

  • You don't like the React Hooks approach to frontend
  • You need a no-std renderer
  • You want to support browsers where Wasm or asm.js are not supported.
  • You need a Send+Sync UI solution (Dioxus is not currently ThreadSafe)

Comparison with other Rust UI frameworks

Dioxus primarily emphasizes developer experience and familiarity with React principles.

  • Yew: prefers the elm pattern instead of React-hooks, no borrowed props, no SSR.
  • Percy: Supports SSR but less emphasis on state management and event handling.
  • Sycamore: VDOM-less using fine-grained reactivity, but lacking in ergonomics.
  • Dominator: Signal-based zero-cost alternative, less emphasis on community and docs.

Parity with React

Dioxus is heavily inspired by React, but we want your transition to feel like an upgrade. Dioxus is most of the way there, but missing a few key features. This parity table does not necessarily include important ecosystem crates like code blocks, markdown, resizing hooks, etc.

Feature Dioxus React Notes for Dioxus
Conditional Rendering if/then to hide/show component
Map, Iterator map/filter/reduce to produce rsx!
Keyed Components advanced diffing with keys
Web renderer for web browser
Desktop (webview) renderer for desktop
Shared State (Context) share state through the tree
Hooks memory cells in components
SSR render directly to string
Component Children cx.children() as a list of nodes
Headless components components that don't return real elements
Fragments multiple elements without a real root
Manual Props Manually pass in props with spread syntax
Controlled Inputs stateful wrappers around inputs
CSS/Inline Styles syntax for inline styles/attribute groups
Custom elements Define new element primitives
Suspense schedule future render from future/promise
Integrated error handling Gracefully handle errors with ? syntax
NodeRef gain direct access to nodes
Re-hydration Pre-render to HTML to speed up first contentful paint
Jank-Free Rendering Large diffs are segmented across frames for silky-smooth transitions
Effects Run effects after a component has been committed to render
Portals 🛠 Render nodes outside of the traditional tree structure
Cooperative Scheduling 🛠 Prioritize important events over non-important events
Server Components 🛠 Hybrid components for SPA and Server
Bundle Splitting 👀 Efficiently and asynchronously load the app
Lazy Components 👀 Dynamically load the new components as the page is loaded
1st class global state redux/recoil/mobx on top of context
Runs natively runs as a portable binary w/o a runtime (Node)
Subtree Memoization skip diffing static element subtrees
High-efficiency templates 🛠 rsx! calls are translated to templates on the DOM's side
Compile-time correct Throw errors on invalid template layouts
Heuristic Engine track component memory usage to minimize future allocations
Fine-grained reactivity 👀 Skip diffing for fine-grain updates
  • = implemented and working
  • 🛠 = actively being worked on
  • 👀 = not yet implemented or being worked on
  • = not sure if will or can implement

License

This project is licensed under the MIT license.

Contribution

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.