4 releases (2 breaking)
|0.3.0||Feb 15, 2023|
|0.2.0||Dec 15, 2022|
|0.1.1||Nov 18, 2022|
|0.1.0||Nov 18, 2022|
#138 in WebAssembly
90 downloads per month
Used in 4 crates
Crux — Cross-platform app development in Rust
Crux helps you share your app's business logic and behavior across mobile (iOS and Android) and web, as a single, reusable core built with Rust.
Unlike React Native, but like Kotlin Multi-platform Mobile, the user interface layer is built natively, with modern declarative UI frameworks such as SwiftUI, Jetpack Compose and React/Vue or a Wasm based framework (like Yew) on the web.
The UI layer is as thin as it can be, and all other work is done by the shared core. The interface with the core has static type checking across languages.
Note, that Crux is experimental and currently under active development (probably not ready for use in production apps just yet). However, the master branch should always be working well, and we will try to keep the examples and documentation up to date as we go. We do think that the API has now settled, so have a play! :-)
- Read the book
- Follow the readme in the project's repository on Github.
- Read the API documentation
The fundamental architectural concept is the strict separation of pure computational tasks from tasks that cause side effects. This is similar to the way Elm works.
In the above diagram, the inner "Core" is compiled and linked to the outer "Shell" on each platform as a library:
- On iOS as a native static library
- On Android as a dynamic library using Java Native Access
- In a browser as a WebAssembly module
In fact, because WebAssembly (Wasm) is one of the compilation targets, the core must remain side-effect free, due to the sandboxed nature of the Wasm runtime environment.
As such, the core is completely isolated and secure against software supply-chain attacks, as it has no access to any external APIs. All it can do is perform pure calculations and keep internal state.
Following the Elm architecture, the core defines the key component types within the application:
enumdescribing the events which the core can handle
Model— describes the internal state of the application
ViewModel— represents information that should be displayed to the user
The former two are tied together by the
update function, familiar from Elm, Redux or other event sourcing architectures, which currently has this type signature:
fn update( &self, event: Event, model: &mut Model, capabilities: &Capabilities, )
The job of the
update function is to process an
Event, update the model accordingly, and potentially request some side-effects using capabilities.
The enclosing "Platform native shell" is written using the language appropriate for the platform, and acts as the runtime environment within which all the non-pure tasks are performed. From the perspective of the core, the shell is the platform on which the core runs.