Bismuth brings together several research strands of the Software Technology Group at TU Darmstadt – distributed reactive programming, replicated data types and protocols, and trust without a central authority. It contains the Scala implementations alongside the papers that formalize them, often with mechanizations in Lean. Bismuth is the successor of REScala.
Consensus protocols built from replicated data types that monotonically accumulate knowledge until agreement is reached. Algebraic composition of RDTs yields composable protocol building blocks, whose safety is verified automatically.
An overview of how the research strands combine into one programming model for decentralized software: algebraic replicated data types with authentication and confidentiality, reactive function calls that turn them into convergent distributed dataflows, and automated reasoning that detects where coordination is required. Developers reason locally, while the runtime ensures convergence to a consistent global state.
Access control for replicated data types without a central authority: fine-grained permissions follow the tree structure of ARDTs, and are first-class capabilities that can be delegated and revoked at runtime. The authorization state is itself replicated as a tamper-evident hash DAG, and every replica enforces policies locally when exchanging deltas – guaranteeing confidentiality, integrity, and availability even in the presence of Byzantine replicas.
Reactive programming for local-first applications: developers state safety invariants, and LoRe verifies which concurrent interactions may violate them – selectively using coordination only where required.
Local-first applications must preserve the privacy and integrity of user data even when synchronizing via untrusted intermediaries. Because ARDTs are coordination-free and state-based, replicas can encrypt and authenticate their (delta) states end-to-end using a shared secret – intermediaries store and forward data they cannot read or forge.
Instead of a fixed catalogue of CRDTs, developers use the algebraic data types they already write for their business logic: every ARDT is a join-semilattice, and merge semantics of products and sums are derived automatically from their components. ARDTs are the shared foundation of several research threads in Bismuth – LoRe, PRDTs, secure replication, and access control all build on them, and the library keeps evolving with them. documentation ↗
Automating fault tolerance for distributed, interactive applications – similar to how a garbage collector automates memory management. Thread-safe transactional propagation, snapshots and restoration of reactive state, and state-based CRDTs for replicated reactives combine into a single programming paradigm with high-level consistency guarantees, also applied to disruption-tolerant networks and Wi-Fi firmware.
REScala started as an extension of EScala (C#-style events in Scala) to bring the semantic benefits of functional reactive programming, inspired by projects such as FlapJax, into object-oriented code that undergraduate students can use and understand. Its API has stayed largely the same since 2014. Within the PACE ERC project, REScala was soon explored for distributed systems, leading to SID-UP – an update algorithm for distributed dataflow graphs without global coordination. rescala-lang.com ↗
Bismuth is developed at the Software Technology Group of TU Darmstadt. We offer theses and other opportunities, and anyone is welcome to join our matrix channel.
