dioxus

Fullstack GUI library for web, desktop, mobile, and more.

APACHE-2.0 License

Downloads
4
Stars
18K
Committers
257
View Code on GitHub Visit Website View on X
Ecosystems: Android, React, Rust, CSS

Bot releases are visible (Hide)

dioxus - v0.6.0-alpha.2 Latest Release

Published by ealmloff 2 months ago

Dioxus 0.6.0 Alpha

Dioxus 0.6 includes improvements to several areas of dioxus. The highlights are:

  • Asset improvements
  • Head elements
  • RSX autocomplete
  • Improved hot reloading
  • Suspense and streaming
  • Error boundaries
  • A new TUI!
  • Documentation improvements
  • Blitz rewrite

Asset Stabilization

We introduced our new asset system, Manganis, in an alpha state with the 0.5 release. Dioxus 0.6 stabilizes the asset system and fixes several bugs and performance issues. You can try out the new linker based asset system by including an asset! anywhere in your code. It will automatically be optimized and bundled across all platforms:

rsx! {
    img { src: asset!("./assets/myimg.png") }
}

Head Elements

In addition to the Manganis asset system, dioxus 0.6 includes a new way to include assets into your html. The new Script, Link, Style , and Meta components let you link to assets anywhere in your html. These components will automatically be hoisted into the <head> across all platforms and deduplicated by the source:

#[component]
fn MyStyledComponent() -> {
    rsx! {
        head::Link {
            rel: "stylesheet",
            href: asset!("./assets/style.css")
        }
        "This component is styled"
    }
}

Autocomplete and improved errors for RSX

RSX now supports autocomplete everywhere. In addition to expressions, elements, components and attributes now autocomplete correctly:

https://github.com/user-attachments/assets/10781eef-de07-491d-aaa3-f75949b32190

The new version of RSX also features better error messages for incorrect markup:

Incorrect markup error message

Supercharged Hot Reloading

In 0.6, RSX hot reloading is much more consistent. You can move around and duplicate expressions anywhere in an rsx block or create new literals anywhere in an rsx block. This means you can now create new formatted text nodes, new formatted attributes or tweak properties on the fly without recompiling!

https://github.com/user-attachments/assets/15bd7d6d-24ae-4cc9-abde-e063879cd842

Suspense and Streaming

Async is a core component of any UI framework. Dioxus provides hooks to handle async state. You can start a future and handle the loading and resolved states within the component:

#[component]
fn Article() -> Element {
    // Use resource starts a future in the background and returns the current state
    let article = use_resource(fetch_article);

    rsx! {
        // You can match the state of the future to render either a loading state or the resolved state
        match article() {
            Some(article) => rsx! { "{article}" },
            None =>  rsx! { p { "Loading..." } }
        }
    }
}

This works ok if you have a single future, but it quickly gets messy when combining many futures into one UI:

#[component]
fn Article() -> Element {
    // Use resource starts a future in the background and returns the current state
    let Some(title) = use_resource(fetch_title).cloned() else {
         return rsx! { "loading..." }
    };
    let Some(article) = use_resource(fetch_article).cloned() else {
         return rsx! { "loading..." }
    };
    let Some(category) = use_resource(move || article.title()).cloned() else {
         return rsx! { "loading..." }
    };

    rsx! {
        Title { "{title}" }
        Body { category, article }
    }
}

In addition to hooks, we need a way to display a different state when async is loading. Dioxus 0.6 introduces a new core primitive for async UI called suspense boundaries. A suspense boundary is a component that renders a placeholder when any child component is loading:

rsx! {
    SuspenseBoundary {
        fallback: |context: SuspenseContext| rsx! {
                // Render a loading placeholder if any child component is suspended
                "Loading..."
        },
        Article {}
    }
}

In any child component, you can just bubble up the pending state with ? to pause rendering until the future is finished:

#[component]
fn Article() -> Element {
    let title = use_resource(fetch_title).suspend()?;
    let article = use_resource(fetch_article).suspend()?;
    let category = use_resource(move || article.title()).suspend()?;

    // Since we bubbled up all the pending futures with `?` we can just
    // handle the happy path in the component
    rsx! {
        Title { "{title}" }
        Body { category, article }
    }
}

Along with suspense boundaries, dioxus fullstack also supports streaming each suspense boundary in from the server. Instead of waiting for the whole page to load, dioxus fullstack streams in each chunk with the resolved futures as they finish:

https://github.com/user-attachments/assets/7aa94563-78b3-4f17-be1d-4cad77efd238

Error boundaries

0.6 also introduces error boundaries which let you display an error message if any child component runs into an error:

#[component]
fn Root() -> Element {
    rsx! {
        ErrorBoundary {
            handle_error: |errors: ErrorContext| {
                match errors.show() {
                    // Render the view the child component through with the error
                    Some(view) => view,
                    // Or a fallback if the error doesn't come with a view
                    None => rsx! {
                        pre {
                            color: "red",
                            "oops, we ran into an error\n{errors:#?}"
                        }
                    }
                }
            },
            Contents {}
        }
    }
}

You can throw an error from any child component while rendering or handling events:

#[component]
fn Double(input: String) -> Element {
    // You can use ? to throw an event during rendering
    let parsed: f32 = input.parse()?;
    let doubled = parsed * 2.0;
    
    rsx! {
        "{doubled}"
    }
}

#[component]
fn DoubleButton(mut count: Signal<u8>) -> Element {
    rsx! {
        button {
            onclick: move |_| {
                // Errors can have an associated view which the error boundary can
                // choose to show
                let doubled = count().checked_mul(2).show(|_|
                    rsx! { "multiplying {count} by 2 would overflow the u8" }
                )?;
                count.set(doubled);

                Ok(())
            },
            "Double!"
        }
    }
}

DX TUI

The Dioxus CLI has been rewritten to support a TUI with build progress, and multiple views for logs. It has shortcuts for common actions, and displays progress in both the TUI and the site as the project loads:

https://github.com/user-attachments/assets/6136627b-3760-4e1e-aaca-2e7315558e32

Blitz Rewrite

Blitz has been rewritten to use Firefox's browser engine, Stylo. The new version of Blitz is much more capable with proper accessibility support, IME support, and better text support. Blitz should be a drop in replacement for dioxus desktop for the small subset of HTML it supports. Keep in mind Blitz is still experimental and not ready for production use. You can try Blitz by adding dioxus_blitz from the git repo:

cargo add dioxus-blitz --git https://github.com/DioxusLabs/blitz

Launching your Dioxus app with the blitz renderer:

dioxus_blitz::launch(app);

Dioxus with Blitz

Ergonomic tweaks

Dioxus 0.6 also includes a number of smaller ergonomic tweaks that should help dioxus feel a lot more consistent

Static Generation

Dioxus 0.6 splits out static generation into its own platform to make it easier to set up:

//! Static generation works out of the box with the router. Just add a router anywhere in your app and it will generate any static routes for you!

#![allow(unused)]
use dioxus::prelude::*;

// Generate all routes and output them to the static path
fn main() {
    launch(|| {
        rsx! {
            Router::<Route> {}
        }
    });
}

#[derive(Clone, Routable, Debug, PartialEq)]
enum Route {
    #[route("/")]
    Home {},

    #[route("/blog")]
    Blog,
}

#[component]
fn Blog() -> Element {
    rsx! {
        Link { to: Route::Home {}, "Go to counter" }
        table {
            tbody {
                for _ in 0..100 {
                    tr {
                        for _ in 0..100 {
                            td { "hello!" }
                        }
                    }
                }
            }
        }
    }
}

#[component]
fn Home() -> Element {
    let mut count = use_signal(|| 0);

    rsx! {
        Link { to: Route::Blog {}, "Go to blog" }
        div {
            h1 { "High-Five counter: {count}" }
            button { onclick: move |_| count += 1, "Up high!" }
            button { onclick: move |_| count -= 1, "Down low!" }
        }
    }
}

Fullstack State

Fullstack state now propagates from the launch builder into server functions which makes it much easier to set up state that is shared throughout your application like a database pool:

fn main() {
     LaunchBuilder::new().with_context(1234567890u32).launch(app);
}

#[server]
async fn get_server_data() -> Result<String, ServerFnError> {
     let FromContext(context): FromContext<u32> = extract().await?;
     Ok(format!("the context was {context}"))
}

Callbacks

Dioxus 0.6 expands EventHandlers into callbacks which let you both take and return arguments. Callbacks are a Copy version of Box<dyn FnMut(Args) -> Ret> built specifically for UI in Rust

#[component]
fn DoubleButton(double: Callback<u32, u32>) -> Element {
    let mut count = use_signal(|| 1);

    rsx! {
        button {
            // Callbacks let you easily inject custom logic into your components
            onclick: move |_| count.set(double(count())),
            "{count}"
        }
    }
}

Improved warnings

Dioxus 0.6 also expands the warning system to include hints for several problematic behaviors. Dioxus now warns if components are called as functions, state is passed up the component tree, or a component rerun is triggered while rendering.

Hoisted value warning

Improved Inline Documentation

We also improved the inline documentation throughout the dioxus crates. Many common items now include in depth examples, explanations, and help for common errors. For comparison, here is the documentation in 0.5 and 0.6 for oninput:

and use_memo:

Bug fixes

Dioxus 0.6 also includes a plethora of bug fixes and consistency tweaks. Over 200 issues closed with 100 bugs fixed

Screenshot 2024-08-07 at 9 49 42 AM

Call for Testing

Testing the alpha release and opening issues for any bugs you run into is a great way to contribute back to dioxus!

Feel free to hop into the discord to give feedback and/or chat about the new changes.

Full Change Log

New Contributors!

Full Diff: https://github.com/DioxusLabs/dioxus/compare/v0.5.1...v0.6.0-alpha.1

dioxus - v0.5.1: Bug fixes!

Published by jkelleyrtp 7 months ago

0.5.1: Bug Fixes!

Thanks everyone for the great feedback for the 0.5.0 launch! We're releasing 0.5.1 now with a bunch of bug fixes.

This includes some stuff like fixing async polling, some smalls issues with memos and resources, and a memory leak in EventHandler.

We strongly recommend you upgrade your dioxus project with cargo update!

The autoformatter also changed a bit, so if you're using the VSCode extension, you should get the updates automatically.

What's Changed

New Contributors

Full Changelog: https://github.com/DioxusLabs/dioxus/compare/v0.5.0...v0.5.1

dioxus - v0.5.0

Published by ealmloff 7 months ago

Dioxus 0.5: Signal Rewrite, Remove lifetimes/unsafe, CSS Hotreloading, 5x Faster Desktop, Asset System, and more!

Read the Full 0.5 release post on the Dioxus blog

The story

Here at Dioxus Labs, we have an unofficial rule: only one rewrite per year.

Our last rewrite brought some amazing features: templates, hotreloading, and insane performance. However, don’t be mistaken, rewrites are scary, time consuming, and a huge gamble. We started this new rewrite on January 1st of 2024, completed it by Feburary 1st, and then spent another month and a half writing tests, squashing bugs, and polishing documentation. Rewrites are absolutely not for the faint of heart.

If you’re new here, Dioxus (dye•ox•us) is a library for building GUIs in Rust. Originally, I built Dioxus as a rewrite of Yew with the intention of supporting proper server-side-rendering. Eventually, Dioxus got popular, we got some amazing sponsors, and I went full time. We’ve grown from a team of 1 (me) to a team of 4(!) - pulled entirely from the wonderful dioxus community.

Now, Dioxus is something a little different. Real life, actual companies are shipping web apps, desktop apps, and mobile apps with Dioxus. What was once just a fun little side project powers a small fraction of apps out in the wild. We now have lofty goals of simplifying the entire app development ecosystem. Web, Desktop, Mobile, all end-to-end typesafe, blazing fast, living under one codebase. The dream!

With 0.5 we took a hard look at how Dioxus would need to change to achieve those goals. The request we got from the community was clear: make it simpler, make it robust, make it polished.

What’s new?

This is probably the biggest release of Dioxus ever, with so many new features, bug fixes, and improvements that I can’t list them all. We churned over 100,000 lines of code (yes, 100,000+) with over 1,400 commits between 0.4.3 and 0.5.0. Here’s a quick overview:

  • Complete rewrite of dioxus-core, removing all unsafe code
  • Abandoning use_state and use_ref for a clone-free Signal-based API
  • Removal of all lifetimes and the cx: Scope state
  • A single, unified launch function that starts your app for any platform
  • Asset hotreloading that supports Tailwind and Vanilla CSS
  • Rewrite of events, allowing access to the native WebSys event types
  • Extension of components with element properties (IE a Link now takes all of <a/> properties)
  • Integrated Error Boundaries and Server Futures with Suspense integration
  • 5x faster desktop reconciliation and custom asset handlers for streaming bytes
  • Streaming server functions and fullstack hotreloading
  • Tons of QoL improvements, bug fixes, and more!

Lifetime Problems

To make Dioxus simpler, we wanted to remove lifetimes entirely. Newcomers to rust are easily scared off by lifetime issues, and even experienced Rustaceans find wading through obtuse error messages exhausting.

In dioxus 0.1-0.4, every value in a component lives for a 'bump lifetime. This lifetime lets you easily use hooks, props and the scope within event listeners without cloning anything. It was the chief innovation that made Dioxus so much easier to use than Yew when it was released.

// Scope and Element have the lifetime 'bump
fn OldDioxusComponent(cx: Scope) -> Element {
  // hook has the lifetime 'bump
  let mut state = use_state(cx, || 0);
  cx.render(rsx! {
    button {
      // The closure has the lifetime 'bump which means you don't 
      // need to clone hook before you move it into the closure 
      onclick: move |_event| *state += 1,
    }
  })
}

This works great for hooks most of the time. The lifetime lets you omit a bunch of manual clones every time you want to use a value inside an EventHandler (onclick, oninput, etc).

However, the lifetime doesn’t work for futures. Futures in dioxus need to be 'static which means you always need to clone values before you use them in the future. Since a future might need to run while the component is rendering, it can’t share the component’s lifetime.

// Scope and Element have the lifetime 'bump
fn OldDioxusComponent(cx: Scope) -> Element {
  // state has the lifetime 'bump
  let state = use_state(cx, || 0);
  
  cx.spawn({
    // Because state has the lifetime 'bump, we need to clone it to make it 
    // 'static before we move it into the 'static future
    let state = state.clone();
    async move {
      println!("{state}");
    }
  });

  // ...
}

