17 releases

0.7.4 Mar 24, 2024
0.7.2 Jan 26, 2024
0.7.0 Dec 3, 2023
0.6.5 Nov 29, 2023
0.1.1 Nov 18, 2022

#60 in GUI

Download history 77/week @ 2023-12-23 27/week @ 2023-12-30 230/week @ 2024-01-06 158/week @ 2024-01-13 527/week @ 2024-01-20 445/week @ 2024-01-27 315/week @ 2024-02-03 250/week @ 2024-02-10 610/week @ 2024-02-17 612/week @ 2024-02-24 381/week @ 2024-03-02 541/week @ 2024-03-09 639/week @ 2024-03-16 665/week @ 2024-03-23 353/week @ 2024-03-30 358/week @ 2024-04-06

2,090 downloads per month
Used in 5 crates

Apache-2.0

250KB
2K SLoC

Rust 1.5K SLoC // 0.0% comments TypeScript 338 SLoC // 0.1% comments Swift 36 SLoC // 0.2% comments Java 19 SLoC

Crux · GitHub license Crate version Docs Build status

Cross-platform app development in Rust

  • Shared Core for Behavior - Crux helps you share your app's business logic and behavior across mobile (iOS/Android) and web — as a single reusable core built with Rust.
  • Thin Shell for UI - Crux recognizes that the best experiences are built with modern declarative frameworks such as SwiftUI, Jetpack Compose, React/Vue, or a WebAssembly based framework (like Yew) — however, it aims to keep this UI layer as thin as it can be, with all other work done by the shared core.
  • Type Generation - the interface with the core has static type checking across languages — types and serialization code are generated for Swift, Kotlin and TypeScript. Rust shells can import the core directly.
  • Capabilities - capabilities express the intent for side effects such as calling an API. Because all side effects (including UI) are performed by the shell, the core becomes trivial to test comprehensively — test suites run in milliseconds (not in minutes or hours).

Getting Started

Learn how to use Crux in your project.

Follow the readme in the project's repository on Github.

Read the API documentation

Watch the introductory talk at the recent Rust Nation 2023 conference in London.

You can also join the friendly conversation on our Zulip channel.

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! :-)

Architectural Overview

Logical architecture

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.

Side-effect-free core

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:

  • Event — an enum describing 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.

Application Shell

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.

Dependencies

~3–5MB
~97K SLoC