#distributed #distributed-systems #cluster #compute #zk #task-execution #map-reduce


A Rust distributed algorithm toolkit. Write distributed algorithms without the complexities of distributed systems programming.

13 unstable releases (3 breaking)

0.4.2 Mar 11, 2024
0.4.1 Dec 3, 2023
0.3.3 Nov 24, 2023
0.2.0 Nov 16, 2023
0.1.3 Oct 29, 2023

#954 in Concurrency

Download history 93/week @ 2024-02-18 17/week @ 2024-02-25 11/week @ 2024-03-03 222/week @ 2024-03-10 100/week @ 2024-03-17 1/week @ 2024-03-24 46/week @ 2024-03-31 54/week @ 2024-04-07 83/week @ 2024-04-14 114/week @ 2024-04-21 17/week @ 2024-04-28 5/week @ 2024-05-05 15/week @ 2024-05-12

151 downloads per month




Bringing divine order to distributed computation.

Crates.io version docs.rs docs

Paladin in 2 sentences

Paladin is a Rust library that aims to simplify writing distributed programs. It provides a declarative API, allowing developers to articulate their distributed programs clearly and concisely, without thinking about the complexities of distributed systems programming.


  • Declarative API: Express distributed computations with clarity and ease.
  • Automated Distribution: Paladin’s runtime seamlessly handles task distribution and execution across the cluster.
  • Simplified Development: Concentrate on the program logic, leaving the complexities of distributed systems to Paladin.
  • Infrastructure Agnostic: Paladin is generic over its messaging backend and infrastructure provider. Bring your own infra!


Below is a (contrived) example of how a typical Paladin program looks.

async fn main() {
    let stream = IndexedStream::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
    // Compute the fibonacci number at each element in the stream.
    let fibs = stream.map(&FibAt);
    // Sum the fibonacci numbers.
    let sum = fibs.fold(&Sum);

    // Run the computation.
    let result = sum.run(&runtime).await.unwrap();
    assert_eq!(result, 143);

In this example program, we define an algorithm for computing the fibonacci number at each element in a stream, after which we sum the results. Behind the scenes, Paladin will distribute the computations across the cluster and return the result back to the main thread.


Licensed under either of

at your option.


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


~571K SLoC