If you don’t clone the value, you will run into an error like this:

4  |   fn OldDioxusComponent(cx: Scope) -> Element {
   |                         --
   |                         |
   |                         `cx` is a reference that is only valid in the function body
   |                         has type `&'1 Scoped<'1>`
...
8  | /     cx.spawn(async move {
9  | |         println!("{state}");
10 | |     });
   | |      ^
   | |      |
   | |______`cx` escapes the function body here
   |        argument requires that `'1` must outlive `'static`

The error complains that cx must outlive 'static without mentioning the hook at all which can be very confusing.

Dioxus 0.5 fixes this issue by first removing scopes and the 'bump lifetime and then introducing a new Copy state management solution called signals. Here is what the component looks like in dioxus 0.5:

// Element has no lifetime, and you don't need a Scope
fn NewComponent() -> Element {
  // state is 'static and Copy, even if the inner value you store is not Copy
  let mut state = use_signal(|| 0);

  // State is already 'static and Copy, so it is copied into the future automatically
  spawn(async move {
    println!("{state}");
  });

  rsx! {
    button {
      // The closure has the lifetime 'static, but state is copy so you don't need to clone into the closure
      onclick: move |_event| state += 1,
    }
  }
}

While this might seem like a rather innocuous change, it has an impressively huge impact on how easy it is to write new components. I’d say building a new Dioxus app is about 2-5x easier with this change alone.

Goodbye scopes and lifetimes!

In the new version of dioxus, scopes and the 'bump lifetime have been removed! This makes declaring a component and using runtime functions within that component much easier:

You can now declare a component by just accepting your props directly instead of a scope parameter

#[component]
fn MyComponent(name: String) -> Element {
  rsx! { "Hello {name}!" }
}

And inside that component, you can use runtime functions directly

spawn(async move {
  tokio::time::sleep(Duration::from_millis(100)).await;
  // You can even use runtime functions inside futures and event handlers!
  let context: i32 = consume_context();
});

Now that lifetimes are gone, Elements are 'static which means you can use them in hooks or even provide them through the context API. This makes some APIs like virtual lists in dioxus significantly easier. We expect more interesting APIs to emerge from the community now that you don’t need to be a Rust wizard to implement things like virtualization and offscreen rendering.

Removal of all Unsafe in Core

Removing the 'bump lifetime along with the scope gave us a chance to remove a lot of unsafe from dioxus. dioxus-core 0.5 contains no unsafe code 🎉

There’s still a tiny bit of unsafe floating around various dependencies that we plan to remove throughout the 0.5 release cycle, but way less: all quite simple to cut or unfortunately necessary due to FFI.

Signals!

Dioxus 0.5 introduces Signals as the core state primitive for components. Signals have two key advantages over the existing use_state and use_ref hooks: They are always Copy and they don’t require manual subscriptions.

Copy state

Signal<T> is Copy, even if the inner T values is not. This is enabled by our new generational-box crate (implemented with zero unsafe). Signals can even optionally be Send+Sync if you need to move them between threads, removing the need for a whole class of specialized state management solutions.

The combination of Copy + Send + Sync Signals, and static components makes it incredibly easy to move state to anywhere you need it:

fn Parent() -> Element {
  // We use a sync signal here so that we can use it in other threads, 
  // but you could use a normal signal if you have !Send data
  let mut state = use_signal_sync(|| 0);

  spawn(async move {
    // Signals have a ton of helper methods that make them easy to work with. 
    // You can call a signal like a function to get the current value
    let value: i32 = state();
  });

  // Because signals can be sync, we can copy them into threads easily
  std::thread::spawn(move || {
    loop {
      std::thread::sleep(Duration::from_millis(100));
      println!("{state}");
    }
  });

  render! {
    button {
      // You can easily move it into an event handler just like use_state
      onclick: move |_| state += 1
    }
  }
}

With Copy state, we’ve essentially bolted on a light form of garbage collection into Rust that uses component lifecycles as the triggers for dropping state. From a memory perspective, this is basically the same as 0.4, but with the added benefit of not needing to explicitly Clone anything.

Smarter subscriptions

Signals are smarter about what components rerun when they are changed. A component will only rerun if you read the value of the signal in the component (not in an async task or event handler). In this example, only the child will re-render when the button is clicked because only the child component is reading the signal:

fn Parent() -> Element {
  let mut state = use_signal(|| 0);

  rsx! {
    button { onclick: move |_| state += 1, "increment" }
    Child { state }
  }
}

#[component]
fn Child(state: Signal<i32>) -> Element {
  rsx! { "{state}" }
}

Smarter subscriptions let us merge several different hooks into signals. For example, we were able to remove an entire crate dedicated to state management: Fermi. Fermi provided what was essentially a use_state API where statics were used as keys. This meant you could declare some global state, and then read it in your components:

static COUNT: Atom<i32> = Atom::new(|| 0);

fn Demo(cx: Scope) -> Element {
  let mut count = use_read_atom(cx, &COUNT);
  rsx! { "{count}" }
}

Since fermi didn’t support smart subscriptions, you had to explicitly declare use the right use_read/ use_write hooks to subscribe to the value. In Dioxus 0.5, we just use signals, eliminating the need for any sort of external state management solution altogether.

// You can use a lazily initialized signal called 
// GlobalSignal in static instead of special Fermi atoms
static COUNT: GlobalSignal<i32> = Signal::global(|| 0);

// Using the GlobalSignal is just the same as any other signal!
// No need for use_read or use_write
fn Demo() -> Element {
  rsx! { "{COUNT}" }
}

Signals even work with the context API, so you can quickly share state between components in your app:

fn Parent() -> Element {
  // Create a new signal and provide it to the context API 
  // without a special use_shared_state hook
  let mut state = use_context_provider(|| Signal::new(0));

  rsx! {
    button { onclick: move |_| state += 1, "Increment" } 
    Child {}
  }
}

fn Child() -> Element {
  // Get the state from the context API
  let state = use_context::<Signal<i32>>();
  rsx! { "{state}" }
}

Smart subscriptions also apply to hooks. Hooks like use_future and use_memo will now automatically add signals you read inside the hook to the dependencies of the hook:

// You can use a lazily initialized signal called GlobalSignal in static instead of special Fermi atoms
static COUNT: GlobalSignal<i32> = Signal::global(|| 0);

fn App() -> Element {
  // Because we read COUNT inside the memo, it is automatically added to the memo's dependencies
  // If we change COUNT, then the memo knows it needs to rerun
  let memo = use_memo(move || COUNT() / 2);

  rsx! { "{memo}" }
}

Event System Rewrite

Since it’s release, dioxus has used a synthetic event system to create a cross platform event API. Synthetic events can be incredibly useful to make events work across platforms and even serialize them across the network, but they do have some drawbacks.

Dioxus 0.5 finally exposes the underlying event type for each platform along with a trait with a cross platform API. This has two advantages:

  1. You can get whatever information you need from the platform event type or pass that type to another library:
fn Button() -> Element {
  rsx! {
    button {
      onclick: move |event| {
        let web_sys_event: web_sys::MouseEvent = event.web_event();
        web_sys::console::log_1(&web_sys_event.related_target.into());
      }
    }
  }
}
  1. Dioxus can bundle split code for events apps don’t use. For a hello world example, this shrinks the gzipped size ~25%!

Screenshot_2024-03-21_at_8 37 04_AM

Again, this seems like a small change on the surface, but opens up dozens of new use cases and possible libraries you can build with dioxus.

Cross platform launch

Dioxus 0.5 introduces a new cross platform API to launch your app. This makes it easy to target multiple platforms with the same application. Instead of pulling in a separate renderer package, you can now enable a feature on the dioxus crate and call the launch function from the prelude:

[dependencies]
dioxus = "0.5"

[features]
default = []
desktop = ["dioxus/desktop"]
fullstack = ["dioxus/fullstack"]
server = ["dioxus/axum"]
web = ["dioxus/web"]

use dioxus::prelude::*;

fn main() {
  dioxus::launch(|| rsx!{ "hello world" })
}

With that single application, you can easily target:

# Desktop
dx serve --platform desktop

# SPA web
dx serve --platform web

# Or a fullstack application
dx serve --platform fullstack

The CLI is now smart enough to automatically pass in the appropriate build features depending on the platform you’re targeting.

Asset System Beta

Currently assets in dioxus (and web applications in general) can be difficult to get right. Links to your asset can easily get out of date, the link to your asset can be different between desktop and web applications, and you need to manually add assets you want to use into your bundled application. In addition to all of that, assets can be a huge performance bottleneck.

Lets take a look at the dioxus mobile guide in the docsite as an example:

docsite_mobile_old

The 0.4 mobile guide takes 7 seconds to load and transfers 9 MB of resources. The page has 6 different large image files which slows down the page loading times significantly. We could switch to a more optimized image format like avif , but manually converting every screenshot is tedious and time consuming.

Lets take a look at the 0.5 mobile guide with the new asset system:

docsite_mobile_new

The new mobile guide takes less than 1 second to load and requires only 1/3 of the resources with the exact same images!

Dioxus 0.5 introduces a new asset system called manganis. Manganis integrates with the CLI to check, bundle and optimize assets in your application. The API is currently unstable so the asset system is currently published as a separate crate. In the new asset system, you can just wrap your assets in the mg! macro and they will automatically be picked up by the CLI. You can read more about the new asset system in the manganis docs.

As we continue to iterate on the 0.5 release, we plan to add hot reloading to manganis assets, so you can interactively add new the features to your app like CSS, images, tailwind classes, and more without forcing a complete reload.

CSS Hot Reloading

As part of our asset system overhaul, we implemented hotreloading of CSS files in the asset directory. If a CSS file appears in your RSX, the dx CLI will watch that file and immediately stream its updates to the running app. This works for web, desktop, and fullstack, with mobile support coming in a future mobile-centric update.

https://github.com/DioxusLabs/dioxus/assets/66571940/ece55e95-cf2b-4216-b04e-fe3c23d9ff78

What’s even niftier is that you can stream these changes to several devices at once, unlocking simultaneous hotreloading across all devices that you target:

https://github.com/DioxusLabs/dioxus/assets/66571940/315264fc-be68-4c47-b2fc-9a2233ccffc1

5x Faster Desktop Rendering

Dioxus implements several optimizations to make diffing rendering fast. Templates let dioxus skip diffing on any static parts of the rsx macro. However, diffing is only one side of the story. After you create a list of changes you need to make to the DOM, you need to apply them.

We developed sledgehammer for dioxus web to make applying those mutations as fast as possible. It makes manipulating the DOM from Rust almost as fast as native JavaScript.

In dioxus 0.5, we apply that same technique to apply changes across the network as fast as possible. Instead of using json to communicate changes to the desktop and liveview renderers, dioxus 0.5 uses a binary protocol.

For render intensive workloads, the new renderer takes only 1/5 the time to apply the changes in the browser with 1/2 the latency. Here is one of the benchmarks we developed while working on the new binary protocol. In dioxus 0.4, the renderer was constantly freezing. In dioxus 0.5, it runs smoothly:

Dioxus 0.4

https://github.com/DioxusLabs/dioxus/assets/66571940/d8c09989-ce99-4b80-b5a7-8ffaf53dbf87

Dioxus 0.5

https://github.com/DioxusLabs/dioxus/assets/66571940/2166880c-b7ce-414d-8f55-570b84a246f0

Spreading props

One common pattern when creating components is providing some additional functionality to a specific element. When you wrap an element, it is often useful to provide some control over what attributes are set in the final element. Instead of manually copying over each attribute from the element, dioxus 0.5 supports extending specific elements and spreading the attributes into an element:

#[derive(Props, PartialEq, Clone)]
struct Props {
    // You can extend a specific element or global attributes
    #[props(extends = img)]
    attributes: Vec<Attribute>,
}

fn ImgPlus(props: Props) -> Element {
    rsx! {
        // You can spread those attributes into any element
        img { ..props.attributes }
    }
}

fn app() -> Element {
  rsx! {
    ImgPlus {
      // You can use any attributes you would normally use on the img element
      width: "10px",
      height: "10px",
      src: "https://example.com/image.png",
    }
  }
}

Shorthand attributes

Another huge quality-of-life feature we added was the ability to use shorthand struct initialization syntax to pass attributes into elements and components. We got tired of passing class: class everywhere and decided to finally implement this long awaited feature, at the expense of some code breakage. Now, it’s super simple to declare attributes from props:

#[component]
fn ImgPlus(class: String, id: String, src: String) -> Element {
    rsx! {
        img { class, id, src }
    }
}

This feature works for anything implementing IntoAttribute, meaning signals also benefit from shorthand initialization. While signals as attributes don’t yet skip diffing, we plan to add this as a performance optimization throughout the 0.5 release cycle.

Multi-line attribute merging

Another amazing feature added this cycle was attribute merging. When working with libraries like tailwind, you’ll occasionally want to make certain attributes conditional. Before, you had to format the attribute using an empty string. Now, you can simply add an extra attribute with a conditional, and the attribute will be merged using a space as a delimiter:

#[component]
fn Blog(enabled: bool) -> Element {
    rsx! {
        div { 
            class: "bg-gray-200 border rounded shadow",
            class: if enabled { "text-white" }
        }
    }
}

This is particularly important when using libraries like tailwind where attributes need to be parsed at compile time but also dynamic at runtime. This syntax integrates with the tailwind compiler, removing the runtime overhead for libraries like tailwind-merge.

Server function streaming

Dioxus 0.5 supports the latest version of the server functions crate which supports streaming data. Server functions can now choose to stream data to or from the client. This makes it easier to do a whole class of tasks on the server.

Creating a streaming server function is as easy as defining the output type and returning a TextStream from the server function. Streaming server functions are great for updating the client during any long running task.

We built an AI text generation example here: https://github.com/ealmloff/dioxus-streaming-llm that uses Kalosm and local LLMS to serve what is essentially a clone of OpenAI’s ChatGPT endpoint on commodity hardware.

#[server(output = StreamingText)]
pub async fn mistral(text: String) -> Result<TextStream, ServerFnError> {
   let text_generation_stream = todo!();
   Ok(TextStream::new(text_generation_stream))
}

https://github.com/DioxusLabs/dioxus/assets/66571940/251f6bf8-4337-4781-a9b4-a22b60ab856e

Side note, the AI metaframework used here - Kalosm - is maintained by the Dioxus core team member ealmloff, and his AI GUI app Floneum is built with Dioxus!

Fullstack CLI platform

The CLI now supports a fullstack platform with hot reloading and parallel builds for the client and sever. You can now serve your fullstack app with the dx command:

dx serve

# Or with an explicit platform
dx serve --platform fullstack

Liveview router support

https://github.com/DioxusLabs/dioxus/pull/1505

@DonAlonzo added liveview support for the router in dioxus 0.5. The router will now work out of the box with your liveview apps!

Custom Asset Handlers

https://github.com/DioxusLabs/dioxus/pull/1719

@willcrichton added support for custom asset handlers to dioxus desktop. Custom asset handlers let you efficiently stream data from your rust code into the browser without going through javascript. This is great for high bandwidth communication like video streaming:

https://github.com/DioxusLabs/dioxus/assets/66571940/ab5fa136-166a-44e3-9053-42418ca45439

Now, you can do things like work with gstreamer or webrtc and pipe data directly into the webview without needing to encode/decode frames by hand.

Native File Handling

This is a bit smaller of a tweak, but now we properly support file drops for desktop:

https://github.com/DioxusLabs/dioxus/assets/66571940/e78ddc32-3f30-4a8c-9053-37b592a13cf6

Previously we just gave you the option to intercept filedrops but now it’s natively integrated into the event systme.

Error handling

Error handling: You can use error boundaries and the throw trait to easily handle errors higher up in your app

Dioxus provides a much easier way to handle errors: throwing them. Throwing errors combines the best parts of an error state and early return: you can easily throw an error with ?, but you keep information about the error so that you can handle it in a parent component.

You can call throw on any Result type that implements Debug to turn it into an error state and then use ? to return early if you do hit an error. You can capture the error state with an ErrorBoundary component that will render the a different component if an error is thrown in any of its children.

fn Parent() -> Element {
  rsx! {
    ErrorBoundary {
      handle_error: |error| rsx! {
        "Oops, we encountered an error. Please report {error} to the developer of this application"
      },
      ThrowsError {}
    }
  }
}

fn ThrowsError() -> Element {
  let name: i32 = use_hook(|| "1.234").parse().throw()?;

  todo!()
}

You can even nest ErrorBoundary components to capture errors at different levels of your app.

fn App() -> Element {
  rsx! {
    ErrorBoundary {
      handle_error: |error| rsx! {
        "Hmm, something went wrong. Please report {error} to the developer"
      },
      Parent {}
    }
  }
}

fn Parent() -> Element {
  rsx! {
    ErrorBoundary {
      handle_error: |error| rsx! {
        "The child component encountered an error: {error}"
      },
      ThrowsError {}
    }
  }
}

fn ThrowsError() -> Element {
  let name: i32 = use_hook(|| "1.234").parse().throw()?;

  todo!()
}

This pattern is particularly helpful whenever your code generates a non-recoverable error. You can gracefully capture these "global" error states without panicking or handling state for each error yourself.

Hotreloading by default and “develop” mode for desktop

We shipped hotreloading in 0.3, added it to desktop in 0.4, and now we’re finally enabling it by default in 0.5. By default, when you dx serve your app, hotreloading is enabled in development mode.

Additionally, we’ve drastically improved the developer experience of building desktop apps. When we can’t hotreload the app and have to do a full recompile, we now preserve the state of the open windows and resume that state. This means your app won’t block your entire screen on every edit and it will maintain its size and position, leading to a more magical experience. Once you’ve played with it, you can never go back - it’s that good.

https://github.com/DioxusLabs/dioxus/assets/66571940/21dfca22-14ea-47f9-a2de-9853609a9dd4

Updates to the dioxus template

With this update, our newest core team member Miles (lovingly, @Doge on our discord) put serious work into overhauling documentation and our templates. We now have templates to create new dioxus apps for web, desktop, mobile, tui, and fullstack under one command.

https://github.com/DioxusLabs/dioxus/assets/66571940/7c6062ea-22a4-4c2a-bd7e-ca6f28cf1dbf

We also updated the default app you get when using dx new to be closer to the traditional create-react-app. The template is now seeded with assets, CSS, and some basic deploy configuration. Plus, it includes links to useful resources like dioxus-std, the VSCode Extension, docs, tutorials, and more.

Dioxus-Community and Dioxus-std

The Dioxus Community is something special: discord members marc and Doge have been hard at working updating important ecosystem crates for the 0.5 release. With this release, important crates like icons, charts, and the dioxus-specific standard library are ready to use right out the gate. The Dioxus Community project is a new GitHub organization that keeps important crates up-to-date even when the original maintainers step down. If you build a library for Dioxus, we’ll be happy to help maintain it, keeping it at what is essentially “Tier 2” support.

Coming soon

At a certain point we had to stop adding new features to this release. There’s plenty of cool projects on the horizon:

  • Stabilizing and more deeply integrating the asset system
  • Bundle splitting the outputted .wasm directly - with lazy components
  • Islands and resumable interactivity (serializing signals!)
  • Server components and merging LiveView into fullstack
  • Enhanced Devtools (potentially featuring some AI!) and testing framework
  • Complete mobile overhaul
  • Fullstack overhaul with websockets, SSE, progressive forms, and more

Sneak Peek: Dioxus-Blitz revival using Servo

We’re not going to say much about this now, but here’s a sneak peek at “Blitz 2.0”… we’re finally integrating servo into blitz so you can render natively with WGPU using the same CSS engine that powers Firefox. To push this effort forward, we’ve brought the extremely talented Nico Burns (the wizard behind our layout library Taffy) on full time. More about this later, but here’s a little demo of google.com being rendered at 900 FPS entirely on the GPU:

Google page rendered by blitz

Admittedly the current iteration is not quite there (google.com is in fact a little wonky) but we’re progressing rapidly here and are quickly approaching something quite usable. The repo is here if you want to take a look and get involved:

https://github.com/jkelleyrtp/stylo-dioxus

How can you contribute?

Well, that’s it for the new features. We might’ve missed a few things (there’s so much new!). If you find Dioxus as exciting as we do, we’d love your help to completely transform app development. We’d love contributions including:

  • Translating docs into your native language
  • Attempting “Good First Issues”
  • Improving our documentation
  • Contributing to the CLI
  • Help answer questions from the discord community

That’s it! We’re super grateful for the community support and excited for the rest of 2024.

Build cool things! ✌️

Full Changelog (since 0.4.3)

New Contributors

dioxus - v0.5.0-alpha.0: first prerelease

Published by jkelleyrtp 8 months ago

First prerelease of dioxus

v0.5 is coming soon! We've decided to start putting out pre-releases so developers on the "bleeding-edge" have a stable checkpoint to use as we release new breaking features.

The full release notes for 0.5 are here:

https://dioxus.notion.site/Dioxus-0-5-Signals-Unified-Launch-Native-Events-5x-Faster-Desktop-Error-Boundaries-9961963b731a4d9f8465e5bcdf8e9ab3?pvs=74

Migration guide:

https://ealmloff.github.io/docsite/learn/0.4/migration/

Feel free to hop into the discord to give feedback and/or chat about the new changes.

Full Changelog: https://github.com/DioxusLabs/dioxus/compare/v0.4.3...v0.5.0-alpha.0

dioxus - v0.4.3

Published by jkelleyrtp 8 months ago

v0.4.3

This is the last release of the 0.4 cycle, containing a number of useful new features as well as many bug fixes.

You can now manipulate the dioxus runtime without going through the Scope object.

This was originally released many months ago, but we never made the release post.

What's Changed

New Contributors

Full Changelog: https://github.com/DioxusLabs/dioxus/compare/v0.4.2...v0.4.3

dioxus - v0.4.2

Published by jkelleyrtp 11 months ago

What's Changed

New Contributors

Full Changelog: https://github.com/DioxusLabs/dioxus/compare/v0.4.0...v0.4.2

dioxus - v0.4.1

Published by ealmloff about 1 year ago

What's Changed

dioxus - v0.4.0

Published by ealmloff about 1 year ago

Dioxus 0.4 Github

The Dioxus 0.4 release includes 6 new crates, a ton of new features and a plethora of bug fixes!

Highlights:

  • Rewritten Type safe Router
  • Fullstack cross-platform meta framework
  • Suspense
  • CLI Linting
  • CLI Bundling
  • Rewritten Documentation
  • Cross platform system API wrappers: Dioxus STD

Router

The router has been revamped for the 0.4 release. The router now uses an enum to define routes. If you use this enum to link to a page, the compiler will insure you never link to a page that doesn’t exist. The new router also includes Nesting, Layout, and sitemap support:

use dioxus::prelude::*;
use dioxus_router::prelude::*;

#[derive(Routable, Clone)]
enum Route {
    #[route("/")]
    Home {},

    #[route("/blog")]
    Blog {},
}

fn App(cx: Scope) -> Element {
    render! {
        Router::<Route> {}
    }
}

#[inline_props]
fn Home(cx: Scope) -> Element {
    render! {
        Link {
            to: Route::Blog {},
            "Go to the blog"
        }
        h1 { "Welcome to the Dioxus Blog!" }
    }
}

#[inline_props]
fn Blog(cx: Scope) -> Element {
    render! {
        Link {
            to: Route::Home {},
            "Go to the home page"
        }
        h1 { "Blog" }
    }
}

Huge shoutout to @TeFiLeDo for creating many different prototypes and tests for the new router!

Fullstack

The 0.4 release introduces the Fullstack crate. The fullstack crate contains adapters for communicating with your

Fullstack Rendering

The fullstack crate makes it dead simple to create a server side rendered hydrated app with fullstack typesafety. The fullstack crate lets you render your page on the server on every request (or incrementally) and then hydrate it on the client.

use dioxus::prelude::*;
use dioxus_fullstack::prelude::*;

fn main() {
	LaunchBuilder::new(app).launch();
}

fn app(cx: Scope) -> Element {
	let mut count = use_state(cx, || 0);
	render! {
		h1 { "High-Five counter: {count}" }
		button { onclick: move |_| count += 1, "Up high!" }
		button { onclick: move |_| count -= 1, "Down low!" }
	}
}

Fullstack communication

In addition to fullstack rendering, the new fullstack create allows you to communicate with your server effortlessly. You can annotate a function with #[server] to make the code inside the function only run on the server. This makes it easy to build a backend for your web or desktop application!

use dioxus::prelude::*;
use dioxus_fullstack::prelude::*;

fn main() {
	LaunchBuilder::new(app).launch();
}

fn app(cx: Scope) -> Element {
	let mut count = use_state(cx, || 0);
	render! {
		h1 { "High-Five counter: {count}" }
		button { onclick: move |_| count += 1, "Up high!" }
		button { onclick: move |_| count -= 1, "Down low!" }
		button {
			onclick: move |_| {
				to_owned![count];
				async move {
					let double = double(*count).await.unwrap();
					count.set(double);
				}
			}
		}
	}
}

#[server]
async fn double(number: usize) -> Result<usize, ServerFnError> {
	// This will *only* run on the server
	Ok(number * 2)
}

Suspense

0.4 adds the long awaited suspense feature. This allows you to wait for a future on the server and then send the result to the client. You can combine suspense with server functions to wait for some code on your server to finish running before rendering a component:

use dioxus::prelude::*;
use dioxus_fullstack::prelude::*;

fn main() {
	LaunchBuilder::new(app).launch();
}

fn app(cx: Scope) -> Element {
	let mut server_data = use_server_future(cx, || get_server_data())?;

	render! {
		div {
			"{server_data:?}"
		}
	}
}

#[server]
async fn get_server_data() -> Result<usize, ServerFnError> {
	Ok(42)
}

CLI Improvements

The Dioxus CLI has moved into the dioxus main repo

The Dioxus CLI is now called dx instead of dioxus. The 0.4 release of the Dioxus CLI added three main features:

Dioxus Check

@eventualbuddha has done a fantastic job creating a new Dioxus check command to lint your Dioxus code for errors! It will warn you if your code violates the rules of hooks

dx check

Dioxus Bundle

The Dioxus CLI can now create installers for MacOs and Windows powered by tauri-bundle!

dioxus bundle

Desktop Hot Reload

In Dioxus 0.4, rsx hot reloading has moved from the hot reload macro to the CLI for desktop, liveview, fullstack, and TUI applications. Now every platform can use the CLI to start hot reloading:

dioxus serve --platform desktop --hot-reload

Mobile

Dioxus now has improved mobile support with a getting started guide and a mobile example!

Documentation

The documentation has been revamped for the 0.4 release. We now have a short getting started guide that teaches you how to build a hackernews clone in Dioxus.

The new documentation site takes full advantage of the fullstack crate to prerender the pages.

While working on the new docsite we also created two new crates:

  • Dioxus Mdbook makes it easy to use markdown into your Dioxus components and use Dioxus components in your markdown
  • Dioxus Search makes it easy to create instant search indexes for your Dioxus page's. It integrates with the Dioxus router's new site map feature to automatically detect searchable pages

Together these crates allow us to make our documentation fully interactive and instantly searchable. The new documentation site contains live code snippets of different components as you walk through the guide.

Dioxus STD

One of the biggest problems with cross platform development in rust today is finding ergonomic ways to interact with system APIs. @doge and @marc have created a new Dioxus std create that makes it easy to interact with a variety of system APIs in Dioxus across all platforms. It contains helpers for Geolocation, clipboard access, notifications, color schemes, translation, and more!

Async Eval

@doge has made the use_eval hook significantly more powerful for the 0.4 release of Dioxus. You can now send messages to and from Javascript asynchronously. This feature makes it possible to listen for Javascript events that Dioxus doesn’t officially support (for example the intersection observer API).

Dioxus HTML

The 0.4 release introduces file upload support for the dioxus-html crate. This makes it easy to upload files to you desktop, liveview, or web application.

This release also introduces a new onmounted event that provides access to some common node APIs like focusing an element or getting the size of an element in a cross platform way.

Rink and Blitz-core

Dioxus' TUI renderer Rink and WGPU renderer Blitz can now be used without Dioxus. This makes it possible to render your own html into either of these renderers or use these renderers in your own framework. To get started, see the Blitz and Rink framework-less examples.

Community

Office Hours

Dioxus now holds weekly office hours in the discord! If you are interested in the project, need help with your projects, or want to get started contributing, you should come to our weekly office hours!

The office hours happen every Friday at 9:00 AM (PDT) in the Dioxus discord server

Recordings of office hours are available on the Dioxus youtube channel

New contributors

There have been almost 50 new contributors since the 0.3 release!

@mirkootter, @davidpdrsn, @mwcz, @askreet, @marcerhans, @ndarilek, @arniu, @pickfire, @arqalite, @ProfXwing, @Icekey, @willothy, @rtwfroody, @attilio, @stephenandary, @Rigellute, @onweru, @Byron, @nicoburns, @serzhiio, @indiv0, @azriel91, @elliotwaite, @nmlt, @nicholastmosher, @TimothyStiles, @jpearnshaw, @jmsfltchr, @striezel, @echochamber, @xinglixing, @sean, @torsteingrindvik, @vanhouc, @terhechte, @traxys, @Mouradost, @DianQK, @eventualbuddha, @leahiel, @kaid, @frisoft, @Niedzwiedzw

Conclusion

For more information on the 0.4 release and all the new features that have been introduced, read the blogpost

Full Changelog: https://github.com/DioxusLabs/dioxus/compare/v0.3.2...v0.4.0

dioxus - v0.3.2

Published by ealmloff over 1 year ago

Dioxus 0.3 is bringing a lot of fantastic new features:

  • Massive performance improvements
  • Hot reloading for web and desktop
  • Autoformatting for RSX via dioxus fmt
  • New LiveView renderer
  • Input widgets for TUI
  • Lua plugin system for CLI and overhaul of CLI
  • Multi window desktop apps and direct access to Tao/Wry
  • General improvements to RSX (if chains, for loops, boolean attributes, any values)
  • Rusty event types with support for complex techniques like file uploading
  • Skia renderer and WGPU renderer
  • Chinese and Portuguese translations
  • A new landing page

For more details about each of these new improvements see the release blog post

dioxus - v0.2.4

Published by jkelleyrtp over 2 years ago

Releasing Diouxs v0.2.4

This update is just a minor bump to Dioxus. A ton of bugs were fixed, and a few new features were added.

Notably

  • Option in props are now optional by default
  • Active_class for Links
  • Improve rsx! errors
  • Fix some bugs in hydration
  • Introduce a very young version of Liveview
  • Introduce a very young version of Dioxus Native (just the core bits)
  • use_eval for running JS

A bunch of bugs were fixed too!

Overall, this release will improve the stability, performance, and usability of Dioxus without any major breaking changes.

What's Changed

New Contributors

Full Changelog: https://github.com/DioxusLabs/dioxus/compare/v0.2.0...v0.2.4

dioxus - v0.2.0

Published by jkelleyrtp over 2 years ago

Dioxus v0.2 Release: TUI, Router, Fermi, and Tooling

March 9, 2022

Thanks to these amazing folks for their financial support on OpenCollective:

Thanks to these amazing folks for their code contributions:

Just over two months in, and we already a ton of awesome changes to Dioxus!

Dioxus is a recently-released library for building interactive user interfaces (GUI) with Rust. It is built around a Virtual DOM, making it portable for the web, desktop, server, mobile, and more. Dioxus looks and feels just like React, so if you know React, then you'll feel right at home.

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

    cx.render(rsx! {
        h1 { "Count: {count}" }
        button { onclick: move |_| count += 1, "+" }
        button { onclick: move |_| count -= 1, "-" }
    })
}

