CloudMicroHaskell: Direct-Style Distributed Haskell via Runtime Graph Serialisation

Jul 16, 2026

CloudMicroHaskell presents a new Cloud Haskell-style approach to distributed programming in Haskell by using MicroHaskell with a runtime that represents both code and data as a combinator graph. When a processor message crosses a node boundary, it serializes the reachable graph directly. This enables remote spawning in direct style, allowing process bodies to capture surrounding variables and transmit ordinary values, including functions, without manual closure conversion.

LanguageEnglish

CategoryTechnology

FormatPDF

Pages31

Reading Time1 h 18 min

Introduction

Cloud Haskell and direct-style limitations

Static values and closure conversion

CloudMicroHaskell design: runtime graph serialization

arXiv :2607 . 10443v1 [ cs .DC] 11 Jul 2026 CloudMicroHaskell Direct-Style Distributed Haskell via Runtime Graph Serialisation ROBERT KROOK, Chalmers University of Technology and University of Gothenburg, Sweden LENNART AUGUSTSSON, Unaffiliated, Sweden Cloud Haskell brings Erlang-style distributed programming to Haskell, but its treatment of mobile code exposes a difficult boundary in the source-level API. Remote processes must be expressed as static closures, messages must satisfy serialisation constraints, and participating nodes are assumed to share the relevant code. This paper explores a different design point. We present CloudMicroHaskell, a Cloud Haskell-style library built on MicroHaskell, whose runtime represents both code and data as a combinator graph. When a processor message crosses a node boundary, CloudMicroHaskell serialises the reachable graph directly. As a result, remote spawning can be written in direct style: process bodies may capture variables from their surrounding scope, and messages may contain ordinary values, including functions, without programmer-written closure conversion. We describe the implementation of the CloudMicroHaskell node runtime, including remote spawn, message delivery, monitors, exit propagation, and library implementations of generic servers and supervisors. We evaluate the system with process/message benchmarks, a distributed work-pool benchmark, a file-synchronisation case study, and a heterogeneous deployment on microcontrollers. The results show that runtime graph serialisation makes the Cloud Haskell programming model substantially more direct, while also making the tradeoff explicit: some guarantees enforced by Cloud Haskell’s source-level types become dynamic checks, and programmers must be aware of laziness and runtime-owned resources when moving graphs between nodes. CCS Concepts: • Networks → Programming interfaces; Network properties; • Computer systems organization → Embedded software; Dependable and fault-tolerant systems and networks; • Theory of computation → Self-organization; Concurrent algorithms. Additional Key Words and Phrases: Haskell, Distributed Haskell, Actor Model Concurrency, Concurrency, MicroHaskell, MicroHs, Serialisation, Graph Reduction, Combinators, Code Mobility ACM Reference Format: Robert Krook and Lennart Augustsson. 2026. CloudMicroHaskell: Direct-Style Distributed Haskell via Runtime Graph Serialisation. In Proceedings of the 19th ACM SIGPLAN International Haskell Symposium (Haskell ’26), August 24–29, 2026, Indianapolis, IN, USA. ACM, New York, NY, USA, 31 pages. [https://doi.org/10.1145/3830439](https://doi.org/10.1145/3830439) . 3831272 1 Introduction Cloud Haskell [4] is a Haskell framework for writing distributed, concurrent programs in the style of Erlang. Erlang’s programming model emphasises concurrency, with lightweight processes that share no memory. Instead, inter-process communication is done via message passing. This Authors’ Contact Information: Robert Krook, Chalmers University of Technology and University of Gothenburg, Department of Computer Science and Engineering, Gothenburg, Sweden, [krookr@chalmers.se](krookr@chalmers.se); Lennart Augustsson, Unaffiliated, Gothenburg, Sweden, [lennart@augustsson.net](lennart@augustsson.net). This work is licensed under a Creative Commons Attribution 4 .0 International License. Haskell ’26, Indianapolis, IN, USA © 2026 Copyright held by the owner/author(s) . ACM ISBN 979-8-4007-2869-3/2026/08 [https://doi.org/10.1145/3830439.3831272](https://doi.org/10.1145/3830439.3831272) , Vol. 1, No. 1, Article . Publication date: July 2026 . programming model greatly aids in writing distributed programs that execute on and communicate over a network. The primary benefit of Cloud Haskell over Erlang is Haskell’s strong type system. With it, the API of Cloud Haskell can be described in a very clear and expressive way. It is short and (mostly) elegant. Furthermore,

FAQs

What limitation of Cloud Haskell is addressed by CloudMicroHaskell?

Cloud Haskell requires remote processes to be expressed as static closures and transmitted messages to satisfy serialization constraints, assuming nodes share relevant code. This complicates a source-level direct-style API for mobile code.

How does CloudMicroHaskell enable remote spawning in direct style?

CloudMicroHaskell’s runtime represents code and data as a combinator graph and serializes the reachable graph when messages cross node boundaries. As a result, process bodies can capture variables from their surrounding scope without programmer-written closure conversion.

What tradeoff does the runtime graph serialization introduce?

Some guarantees enforced by Cloud Haskell’s source-level types become dynamic checks. Programmers must also account for laziness and resources owned by the runtime when moving graphs between nodes.

Jul 16, 2026

Upload by Theodore