What's new?

A ton of stuff happened in this release; 550+ commits, 23 contributors, 2 minor releases, and 6 backers on Open Collective.

Some of the major new features include:

  • We now can render into the terminal, similar to Ink.JS - a huge thanks to @Demonthos
  • We have a new router in the spirit of React-Router @autarch
  • We now have Fermi for global state management in the spirit of Recoil.JS
  • Our desktop platform got major upgrades, getting closer to parity with Electron @mrxiaozhuox
  • Our CLI tools now support HTML-to-RSX translation for converting 3rd party HTML into Dioxus @mrxiaozhuox
  • Dioxus-Web is sped up by 2.5x with JS-based DOM manipulation (3x faster than React)

We also fixed and improved a bunch of stuff - check out the full list down below.

A New Renderer: Your terminal!

When Dioxus was initially released, we had very simple support for logging Dioxus elements out as TUI elements. In the past month or so, @Demonthos really stepped up and made the new crate a reality.

New Router

We totally revamped the router, switching away from the old yew-router approach to the more familiar React-Router. It's less type-safe but provides more flexibility and support for beautiful URLs.

Apps with routers are really simple now. It's easy to compose the "Router", a "Route", and "Links" to define how your app is laid out:

fn app(cx: Scope) -> Element {
    cx.render(rsx! {
        Router {
            onchange: move |_| log::info!("Route changed!"),
            ul {
                Link { to: "/",  li { "Go home!" } }
                Link { to: "users",  li { "List all users" } }
                Link { to: "blog", li { "Blog posts" } }
            }
            Route { to: "/", "Home" }
            Route { to: "/users", "User list" }
            Route { to: "/users/:name", User {} }
            Route { to: "/blog", "Blog list" }
            Route { to: "/blog/:post", BlogPost {} }
            Route { to: "", "Err 404 Route Not Found" }
        }
    })
}

We're also using hooks to parse the URL parameters and segments so you can interact with the router from anywhere deeply nested in your app.

#[derive(Deserialize)]
struct Query { name: String }

fn BlogPost(cx: Scope) -> Element {
    let post = use_route(&cx).segment("post")?;
    let query = use_route(&cx).query::<Query>()?;

    cx.render(rsx!{
        "Viewing post {post}"
        "Name selected: {query}"
    })
}

Give a big thanks to @autarch for putting in all the hard work to make this new router a reality.

The Router guide is available here - thanks to @dogedark.

Fermi for Global State Management

Managing state in your app can be challenging. Building global state management solutions can be even more challenging. For the first big attempt at building a global state management solution for Dioxus, we chose to keep it simple and follow in the footsteps of the Recoil.JS project.

Fermi uses the concept of "Atoms" for global state. These individual values can be get/set from anywhere in your app. Using state with Fermi is basically as simple as use_state.

// Create a single value in an "Atom"
static TITLE: Atom<&str> = |_| "Hello";

// Read the value from anywhere in the app, subscribing to any changes
fn app(cx: Scope) -> Element {
    let title = use_read(&cx, TITLE);
    cx.render(rsx!{
        h1 { "{title}" }
        Child {}
    })
}

// Set the value from anywhere in the app
fn Child(cx: Scope) -> Element {
    let set_title = use_set(&cx, TITLE);
    cx.render(rsx!{
        button {
            onclick: move |_| set_title("goodbye"),
            "Say goodbye"
        }
    })
}

Inline Props Macro

For internal components, explicitly declaring props structs can become tedious. That's why we've built the new inline_props macro. This macro lets you inline your props definition right into your component function arguments.

Simply add the inline_props macro to your component:

#[inline_props]
fn Child<'a>(
    cx: Scope,
    name: String,
    age: String,
    onclick: EventHandler<'a, ClickEvent>
) -> Element {
    cx.render(rsx!{
        button {
            "Hello, {name}"
            "You are {age} years old"
            onclick: move |evt| onclick.call(evt)
        }
    })
}

You won't be able to document each field or attach attributes so you should refrain from using it in libraries.

Props optional fields

Sometimes you don't want to specify every value in a component's props, since there might a lot. That's why the Props macro now supports optional fields. You can use a combination of default, strip_option, and optional to tune the exact behavior of properties fields.

#[derive(Props, PartialEq)]
struct ChildProps {
    #[props(default = "client")]
    name: String,

    #[props(default)]
    age: Option<u32>,

    #[props(optional)]
    age: Option<u32>,
}

// then to use the accompanying component
rsx!{
    Child {
        name: "asd",
    }
}

Dioxus Web Speed Boost

We've changed how DOM patching works in Dioxus-Web; now, all of the DOM manipulation code is written in TypeScript and shared between our web, desktop, and mobile runtimes.

On an M1-max, the "create-rows" operation used to take 45ms. Now, it takes a mere 17ms - 3x faster than React. We expect an upcoming optimization to bring this number as low as 3ms.

Under the hood, we have a new string interning engine to cache commonly used tags and values on the Rust <-> JS boundary, resulting in significant performance improvements.

Overall, Dioxus apps are even more snappy than before.

Before and after:
Before and After

Dioxus Desktop Window Context

A very welcome change, thanks AGAIN to @mrxiaozhuox is support for imperatively controlling the desktop window from your Dioxus code.

A bunch of new methods were added:

  • Minimize and maximize window
  • Close window
  • Focus window
  • Enable devtools on the fly

And more!

In addition, Dioxus Desktop now autoresolves asset locations, so you can easily add local images, JS, CSS, and then bundle it into an .app without hassle.

You can now build entirely borderless desktop apps:

img

CLI Tool

Thanks to the amazing work by @mrxiaozhuox, our CLI tool is fixed and working better than ever. The Dioxus-CLI sports a new development server, an HTML to RSX translation engine, a cargo fmt-style command, a configuration scheme, and much more.

Unlike its counterpart, Trunk.rs, the dioxus-cli supports running examples and tests, making it easier to test web-based projects and showcase web-focused libraries.

Async Improvements

Working with async isn't the easiest part of Rust. To help improve things, we've upgraded async support across the board in Dioxus.

First, we upgraded the use_future hook. It now supports dependencies, which let you regenerate a future on the fly as its computed values change. It's never been easier to add datafetching to your Rust Web Apps:

fn RenderDog(cx: Scope, breed: String) -> Element {
    let dog_request = use_future(&cx, (breed,), |(breed,)| async move {
        reqwest::get(format!("https://dog.ceo/api/breed/{}/images/random", breed))
            .await
            .unwrap()
            .json::<DogApi>()
            .await
    });

    cx.render(match dog_request.value() {
        Some(Ok(url)) => rsx!{ img { url: "{url}" } },
        Some(Err(url)) => rsx!{ span { "Loading dog failed" }  },
        None => rsx!{ "Loading dog..." }
    })
}

Additionally, we added better support for coroutines. You can now start, stop, resume, and message with asynchronous tasks. The coroutine is automatically exposed to the rest of your app via the Context API. For the vast majority of apps, Coroutines can satisfy all of your state management needs:

fn App(cx: Scope) -> Element {
    let sync_task = use_coroutine(&cx, |rx| async move {
        connect_to_server().await;
        let state = MyState::new();

        while let Some(action) = rx.next().await {
            reduce_state_with_action(action).await;
        }
    });

    cx.render(rsx!{
        button {
            onclick: move |_| sync_task.send(SyncAction::Username("Bob")),
            "Click to sync your username to the server"
        }
    })
}

All New Features

We've covered the major headlining features, but there were so many more!

  • A new router @autarch
  • Fermi for global state management
  • Translation of docs and Readme into Chinese @mrxiaozhuox
  • 2.5x speedup by using JS-based DOM manipulation (3x faster than React)
  • Beautiful documentation overhaul
  • InlineProps macro allows definition of props within a component's function arguments
  • Improved dev server, hot reloading for desktop and web apps @mrxiaozhuox
  • Templates: desktop, web, web/hydration, Axum + SSR, and more @mrxiaozhuox
  • Web apps ship with console_error_panic_hook enabled, so you always get tracebacks
  • Enhanced Hydration and server-side-rendering (recovery, validation)
  • Optional fields for component properties
  • Introduction of the EventHandler type
  • Improved use_state hook to be closer to react
  • Improved use_ref hook to be easier to use in async contexts
  • New use_coroutine hook for carefully controlling long-running async tasks
  • Prevent Default attribute
  • Provide Default Context allows injection of global contexts to the top of the app
  • push_future now has a spawn counterpart to be more consistent with rust
  • Add gap and gap_row attributes @FruitieX
  • File Drag n Drop support for Desktop
  • Custom handler support for desktop
  • Forms now collect all their values in oninput/onsubmit
  • Async tasks now are dropped when components unmount
  • Right-click menus are now disabled by default

Fixes

  • Windows support improved across the board
  • Linux support improved across the board
  • Bug in Calculator example
  • Improved example running support

A ton more! Dioxus is now much more stable than it was at release!

Breaking Changes and Migrations

  • UseState is not Copy - but now supports Clone for use in async. for_async has been removed
  • UseFuture and UseEffect now take dependency tuples
  • UseCoroutine is now exposed via the context API and takes a receiver
  • Async tasks are canceled when components are dropped
  • The ContextAPI no longer uses RC to share state - anything that is Clone can be shared

Community Additions

Looking Forward

Dioxus is still under rapid, active development. We'd love for you to get involved! For the next release, we're looking to add:

  • Native WGPU renderer support
  • A query library like react-query
  • Multiwindow desktop app support
  • Full LiveView integrations for Axum, Warp, and Actix
  • A builder pattern for elements (no need for rsx!)
  • Autoformatting of rsx! code (like cargo fmt)
  • Improvements to the VSCode Extension

If you're interested in building an app with Dioxus, make sure to check us out on:

What's Changed

New Contributors

Full Changelog: https://github.com/DioxusLabs/dioxus/compare/v0.1.7...v0.2.0

dioxus - v0.1.7

Published by jkelleyrtp almost 3 years ago

Bug Fixes

  • tests

Commit Statistics

  • 1 commit contributed to the release over the course of 2 calendar days.
  • 1 commit where understood as conventional.
  • 0 issues like '(#ID)' where seen in commit messages

Commit Details

  • Uncategorized
    • tests (bd341f5)
dioxus - dioxus-web v0.0.4

Published by jkelleyrtp almost 3 years ago

Documentation

  • fix the reference code
  • update cargo tomls
  • update local examples and docs to support new syntaxes
  • lnks to projects
  • big updates to the reference
  • move around examples

New Features

  • handle bool attrs properly

  • make hydration more robust

  • overhaul examples and clean things up

  • more API updates

  • bubbling

  • upgrade syntax

  • events bubble now

  • support innerhtml

  • massage lifetimes

  • support desktop more completely

  • add update functionality to useref

  • shared state mechanisms

  • a cute crm

  • mutations

  • select figured out

  • re-enable suspense

  • amazingly awesome error handling

  • proper handling of events

  • mvoe away from compound context

  • make hooks free-functions

  • omg what a dumb mistake

  • suspense!

  • bless up, no more segfaults

  • more suspended nodes!

  • move over to push based mechanism

  • architecture document and edit list

  • it loads the doggos

  • task system works
    but I broke the other things :(

  • rebuild doesn't return errors

  • static node infrastructure and ssr changes

  • enable arbitrary body in rsx! macro

  • add edits back! and more webview support!
    This commit adds a new type - the DomEdit - for serializing the changes made by the diffing machine. The architecture of how DomEdits fit into the cooperative scheduling is still TBD but it will allow us to build change lists without applying them immediately. This is more performant and allows us to only render parts of the page at a time.

    This commit also adds more infrastructure around webview. Dioxus can now run on the web, generate static pages, run in the desktop, and run on mobile, with a large part of thanks to webview.

  • move to slotmap

  • integrate serialization and string borrowing
    This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.

  • events work again!

  • props memoization is more powerful
    This commit solves the memoization , properly memoizing properties that don't have any generic parameters. This is a rough heuristic to prevent non-static lifetimes from creeping into props and breaking our minual lifetime management.

    Props that have a generic parameter are opted-out of the partialeq requirement and props without lifetimes must implement partialeq. We're going to leave manual disabling of memoization for future work.

  • todomvc

  • somewhat working with rc and weak

Bug Fixes

  • add exclusion list
  • make tests pass
  • readme and examples syntax
  • keyword length
  • tags
  • all the bugs!
  • append isnt backwards

Performance

  • remove global allocation for props

Commit Statistics

  • 203 commits contributed to the release over the course of 358 calendar days.
  • 190 commits where understood as conventional.
  • 0 issues like '(#ID)' where seen in commit messages

Commit Details

  • Uncategorized
    • Release dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (a36dab7)
    • Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (40d1f85)
    • add exclusion list (2123228)
    • handle bool attrs properly (8d685f4)
    • Merge pull request #74 from mrxiaozhuox/master (47056fd)
    • Merge pull request #80 from DioxusLabs/jk/router2dotoh (cdc2d8e)
    • memoize dom in the prescence of identical components (cb2782b)
    • make hydration more robust (bbb6ee1)
    • new versions of everything (4ea5c99)
    • bump all versions (4f92ba4)
    • switch to log tracing (e2a6454)
    • fix the reference code (3de776c)
    • dioxus web (7abb3cc)
    • dioxus web (c0cd50b)
    • make tests pass (75fa7b4)
    • overhaul examples and clean things up (420a30e)
    • more API updates (a4f280d)
    • get web ready gto publish (2d58d38)
    • readme and examples syntax (3dc0e59)
    • rip out unsafe task engine (c7d001c)
    • upgrade to new version of dioxus core. (cda759c)
    • clean it up a bit (fa106be)
    • go back to noisy lifetime solution (8daf7a6)
    • clean up the core crate (e6c6bbd)
    • rename fc to component (1e4a599)
    • 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 (2b92837)
    • bubbling (19df1bd)
    • some docs and suspense (93d4b8c)
    • move examples around (1e6e5e6)
    • 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.0 (0d480a4)
    • keyword length (868f673)
    • docs and router (a5f05d7)
    • upgrade syntax (fd93ee8)
    • 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.0 (b32665d)
    • tags (a33f770)
    • events bubble now (f223406)
    • 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.0 (3a706ac)
    • update cargo tomls (e4c06ce)
    • 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.0 (270dfc9)
    • update local examples and docs to support new syntaxes (4de16c4)
    • support innerhtml (cfc24f5)
    • massage lifetimes (9726a06)
    • move everything over to a stack dst (0e9d5fc)
    • event system (1f22a06)
    • support desktop more completely (efd0e9b)
    • add update functionality to useref (a2b0c50)
    • lnks to projects (460783a)
    • overhaul event system (7a03c1d)
    • threadsafe (82953f2)
    • all the bugs! (478255f)
    • ssr (71f0df6)
    • shared state mechanisms (4a4c7af)
    • fix web list issue (da4423c)
    • move macro crate out of core (7bdad1e)
    • clean up to web (b43a964)
    • clean up the web module (823adc0)
    • slightly simplify crm (f07e345)
    • fix some event stuff for web and core (725b4a1)
    • a cute crm (718fa14)
    • on collaborative scheduling (1a32383)
    • examples (1a2f91e)
    • mutations (fac4233)
    • performance looks good, needs more testing (4b6ca05)
    • add test_dom (a652090)
    • bottom up dropping (f2334c1)
    • cleanup (1745a44)
    • select figured out (84b5ddd)
    • re-enable suspense (687cda1)
    • fill out the snippets (6051b0e)
    • amazingly awesome error handling (4a72b31)
    • some ideas (05c909f)
    • proper handling of events (d7940aa)
    • websys dom working properly (cfa0247)
    • big updates to the reference (583fdfa)
    • broken diff (f15e1fa)
    • cleanup workspace (8f0bb5d)
    • changes to scheduler (098d382)
    • web stuff (acad9ca)
    • making progress on diffing and hydration (49856cc)
    • mvoe away from compound context (a2c7d17)
    • make hooks free-functions (e5c88fe)
    • more work on suspense and documentation (37ed4be)
    • omg what a dumb mistake (f782e14)
    • suspense! (4837d8e)
    • refactor (8b0eb87)
    • bless up, no more segfaults (4a0068f)
    • more suspended nodes! (de9f61b)
    • more docs (34c3107)
    • basic support for scheduled rendering (c52af22)
    • move over to push based mechanism (80e6c25)
    • solve some issues regarding listeners (dfaf5ad)
    • architecture document and edit list (e723876)
    • move to slab (6084fbc)
    • change in cx to cx (9971ff2)
    • move things into a "shared" object (f644d7c)
    • it loads the doggos (abf4759)
    • task system works (3a57b94)
    • more overhaul on virtualevents (41cc429)
    • more work on web (3bf19d8)
    • ricraf polyfill (59219b9)
    • ....sigh..... so the diffing algorithm is robust (68ed1c0)
    • remove global allocation for props (8b3ac0b)
    • ric_raf wired up (8b0d04c)
    • rebuild doesn't return errors (f457b71)
    • more examples (56e7eb8)
    • tests and documentation (da81591)
    • append isnt backwards (df8aa77)
    • it works but the page is backwards (cdcd861)
    • static node infrastructure and ssr changes (9abb047)
    • more refactor for async (975fa56)
    • enable arbitrary body in rsx! macro (7aec40d)
    • working on async diff (f41cff5)
    • move some examples around (98a0933)
    • fix issues with lifetimes (a38a81e)
    • groundwork for noderefs (c1afeba)
    • more examples (11f89e5)
    • add edits back! and more webview support! (904b26f)
    • enable more diffing (e8f29a8)
    • example (eb39b00)
    • wip (952a91d)
    • integrate signals (93900aa)
    • move to slotmap (7665f2c)
    • integrate serialization and string borrowing (f4fb5bb)
    • more work on diffing machine (9813f23)
    • rename ctx to cx (81382e7)
    • move around examples (70cd46d)
    • start moving events to rc (b9ff95f)
    • rename recoil to atoms (36ea39a)
    • more examples and docs (7fbaf69)
    • more work on updating syntad (47e8960)
    • some cleanup and documentation (517d7f1)
    • docs (f5683a2)
    • pre vnodes instead of vnode (fe6938c)
    • events work again! (9d7ee79)
    • props memoization is more powerful (73047fe)
    • massive changes to definition of components (508c560)
    • moving to IDs (79127ea)
    • move to static props (c1fd848)
    • doesnt share on thread (fe67ff9)
    • parity document (ba97541)
    • recoil (ee67654)
    • buff the readme and docs (3cfa1fe)
    • Todomvc in progress (b843dbd)
    • introduce children for walking down the tree (0d44f00)
    • Clean up repo a bit (a99147c)
    • some code health (c28697e)
    • major overhaul to diffing (9810fee)
    • Wip (c809095)
    • refactor a bit (2eeb8f2)
    • todos (8c541f6)
    • todomvc (cfa0927)
    • todomvc (ce33031)
    • more ergonomics, more examples (0bcff1f)
    • building large apps, revamp macro (9f7f43b)
    • more liveview and webview custom client (9b560df)
    • livehost bones (7856f2b)
    • some stuff related to event listeners. POC for lifecyel (5b7887d)
    • diffing approach slightly broken (4e48e05)
    • remove old macro (9d0727e)
    • add deeply neste example (e66827e)
    • update examples (39bd185)
    • ensure mutabality is okay when not double-using the components (305ff91)
    • somewhat working with rc and weak (d4f1cea)
    • foregin eq from comparapable comp type. (ec801ea)
    • staticify? (5ad8188)
    • Feat: it's awersome (8dc2619)
    • yeet, synthetic somewhat wired up (d959806)
    • remove FC (92d9521)
    • more cleanup (5a9155b)
    • add context to builder (cf16090)
    • listeners now have scope information (fcd68e6)
    • broken, but solved (cb74d70)
    • accept closures directly in handler (f225030)
    • bug that phantom triggered events (07f671c)
    • wowza got it all working (4b8e9f4)
    • update readme and examples (ffaf687)
    • view -> render (c8bb392)
    • bump core version (6fabd8c)
    • update and prep for dioxusweb (ab655ea)
    • a few bugs, but the event system works! (3b30fa6)
    • moving to CbIdx as serializable event system (e840f47)
    • custom format_args for inlining variables into html templates (e4b1f6e)
    • begin WIP on html macro (a8b1225)
    • move webview logic into library (32b45e5)
    • comments (18a7a1f)
    • buff up examples and docs (8d3e2ad)
    • wire up rebuild (06ae4fc)
    • update websys with lifecycle (4d01455)
    • fix internal lifecycle (5204862)
    • add css example (edf09c1)
    • WIP ctx (7a6aabe)
    • desktop app wired up (b3e6886)
    • re-enable stack machine approach (e3ede7f)
    • WIP on deserialize (f22ff83)
    • web example + cli writes to browser screen! (8439994)
    • wire up a very basic dom updater (c4e8d8b)
    • major overhaul to diffing, using a "diffing machine" now (4dfdf91)
    • remove generic paramter on VDOM (4c291a0)
    • wire up some of the changelist for diff (d063a19)
    • event loop (ea2aa4b)
    • Dioxus-webview (9c01736)
    • more docs, dissolve vnode crate into dioxus-core (9c616ea)
    • WIP (ce34d0d)
dioxus - dioxus-ssr v0.1.2

Published by jkelleyrtp almost 3 years ago

Documentation

  • update cargo tomls
  • update local examples and docs to support new syntaxes
  • big updates to the reference

New Features

  • make hydration more robust
  • overhaul examples and clean things up
  • enable children properly
  • upgrade syntax
  • support innerhtml
  • add more to ssr renderer
  • massage lifetimes
  • some docs, cleaning
  • a new vnode type for anchors
  • code quality improvements for core
  • mvoe away from compound context
  • wire up resource pool
  • omg what a dumb mistake
  • rebuild doesn't return errors
  • add aria
  • buff up html allowed attributes
  • enable components in ssr
  • static node infrastructure and ssr changes
  • todomvc

Bug Fixes

  • lastnodewastext in ssr
  • tests
  • readme and examples syntax
  • keyword length
  • tags

Commit Statistics

  • 84 commits contributed to the release over the course of 357 calendar days.
  • 75 commits where understood as conventional.
  • 0 issues like '(#ID)' where seen in commit messages

Commit Details

  • Uncategorized
    • Release dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (a36dab7)
    • Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (40d1f85)
    • Merge pull request #74 from mrxiaozhuox/master (47056fd)
    • Merge pull request #80 from DioxusLabs/jk/router2dotoh (cdc2d8e)
    • add palceholder as comment content (c6e917c)
    • always add spacing comments between textnodes (b3a774b)
    • lastnodewastext in ssr (dbb6e9b)
    • make hydration more robust (bbb6ee1)
    • new versions of everything (4ea5c99)
    • bump all versions (4f92ba4)
    • tests (bd341f5)
    • ssr (a2317bf)
    • overhaul examples and clean things up (420a30e)
    • remove runner on hook and then update docs (d156045)
    • arbitrary expressions excepted without braces (4c85bcf)
    • readme and examples syntax (3dc0e59)
    • enable children properly (b997b8e)
    • fix ssr (ded9696)
    • adjust memoization (e2e4d43)
    • rename fc to component (1e4a599)
    • 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 (2b92837)
    • rename (36d89be)
    • some docs and suspense (93d4b8c)
    • move examples around (1e6e5e6)
    • 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.0 (0d480a4)
    • keyword length (868f673)
    • docs and router (a5f05d7)
    • upgrade syntax (fd93ee8)
    • 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.0 (b32665d)
    • tags (a33f770)
    • 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.0 (3a706ac)
    • update cargo tomls (e4c06ce)
    • 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.0 (270dfc9)
    • update local examples and docs to support new syntaxes (4de16c4)
    • support innerhtml (cfc24f5)
    • clean up and add lazy renderer (d4dcb17)
    • add more to ssr renderer (63568c5)
    • massage lifetimes (9726a06)
    • threadsafe (82953f2)
    • ssr (71f0df6)
    • move macro crate out of core (7bdad1e)
    • remove wildcards (10d335a)
    • remove wildcard (ba8ced5)
    • cleanup (1745a44)
    • some ideas (05c909f)
    • websys dom working properly (cfa0247)
    • big updates to the reference (583fdfa)
    • docs, html! macro, more (caf772c)
    • cleanup workspace (8f0bb5d)
    • some docs, cleaning (c321532)
    • a new vnode type for anchors (d618092)
    • fix styling for ssr (f14d4ef)
    • making progress on diffing and hydration (49856cc)
    • code quality improvements for core (00231ad)
    • mvoe away from compound context (a2c7d17)
    • wire up resource pool (31702db)
    • more work on suspense and documentation (37ed4be)
    • omg what a dumb mistake (f782e14)
    • solve some issues regarding listeners (dfaf5ad)
    • move things into a "shared" object (f644d7c)
    • polish up some safety stuff and add suspense support in (ff1398b)
    • rebuild doesn't return errors (f457b71)
    • add aria (4091846)
    • more examples (56e7eb8)
    • buff up html allowed attributes (c79d9ae)
    • it works but the page is backwards (cdcd861)
    • ssr + tide (269e81b)
    • enable components in ssr (bbcb5a0)
    • static node infrastructure and ssr changes (9abb047)
    • back to vnode enum (64f289a)
    • rename ctx to cx (81382e7)
    • more work on updating syntad (47e8960)
    • massive changes to definition of components (508c560)
    • more progress on parity docs. (c5089ba)
    • dirty hack to enable send + sync on virtual dom (4d5c528)
    • doesnt share on thread (fe67ff9)
    • remove old code (3de54d0)
    • Clean up repo a bit (a99147c)
    • todomvc (cfa0927)
    • todomvc (ce33031)
    • building large apps, revamp macro (9f7f43b)
    • include the helper (07341d2)
    • update fc_macro (28ac37a)
    • more docs, example, mroe nodes (d13e04c)
dioxus - dioxus-router v0.1.0

Published by jkelleyrtp almost 3 years ago

Documentation

  • update local examples and docs to support new syntaxes
  • update cargo tomls

New Features

  • it compiles once more
  • add prevent default attribute and upgrade router
  • overhaul examples and clean things up
  • more API updates

Bug Fixes

  • router version
  • really big bug around hooks
  • tags
  • keyword length
  • tests
  • make tests pass
  • readme and examples syntax

Commit Statistics

  • 42 commits contributed to the release over the course of 352 calendar days.
  • 35 commits where understood as conventional.
  • 0 issues like '(#ID)' where seen in commit messages

Commit Details

  • Uncategorized
    • Release dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (a36dab7)
    • Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (40d1f85)
    • add prevent default attribute and upgrade router (427b126)
    • memoize dom in the prescence of identical components (cb2782b)
    • bump all versions (4f92ba4)
    • tests (bd341f5)
    • switch to log tracing (e2a6454)
    • make tests pass (75fa7b4)
    • overhaul examples and clean things up (420a30e)
    • remove runner on hook and then update docs (d156045)
    • arbitrary expressions excepted without braces (4c85bcf)
    • add more svg elements, update readme (ad4a0eb)
    • more API updates (a4f280d)
    • readme and examples syntax (3dc0e59)
    • upgrade to new version of dioxus core. (cda759c)
    • remove portals completely (2fd56e7)
    • miri stress tets (934de21)
    • go back to noisy lifetime solution (8daf7a6)
    • rename fc to component (1e4a599)
    • docs (8814977)
    • prepare to change our fragment pattern. Add some more docs (2c3a046)
    • really big bug around hooks (52c7154)
    • 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 (2b92837)
    • it compiles once more (8acdd2e)
    • move examples around (1e6e5e6)
    • 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.0 (0d480a4)
    • updates to router (bab21a0)
    • add router (d298b62)
    • keyword length (868f673)
    • docs and router (a5f05d7)
    • 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.0 (b32665d)
    • tags (a33f770)
    • 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.0 (3a706ac)
    • update cargo tomls (e4c06ce)
    • 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.0 (270dfc9)
    • router version (58106a5)
    • bump versions (0846d93)
    • update local examples and docs to support new syntaxes (4de16c4)
    • rename ctx to cx (81382e7)
    • more work on updating syntad (47e8960)
    • massive changes to definition of components (508c560)
    • add router (6aeea9b)
dioxus - dioxus-mobile v0.0.3

Published by jkelleyrtp almost 3 years ago

Documentation

  • update cargo tomls
  • update local examples and docs to support new syntaxes
  • big updates to the reference

New Features

  • add update functionality to useref
  • omg what a dumb mistake

Bug Fixes

  • readme and examples syntax
  • keyword length
  • tags

Commit Statistics

  • 32 commits contributed to the release over the course of 151 calendar days.
  • 21 commits where understood as conventional.
  • 0 issues like '(#ID)' where seen in commit messages

Commit Details

  • Uncategorized
    • Release dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (a36dab7)
    • Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (40d1f85)
    • Merge pull request #74 from mrxiaozhuox/master (47056fd)
    • Merge pull request #80 from DioxusLabs/jk/router2dotoh (cdc2d8e)
    • Merge pull request #79 from DioxusLabs/jk/better_rehydration (34b0cb5)
    • fix typo in document (a17827f)
    • bump versions (b3b4c58)
    • bump mobile (b96491f)
    • mobile (95f01ae)
    • bump mobile (99d6409)
    • polish some more things (1496102)
    • readme and examples syntax (3dc0e59)
    • rename fc to component (1e4a599)
    • 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 (2b92837)
    • 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.0 (0d480a4)
    • keyword length (868f673)
    • 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.0 (b32665d)
    • tags (a33f770)
    • 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.0 (3a706ac)
    • update cargo tomls (e4c06ce)
    • 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.0 (270dfc9)
    • update local examples and docs to support new syntaxes (4de16c4)
    • book documentation (16dbf4a)
    • add update functionality to useref (a2b0c50)
    • overhaul event system (7a03c1d)
    • bottom up dropping (f2334c1)
    • big updates to the reference (583fdfa)
    • cleanup workspace (8f0bb5d)
    • omg what a dumb mistake (f782e14)
    • solve some issues regarding listeners (dfaf5ad)
    • move CLI into its own "studio" app (fd79335)
    • groundwork for noderefs (c1afeba)
dioxus - dioxus-hooks v0.1.6

Published by jkelleyrtp almost 3 years ago

Documentation

  • remove all usages of static closure syntax and update readme
  • update the docs
  • update cargo tomls
  • update local examples and docs to support new syntaxes
  • big updates to the reference
  • move around examples
  • move into a fromjs tutorial

New Features

  • allow use_ref to be cloned into callbacks
  • plug in bubbling
  • overhaul examples and clean things up
  • more API updates
  • it compiles once more
  • improve safety
  • massage lifetimes
  • add update functionality to useref
  • shared state mechanisms
  • mvoe away from compound context
  • omg what a dumb mistake
  • more suspended nodes!
  • wire up event delegator for webview
  • task system works
    but I broke the other things :(
  • static node infrastructure and ssr changes

Bug Fixes

  • component pass thru events
  • ci and bug in setter
  • make tests pass
  • readme and examples syntax
  • really big bug around hooks
  • keyword length
  • tags
  • desktop and mobile
  • all the bugs!

Commit Statistics

  • 93 commits contributed to the release over the course of 358 calendar days.
  • 82 commits where understood as conventional.
  • 0 issues like '(#ID)' where seen in commit messages

Commit Details

  • Uncategorized
    • Release dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (a36dab7)
    • Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (40d1f85)
    • component pass thru events (c439b0a)
    • Merge pull request #74 from mrxiaozhuox/master (47056fd)
    • Merge pull request #84 from DioxusLabs/jk/windows-lag (211d44d)
    • Merge branch 'master' into jk/router2dotoh (59f8b49)
    • allow use_ref to be cloned into callbacks (a890f39)
    • ci and bug in setter (4aadec1)
    • memoize dom in the prescence of identical components (cb2782b)
    • bump all versions (4f92ba4)
    • fix hooks docs (df168d0)
    • bump version (eab8422)
    • hooks (c606f92)
    • remove hooks warnigns (d788151)
    • plug in bubbling (d84fc05)
    • make tests pass (75fa7b4)
    • overhaul examples and clean things up (420a30e)
    • remove all usages of static closure syntax and update readme (cafb7df)
    • remove runner on hook and then update docs (d156045)
    • arbitrary expressions excepted without braces (4c85bcf)
    • polish some more things (1496102)
    • more API updates (a4f280d)
    • upgrade hooks (b3ac2ee)
    • readme and examples syntax (3dc0e59)
    • update the docs (c0e0196)
    • rip out unsafe task engine (c7d001c)
    • upgrade to new version of dioxus core. (cda759c)
    • remove portals completely (2fd56e7)
    • go back to noisy lifetime solution (8daf7a6)
    • clean up the core crate (e6c6bbd)
    • make warnings go away (0545d27)
    • rename fc to component (1e4a599)
    • docs (8814977)
    • update hooks (597a045)
    • really big bug around hooks (52c7154)
    • better desktop support (25a8411)
    • 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 (2b92837)
    • it compiles once more (8acdd2e)
    • move examples around (1e6e5e6)
    • 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.0 (0d480a4)
    • keyword length (868f673)
    • docs and router (a5f05d7)
    • 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.0 (b32665d)
    • tags (a33f770)
    • Merge branch 'master' into jk/remove_node_safety (db00047)
    • 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.0 (3a706ac)
    • Merge branch 'master' of https://github.com/jkelleyrtp/dioxus (60d6eb2)
    • update cargo tomls (e4c06ce)
    • bubbling in progress (a21020e)
    • desktop and mobile (601078f)
    • update local examples and docs to support new syntaxes (4de16c4)
    • docs (3ddf395)
    • improve safety (fda2ebc)
    • massage lifetimes (9726a06)
    • major cleanups to scheduler (2933e4b)
    • add update functionality to useref (a2b0c50)
    • all the bugs! (478255f)
    • shared state mechanisms (4a4c7af)
    • fix web list issue (da4423c)
    • remove wildcard (ba8ced5)
    • clean up the web module (823adc0)
    • examples (1a2f91e)
    • performance looks good, needs more testing (4b6ca05)
    • cleanup (1745a44)
    • fill out the snippets (6051b0e)
    • big updates to the reference (583fdfa)
    • docs, html! macro, more (caf772c)
    • mvoe away from compound context (a2c7d17)
    • examples (f1cff84)
    • omg what a dumb mistake (f782e14)
    • more suspended nodes! (de9f61b)
    • wire up event delegator for webview (7dfe89c)
    • task system works (3a57b94)
    • move examples around (304259d)
    • ssr + tide (269e81b)
    • static node infrastructure and ssr changes (9abb047)
    • more refactor for async (975fa56)
    • some project refactor (8cfc437)
    • move some examples around (98a0933)
    • rename ctx to cx (81382e7)
    • move around examples (70cd46d)
    • pre vnodes instead of vnode (fe6938c)
    • move into a fromjs tutorial (69f5cc3)
    • massive changes to definition of components (508c560)
    • major overhaul to diffing (9810fee)
    • cargo fix to clean up things (78d093a)
    • overall API updates (f47651b)
    • implememt nodes better (edbb33b)
    • comment out examples and move lifetime in FC type (62d4ad5)
    • updates to docs, extension (a2406b3)
    • add webview example (65d0d61)
    • add hooks (c1b990b)
    • docs, code frm percy (2b9c8d0)
dioxus - dioxus-desktop v0.1.5

Published by jkelleyrtp almost 3 years ago

Documentation

  • update cargo tomls
  • update local examples and docs to support new syntaxes
  • lnks to projects

New Features

  • handle bool attrs properly
  • add prevent default attribute and upgrade router
  • make hydration more robust
  • plug in bubbling
  • overhaul examples and clean things up
  • more API updates
  • enable children properly
  • bubbling
  • it properly bubbles
  • upgrade syntax
  • fake bubbling
  • improve safety
  • massage lifetimes
  • support desktop more completely
  • add update functionality to useref
  • desktop functioning well
  • shared state mechanisms
  • mutations
  • mvoe away from compound context
  • omg what a dumb mistake
  • bless up, no more segfaults
  • wire up event delegator for webview

Bug Fixes

  • add exclusion list
  • tests
  • readme and examples syntax
  • really big bug around hooks
  • keyword length
  • tags
  • desktop and mobile
  • messed up how lifetimes worked, need to render once per component

Commit Statistics

  • 91 commits contributed to the release over the course of 151 calendar days.
  • 78 commits where understood as conventional.
  • 0 issues like '(#ID)' where seen in commit messages

Commit Details

  • Uncategorized
    • Release dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (a36dab7)
    • Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (40d1f85)
    • add exclusion list (2123228)
    • handle bool attrs properly (8d685f4)
    • Merge pull request #89 from DioxusLabs/jk/simplify-example-run (8b6aa8b)
    • Merge pull request #74 from mrxiaozhuox/master (47056fd)
    • Merge pull request #80 from DioxusLabs/jk/router2dotoh (cdc2d8e)
    • clear warnigns (175a6a1)
    • remove lag by forcing update (fd91158)
    • add prevent default attribute and upgrade router (427b126)
    • include desktop fixes (7cf15ee)
    • make hydration more robust (bbb6ee1)
    • Merge branch 'master' into jk/windows-desktop (be2d687)
    • try to fix pathing (ada24e7)
    • bump all versions (4f92ba4)
    • tests (bd341f5)
    • switch to log tracing (e2a6454)
    • bump desktop version (54103da)
    • desktop (c1f8424)
    • desktop (be6fac9)
    • plug in bubbling (d84fc05)
    • overhaul examples and clean things up (420a30e)
    • remove runner on hook and then update docs (d156045)
    • polish some more things (1496102)
    • more API updates (a4f280d)
    • readme and examples syntax (3dc0e59)
    • rip out unsafe task engine (c7d001c)
    • upgrade to new version of dioxus core. (cda759c)
    • clean it up a bit (fa106be)
    • enable children properly (b997b8e)
    • miri stress tets (934de21)
    • rename fc to component (1e4a599)
    • polish (8bf57dc)
    • prepare to change our fragment pattern. Add some more docs (2c3a046)
    • really big bug around hooks (52c7154)
    • better desktop support (25a8411)
    • 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 (2b92837)
    • bubbling (19df1bd)
    • move examples around (1e6e5e6)
    • 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.0 (0d480a4)
    • updates to router (bab21a0)
    • keyword length (868f673)
    • docs and router (a5f05d7)
    • it properly bubbles (9d8c5ca)
    • upgrade syntax (fd93ee8)
    • 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.0 (b32665d)
    • fake bubbling (11757dd)
    • tags (a33f770)
    • Merge branch 'master' into jk/remove_node_safety (db00047)
    • 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.0 (3a706ac)
    • Merge branch 'master' of https://github.com/jkelleyrtp/dioxus (60d6eb2)
    • update cargo tomls (e4c06ce)
    • desktop and mobile (601078f)
    • 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.0 (270dfc9)
    • slim down tokio (e86c1d8)
    • update local examples and docs to support new syntaxes (4de16c4)
    • docs (a42711a)
    • improve safety (fda2ebc)
    • massage lifetimes (9726a06)
    • book documentation (16dbf4a)
    • more changes to scheduler (059294a)
    • messed up how lifetimes worked, need to render once per component (ba9e1db)
    • major cleanups to scheduler (2933e4b)
    • move everything over to a stack dst (0e9d5fc)
    • support desktop more completely (efd0e9b)
    • add update functionality to useref (a2b0c50)
    • lnks to projects (460783a)
    • desktop functioning well (5502429)
    • more example images (2403990)
    • overhaul event system (7a03c1d)
    • threadsafe (82953f2)
    • shared state mechanisms (4a4c7af)
    • clean up the web module (823adc0)
    • fix some event stuff for web and core (725b4a1)
    • mutations (fac4233)
    • add test_dom (a652090)
    • bottom up dropping (f2334c1)
    • cleanup (1745a44)
    • docs, html! macro, more (caf772c)
    • cleanup workspace (8f0bb5d)
    • clean up warnings (b32e261)
    • web stuff (acad9ca)
    • making progress on diffing and hydration (49856cc)
    • mvoe away from compound context (a2c7d17)
    • omg what a dumb mistake (f782e14)
    • refactor (8b0eb87)
    • bless up, no more segfaults (4a0068f)
    • wire up event delegator for webview (7dfe89c)
    • solve some issues regarding listeners (dfaf5ad)
    • more overhaul on virtualevents (41cc429)
    • groundwork for noderefs (c1afeba)
dioxus - dioxus-html v0.1.4

Published by jkelleyrtp almost 3 years ago

Documentation

  • update cargo tomls
  • update readme
  • big updates to the reference

New Features

  • enable prevent_default everywhere
  • eanble bubbling
  • plug in bubbling
  • fake bubbling
  • events bubble now
  • support innerhtml
  • shared state mechanisms
  • a cute crm
  • svgs working in webview
  • more suspended nodes!
  • add aria
  • buff up html allowed attributes
  • beaf up the use_state hook
  • enable arbitrary body in rsx! macro

Bug Fixes

  • component pass thru events
  • make tests pass
  • keyword length
  • tags
  • desktop and mobile

Commit Statistics

  • 60 commits contributed to the release over the course of 184 calendar days.
  • 52 commits where understood as conventional.
  • 0 issues like '(#ID)' where seen in commit messages

Commit Details

  • Uncategorized
    • Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (40d1f85)
    • enable prevent_default everywhere (9dff700)
    • component pass thru events (c439b0a)
    • memoize dom in the prescence of identical components (cb2782b)
    • new versions of everything (4ea5c99)
    • bump all versions (4f92ba4)
    • update core, core-macro, and html (f9b9bb9)
    • eanble bubbling (06276ed)
    • plug in bubbling (d84fc05)
    • make tests pass (75fa7b4)
    • remove runner on hook and then update docs (d156045)
    • bump html crate (18f1fa4)
    • add more svg elements (8f9a328)
    • add more svg elements, update readme (ad4a0eb)
    • polish some more things (1496102)
    • upgrade hooks (b3ac2ee)
    • fix documentation page (42c6d17)
    • rename fc to component (1e4a599)
    • polish (8bf57dc)
    • prepare to change our fragment pattern. Add some more docs (2c3a046)
    • 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 (2b92837)
    • 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.0 (0d480a4)
    • keyword length (868f673)
    • docs and router (a5f05d7)
    • 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.0 (b32665d)
    • fake bubbling (11757dd)
    • tags (a33f770)
    • events bubble now (f223406)
    • 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.0 (3a706ac)
    • Merge branch 'master' of https://github.com/jkelleyrtp/dioxus (60d6eb2)
    • update cargo tomls (e4c06ce)
    • desktop and mobile (601078f)
    • 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.0 (270dfc9)
    • bump versions (0846d93)
    • support innerhtml (cfc24f5)
    • major cleanups to scheduler (2933e4b)
    • more raw ptrs (95bd17e)
    • update readme (285b33d)
    • shared state mechanisms (4a4c7af)
    • fix web list issue (da4423c)
    • html package (740cbd1)
    • and publish (51e2005)
    • clean up the web module (823adc0)
    • a cute crm (718fa14)
    • examples (1a2f91e)
    • some ideas (05c909f)
    • big updates to the reference (583fdfa)
    • cleanup workspace (8f0bb5d)
    • svgs working in webview (3bedcb9)
    • more doc (adf202e)
    • more suspended nodes! (de9f61b)
    • solve some issues regarding listeners (dfaf5ad)
    • wip (996247a)
    • add aria (4091846)
    • more examples (56e7eb8)
    • buff up html allowed attributes (c79d9ae)
    • it works but the page is backwards (cdcd861)
    • use the new structure (a05047d)
    • beaf up the use_state hook (e4cdb64)
    • enable arbitrary body in rsx! macro (7aec40d)
dioxus - dioxus-core v0.1.7

Published by jkelleyrtp almost 3 years ago

Documentation

  • add title to doc comment
  • better document the EventHandler type
  • more docs
  • strong improvmenets, first major section done
  • update cargo tomls
  • start on components
  • update local examples and docs to support new syntaxes
  • fix table
  • lnks to projects
  • big updates to the reference
  • examples
  • more docs
  • move around examples
  • move into a fromjs tutorial
  • add some more sources in the core implementation

New Features

  • add prevent default attribute and upgrade router

  • make hydration more robust

  • eanble bubbling

  • plug in bubbling

  • more API updates

  • enable children properly

  • it works with a new bump each time!!

  • move back to combined cx/props

  • bubbling

  • it compiles once more

  • should be functional across the boar

  • wire tasks up

  • wire up linked nodes

  • it properly bubbles

  • upgrade syntax

  • fake bubbling

  • events bubble now

  • pull children out of component definition

  • cleanuup

  • full html support

  • improve FC handling to allow lifetimes of parent

  • improve safety

  • massage lifetimes

  • support desktop more completely

  • add update functionality to useref

  • desktop functioning well

  • shared state mechanisms

  • mutations

  • re-enable suspense

  • amazingly awesome error handling

  • proper handling of events

  • keyed diffing!!

  • update root props

  • some docs, cleaning

  • more and more sophisticated diff

  • a new vnode type for anchors

  • code quality improvements for core

  • mvoe away from compound context

  • wire up resource pool

  • make hooks free-functions

  • transition to cx, props

  • omg what a dumb mistake

  • suspense!

  • bless up, no more segfaults

  • more suspended nodes!

  • wire up event delegator for webview

  • fix some lifetime issues

  • move over to push based mechanism

  • architecture document and edit list

  • task system works
    but I broke the other things :(

  • rebuild doesn't return errors

  • add aria

  • buff up html allowed attributes

  • enable components in ssr

  • keyed diffing

  • static node infrastructure and ssr changes

  • tests and benchmarks

  • dedicated mutations module

  • refactor out the hooks implementation

  • fix compiling

  • move webview to wry

  • beaf up the use_state hook

  • namespaced attributes
    this commit adds namespaced attributes. This lets us support attribute groups, and thus, inline styles.

    This namespaced attribute stuff is only available for styles at the moment, though it theoretically could be enabled for any other attributes.

  • add edits back! and more webview support!
    This commit adds a new type - the DomEdit - for serializing the changes made by the diffing machine. The architecture of how DomEdits fit into the cooperative scheduling is still TBD but it will allow us to build change lists without applying them immediately. This is more performant and allows us to only render parts of the page at a time.

    This commit also adds more infrastructure around webview. Dioxus can now run on the web, generate static pages, run in the desktop, and run on mobile, with a large part of thanks to webview.

  • two calculator examples

  • move to slotmap

  • integrate serialization and string borrowing
    This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.

  • events work again!

  • props memoization is more powerful
    This commit solves the memoization , properly memoizing properties that don't have any generic parameters. This is a rough heuristic to prevent non-static lifetimes from creeping into props and breaking our minual lifetime management.

    Props that have a generic parameter are opted-out of the partialeq requirement and props without lifetimes must implement partialeq. We're going to leave manual disabling of memoization for future work.

  • todomvc

  • somewhat working with rc and weak

  • dyn scope

  • update builder

Bug Fixes

  • component pass thru events
  • ci and bug in setter
  • attempt to fix ice
  • tests
  • make tests pass
  • readme and examples syntax
  • really big bug around hooks
  • keyword length
  • tags
  • desktop and mobile
  • it compiles again
  • use annotation method from rust/58052 to fix closure lifetimes
  • messed up how lifetimes worked, need to render once per component
  • all the bugs!

Performance

  • remove global allocation for props
  • refcell to cell for hookidx

Commit Statistics

  • 437 commits contributed to the release over the course of 358 calendar days.
  • 416 commits where understood as conventional.
  • 0 issues like '(#ID)' where seen in commit messages

Commit Details

  • Uncategorized
    • Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 (40d1f85)
    • add title to doc comment (d11f322)
    • better document the EventHandler type (be9f1a5)
    • component pass thru events (c439b0a)
    • Merge pull request #74 from mrxiaozhuox/master (47056fd)
    • Merge pull request #80 from DioxusLabs/jk/router2dotoh (cdc2d8e)
    • ci and bug in setter (4aadec1)
    • add prevent default attribute and upgrade router (427b126)
    • memoize dom in the prescence of identical components (cb2782b)
    • make hydration more robust (bbb6ee1)
    • bump all versions (4f92ba4)
    • attempt to fix ice (2481cd0)
    • tests (bd341f5)
    • update core, core-macro, and html (f9b9bb9)
    • eanble bubbling (06276ed)
    • plug in bubbling (d84fc05)
    • run cargo fmt (a95dead)
    • make tests pass (75fa7b4)
    • remove runner on hook and then update docs (d156045)
    • arbitrary expressions excepted without braces (4c85bcf)
    • polish some more things (1496102)
    • bump core version (ddfa2ba)
    • more API updates (a4f280d)
    • clean up examples and demo list (944b3a8)
    • upgrade hooks (b3ac2ee)
    • readme and examples syntax (3dc0e59)
    • rip out unsafe task engine (c7d001c)
    • continue to consolidate (21e00c1)
    • upgrade to new version of dioxus core. (cda759c)
    • clean it up a bit (fa106be)
    • enable children properly (b997b8e)
    • fix ssr (ded9696)
    • remove portals completely (2fd56e7)
    • some basic cleaning (f746793)
    • it works with a new bump each time!! (78d9056)
    • miri stress tets (934de21)
    • go back to noisy lifetime solution (8daf7a6)
    • clean up the core crate (e6c6bbd)
    • adjust memoization (e2e4d43)
    • adjust semantics of placeholders and fragments (1c516ab)
    • rename fc to component (1e4a599)
    • docs (8814977)
    • polish (8bf57dc)
    • prepare to change our fragment pattern. Add some more docs (2c3a046)
    • update hooks (597a045)
    • really big bug around hooks (52c7154)
    • better desktop support (25a8411)
    • 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 (2b92837)
    • move back to combined cx/props (96b3d56)
    • rename (36d89be)
    • bubbling (19df1bd)
    • it compiles once more (8acdd2e)
    • some docs and suspense (93d4b8c)
    • update readme (9bd56ee)
    • should be functional across the boar (74c6211)
    • move examples around (1e6e5e6)
    • 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.0 (0d480a4)
    • updates to router (bab21a0)
    • wire tasks up (55e6dd9)
    • wire up linked nodes (c10c1f4)
    • add router (d298b62)
    • keyword length (868f673)
    • docs and router (a5f05d7)
    • it properly bubbles (9d8c5ca)
    • upgrade syntax (fd93ee8)
    • more docs (9874f34)
    • strong improvmenets, first major section done (54d050c)
    • 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.0 (b32665d)
    • fake bubbling (11757dd)
    • remove scopechildren in favor of elements directly (574d7fd)
    • remove send requirement on root props (5a21493)
    • tags (a33f770)
    • events bubble now (f223406)
    • move hooklist into scope (b9fc5fc)
    • Merge branch 'master' into jk/remove_node_safety (db00047)
    • 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.0 (3a706ac)
    • bubbling reserves nodes (b6262ed)
    • move testdom methods into virtualdom (d2f0547)
    • pull children out of component definition (2cf90b6)
    • Merge branch 'master' of https://github.com/jkelleyrtp/dioxus (60d6eb2)
    • Various typos/grammar/rewording (5747e00)
    • update cargo tomls (e4c06ce)
    • bubbling in progress (a21020e)
    • cleanup src (f2e343c)
    • move children onto scope (f438bbc)
    • desktop and mobile (601078f)
    • start on components (9b5f82a)
    • cleanuup (84fd0c6)
    • 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.0 (270dfc9)
    • it compiles again (77686ba)
    • move debugging virtualdom into its own feature (d1b294f)
    • clean up using new children syntax (9c13436)
    • fix some bugs around the rsx macro (339e450)
    • full html support (79503f1)
    • slim deps and upgrade docs (83dd49d)
    • work on scheduler, async, coroutines, and merge scope into context (b56ea6c)
    • implement dst magic (d4192d0)
    • update local examples and docs to support new syntaxes (4de16c4)
    • working on re-enabling components (fffc7ea)
    • a few things left, slme cleanup (289d2f2)
    • implement lazy nodes properly (3e07214)
    • fix table (e495b09)
    • fix rebuild (15c31d5)
    • dst drops properly (f33510b)
    • remove cx.children. start to move towards a "children" field (7b97e00)
    • clean up, use old approach to components (2559740)
    • dst nodes leak but work (62ed920)
    • improve FC handling to allow lifetimes of parent (6b2645f)
    • improve safety (fda2ebc)
    • move more stuff out (464b457)
    • try to get lifetimes passed in properly (f70b5b4)
    • listen to clippy (f492443)
    • remove bumpframe (e4cda7c)
    • use annotation method from rust/58052 to fix closure lifetimes (27d8919)
    • it compiles cleanly (fd0c384)
    • worked backwards a bit and got it slightly figured out (9ee2bfb)
    • massage lifetimes (9726a06)
    • book documentation (16dbf4a)
    • more changes to scheduler (059294a)
    • messed up how lifetimes worked, need to render once per component (ba9e1db)
    • major cleanups to scheduler (2933e4b)
    • move everything over to a stack dst (0e9d5fc)
    • event system (1f22a06)
    • no more lifetimes (d96276a)
    • support desktop more completely (efd0e9b)
    • compiling again with runtime safety (857c92f)
    • add update functionality to useref (a2b0c50)
    • more raw ptrs (95bd17e)
    • lnks to projects (460783a)
    • desktop functioning well (5502429)
    • remove resource pool in favor of raw ptrs (b8d9869)
    • overhaul event system (7a03c1d)
    • consolidation, simplification (70b983d)
    • threadsafe (82953f2)
    • all the bugs! (478255f)
    • ssr (71f0df6)
    • shared state mechanisms (4a4c7af)
    • fix typo (4a5041c)
    • fix web list issue (da4423c)
    • move macro crate out of core (7bdad1e)
    • portals (4a0bb8c)
    • polish (a5f82be)
    • exampels (04d16b4)
    • fix some event stuff for web and core (725b4a1)
    • garbage collection (dfe9f86)
    • on collaborative scheduling (1a32383)
    • examples (1a2f91e)
    • working down warnings (958c02a)
    • mutations (fac4233)
    • performance looks good, needs more testing (4b6ca05)
    • add test_dom (a652090)
    • bottom up dropping (f2334c1)
    • cleanup (1745a44)
    • more scheduler work (44b4384)
    • re-enable suspense (687cda1)
    • fill out the snippets (6051b0e)
    • amazingly awesome error handling (4a72b31)
    • some ideas (05c909f)
    • proper handling of events (d7940aa)
    • more work on scheduler (1cd5e69)
    • websys dom working properly (cfa0247)
    • big updates to the reference (583fdfa)
    • fix invalid is_empty bug (c7d2d9d)
    • more work on rebuild (5c3dc0a)
    • keyed diffing!! (d717c22)
    • docs, html! macro, more (caf772c)
    • update root props (fac2e56)
    • get keyed diffing compiling (0a0be95)
    • changes to scheduler (098d382)
    • some docs, cleaning (c321532)
    • more and more sophisticated diff (1749eba)
    • clean up warnings (b32e261)
    • a new vnode type for anchors (d618092)
    • more cleanup (5cbdc57)
    • more work on bumpframe (63a85e4)
    • heuristics engine (6aaad1c)
    • more cleanup in scheduler (9f99f46)
    • making progress on diffing and hydration (49856cc)
    • code quality improvements for core (00231ad)
    • mvoe away from compound context (a2c7d17)
    • examples (f1cff84)
    • wire up resource pool (31702db)
    • make hooks free-functions (e5c88fe)
    • more work on suspense and documentation (37ed4be)
    • transition to cx, props (bfdcb20)
    • more doc (adf202e)
    • cleanup public apis (927b05f)
    • omg what a dumb mistake (f782e14)
    • suspense! (4837d8e)
    • refactor (8b0eb87)
    • bless up, no more segfaults (4a0068f)
    • more suspended nodes! (de9f61b)
    • more docs (34c3107)
    • algo for scheduler finished (9ad5e49)
    • wire up event delegator for webview (7dfe89c)
    • basic support for scheduled rendering (c52af22)
    • feeling goodish about scheduler (5f63eda)
    • fix some lifetime issues (0a907b3)
    • move over to push based mechanism (80e6c25)
    • bubbling (7978a17)
    • some structure (bcaa76a)
    • solve some issues regarding listeners (dfaf5ad)
    • architecture document and edit list (e723876)
    • before scheduler simplify (c16b92e)
    • considering making vdom passed verywehre (ac3a7b1)
    • move to slab (6084fbc)
    • change in cx to cx (9971ff2)
    • more work on scheduler (d4d7114)
    • move things into a "shared" object (f644d7c)
    • reduce warnings (0ded32e)
    • it compiles again (07efb6a)
    • task system works (3a57b94)
    • more polish on display (12afd2b)
    • more overhaul on virtualevents (41cc429)
    • cargo fix (84c3e9f)
    • more polish on scopes (2386772)
    • more work on priority (cef116a)
    • cargo fix (beceda5)
    • polish up some safety stuff and add suspense support in (ff1398b)
    • refactor to fix some ownership quirks (05e960b)
    • cargo fix (fd03b9d)
    • remove unnecessary import (fb0c6d2)
    • fix props update (79e8df2)
    • more work on web (3bf19d8)
    • cargo fix (c7ca7c2)
    • more clean up (5a09ec1)
    • ricraf polyfill (59219b9)
    • cut down on errors (775e9e2)
    • ....sigh..... so the diffing algorithm is robust (68ed1c0)
    • remove global allocation for props (8b3ac0b)
    • ric_raf wired up (8b0d04c)
    • wip (996247a)
    • lots of changes to diffing (ff0a3d1)
    • change around how deadline works (369b36b)
    • rebuild doesn't return errors (f457b71)
    • add aria (4091846)
    • more examples (56e7eb8)
    • tests and documentation (da81591)
    • buff up html allowed attributes (c79d9ae)
    • move examples around (304259d)
    • it works but the page is backwards (cdcd861)
    • use the new structure (a05047d)
    • ssr + tide (269e81b)
    • more test (a0a977a)
    • enable components in ssr (bbcb5a0)
    • documentation and badges (3f68be7)
    • keyed diffing (0479252)
    • static node infrastructure and ssr changes (9abb047)
    • naming (1a6b238)
    • it works? (778baff)
    • more refactor for async (975fa56)
    • refactor non_keyed diff (082765f)
    • some project refactor (8cfc437)
    • tests and benchmarks (e6f5656)
    • some work (feab50f)
    • structure coming together and tests (2d541ec)
    • more refactor (58ab51a)
    • compiles again (16bfc6d)
    • more refactor (c811a89)
    • dedicated mutations module (db6d018)
    • refactor (9276fd7)
    • basic creates working properly (1622f48)
    • refactor out the hooks implementation (1cc1679)
    • tests added for new iterative (24572b6)
    • webview and async (eb82051)
    • fix compiling (2ce0752)
    • move webview to wry (99d94b6)
    • moving over instructions (0987760)
    • more examples (2547da3)
    • remove old create (7b06820)
    • beaf up the use_state hook (e4cdb64)
    • back to vnode enum (64f289a)
    • move from recursive to iterative (9652ccd)
    • move CLI into its own "studio" app (fd79335)
    • working on async diff (f41cff5)
    • more work on scheduler (882d695)
    • move some examples around (98a0933)
    • scheduler skeleton (9d14faf)
    • remove the scoped trait (cca7c5f)
    • more work on deadline, support immediates (5965bee)
    • move the functions around a bit (36542b4)
    • got the structure figured out! (97745c6)
    • fix issues with lifetimes (a38a81e)
    • close on putting it all together (85e2dc2)
    • namespaced attributes (22e659c)
    • groundwork for noderefs (c1afeba)
    • more work on jank free (a44e9fc)
    • more examples (11f89e5)
    • add edits back! and more webview support! (904b26f)
    • enable more diffing (e8f29a8)
    • two calculator examples (b5e5ef1)
    • examples (d9e6d09)
    • wip (952a91d)
    • integrate signals (93900aa)
    • move to slotmap (7665f2c)
    • more work on diffing (21685fb)
    • integrate serialization and string borrowing (f4fb5bb)
    • more work on diffing machine (9813f23)
    • more work on diffing. (ca3b80f)
    • stack-based "real child iterator" (895cc01)
    • more docs (0826fdf)
    • refcell to cell for hookidx (ea91fc9)
    • rename ctx to cx (81382e7)
    • rethinking stack machine (62ae5d3)
    • move around examples (70cd46d)
    • start moving events to rc (b9ff95f)
    • rename recoil to atoms (36ea39a)
    • more examples and docs (7fbaf69)
    • more work on updating syntad (47e8960)
    • some cleanup and documentation (517d7f1)
    • pre-diffmachine merge fork (424a181)
    • docs (f5683a2)
    • pre vnodes instead of vnode (fe6938c)
    • move into a fromjs tutorial (69f5cc3)
    • events work again! (9d7ee79)
    • successfully building (e3d9db0)
    • props memoization is more powerful (73047fe)
    • merge in some code from the other branch (7790750)
    • move the rsx macro around (50c8b93)
    • add some more sources in the core implementation (7102fe5)
    • new approach at direct access to vdom (795a54a)
    • some docs (1919f88)
    • get diff compiling (cff0547)
    • massive changes to definition of components (508c560)
    • moving to IDs (79127ea)
    • move to static props (c1fd848)
    • moving to imperative method of dom (45ee803)
    • more progress on parity docs. (c5089ba)
    • dirty hack to enable send + sync on virtual dom (4d5c528)
    • doesnt share on thread (fe67ff9)
    • recoil (ee67654)
    • Todomvc in progress (b843dbd)
    • introduce children for walking down the tree (0d44f00)
    • context api wired up (24805a0)
    • about to consolidate context and scope (4c8130c)
    • remove old code (3de54d0)
    • abstraction lifetimes work out nicely (2284b35)
    • Clean up repo a bit (a99147c)
    • some code health (c28697e)
    • major overhaul to diffing (9810fee)
    • Wip (c809095)
    • refactor a bit (2eeb8f2)
    • todos (8c541f6)
    • todomvc (cfa0927)
    • todomvc (ce33031)
    • more ergonomics, more examples (0bcff1f)
    • use rsx! inline! (44aad27)
    • building large apps, revamp macro (9f7f43b)
    • begint to accept iterator types (742f150)
    • livehost bones (7856f2b)
    • some stuff related to event listeners. POC for lifecyel (5b7887d)
    • diffing approach slightly broken (4e48e05)
    • remove old macro (9d0727e)
    • update examples (39bd185)
    • ensure mutabality is okay when not double-using the components (305ff91)
    • props now autoderives its own trait (b3c96a5)
    • somewhat working with rc and weak (d4f1cea)
    • foregin eq from comparapable comp type. (ec801ea)
    • staticify? (5ad8188)
    • cargo fix to clean up things (78d093a)
    • implement vcomp fully (29751a4)
    • add some docs (5abda91)
    • update component so build passes (8fcd001)
    • wire up props macro (37f5a7a)
    • still a bit stumped on DFS vs BFS (3740f81)
    • Feat: it's awersome (8dc2619)
    • revert FC changes (like the old style). (7158bc3)
    • dyn scope (89f2290)
    • yeet, synthetic somewhat wired up (d959806)
    • synthetic events wired up (ish) (3087813)
    • remove FC (92d9521)
    • notes on safety, and inline listeners (bdd6be3)
    • cleanup edit module (c70652a)
    • more cleanup (5a9155b)
    • add context to builder (cf16090)
    • listeners now have scope information (fcd68e6)
    • broken, but solved (cb74d70)
    • use_reducer (879e107)
    • wowza got it all working (4b8e9f4)
    • parse custom rsx syntax (da00df6)
    • update readme and examples (ffaf687)
    • view -> render (c8bb392)
    • bump core version (4997976)
    • remove html crate (9dcee01)
    • add core macro crate (c32a6ef)
    • bump version for web release (422d5ac)
    • a few bugs, but the event system works! (3b30fa6)
    • patch to diff to allow scopes (2041c88)
    • moving to CbIdx as serializable event system (e840f47)
    • custom format_args for inlining variables into html templates (e4b1f6e)
    • begin WIP on html macro (a8b1225)
    • move webview logic into library (32b45e5)
    • comments (18a7a1f)
    • wire up rebuild (06ae4fc)
    • clean up code (8345137)
    • fix internal lifecycle (5204862)
    • add css example (edf09c1)
    • borrowing (7a4594e)
    • finally solve the component lifetime problem <3 (bdc25b5)
    • WIP ctx (7a6aabe)
    • desktop app wired up (b3e6886)
    • remove our use of ouroborous. (bcbb93b)
    • re-enable stack machine approach (e3ede7f)
    • WIP on deserialize (f22ff83)
    • wire up a very basic dom updater (c4e8d8b)
    • major overhaul to diffing, using a "diffing machine" now (4dfdf91)
    • remove generic paramter on VDOM (4c291a0)
    • wire up some of the changelist for diff (d063a19)
    • event loop (ea2aa4b)
    • major overhaul, wire up event system (8295ac4)
    • overall API updates (f47651b)
    • push new component API and context API (125f542)
    • update builder (8329268)
    • update solved problems with context API (c97a964)
    • Feat: - integrate subscription service into context. - Update documentation (204f0d9)
    • fix docs names (ee23ea6)
    • implememt nodes better (edbb33b)
    • move out scope into its own file (c9d95dd)
    • capture pointer type (e939373)
    • more updates to hooks (2c2882c)
    • found a fast solution to hook state (4d01436)
    • comment out examples and move lifetime in FC type (62d4ad5)
    • include the helper (07341d2)
    • updates to docs, extension (a2406b3)
    • webview example (7730fd4)
    • Dioxus-webview (9c01736)
    • add router (6aeea9b)
    • dioxus frontend crate (4d7ac5b)
    • Add versioning for package (33a805d)
    • clean up naming (2afbfea)
    • prep for cargo (be8d267)
    • include diffing and patching in Dioxus (f3c650b)
    • more docs, dissolve vnode crate into dioxus-core (9c616ea)
    • more docs, example, mroe nodes (d13e04c)
    • some updates, pull in the vnode enums (152bced)
    • WIP (ce34d0d)
    • docs, code frm percy (2b9c8d0)
Package Rankings
Top 3.16% on Crates.io
Top 9.55% on Proxy.golang.org
Top 38.02% on Npmjs.org
Related Projects
react-redux-boilerplate

A meticulously crafted, extensible, and robust architecture for constructing production-grade Rea...

16 Jan 2024 43
component-party.dev

🎉 Web component JS frameworks overview by their syntax and features

28 Mar 2022 2,140
react-redux-boilerplate

Awesome React Redux Workflow Boilerplate with Webpack 4

25 Oct 2016 302