Rhizome

1. Introduction

Rhizome is a general-purpose programming language, first released in 2019, whose defining innovation is the replacement of the abstract syntax tree with what its designers call the abstract syntax web. In conventional language implementations, source code is parsed into a tree structure in which each node has exactly one parent and relationships flow strictly downward from root to leaves. Rhizome’s designers considered this hierarchical, exclusionary, and — the word recurs throughout their early documentation — arboreal, a term they used with the specific contempt that only people who have read Deleuze and Guattari can bring to a data structure.

The abstract syntax web, by contrast, is a directed graph in which any node may reference any other node, including nodes that have not yet been defined, nodes in other files, and — following a controversial extension in version 0.7 — nodes that were defined in a previous compilation and may no longer exist. Parsing a Rhizome programme does not produce a hierarchy. It produces a topology. The language specification describes this topology as “a field of mutual implication,” which is the kind of phrase that is easy to write in a design document and difficult to implement in a compiler.

This paper traces the history of Rhizome from its origins in a graduate seminar at the European Graduate School in Saas-Fee to its current status as a language with approximately nine hundred active users, a schism, two incompatible compilers, and a community whose primary activity is the discussion of what programmes in Rhizome mean rather than what they do. It is, by any measure, the most theoretically sophisticated programming language ever designed. Whether it is a good programming language is a question the community considers not only unanswerable but symptomatic of a hierarchical epistemology they have spent seven years trying to escape.

2. Origins

Rhizome was created by three doctoral students — Gaspard Morel (philosophy), Yasmin Okafor (comparative literature), and Lutz Pfeiffer (computer science, though his dissertation was on the ontological implications of garbage collection) — who met in 2017 at a reading group on A Thousand Plateaus and discovered, over the course of several months, that they shared a conviction that the abstract syntax tree was not merely a technical convenience but a political commitment.

Their foundational paper, “Against Arborescence: Toward a Non-Hierarchical Syntax” (2018, self-published, forty-seven pages, nine citations as of 2026, seven of which are self-citations), argued that the tree structure imposed on programme text by conventional parsers reproduces the logics of domination that Deleuze and Guattari identified in the arborescent model of thought. In a tree, every node has exactly one parent. Authority flows downward. The root determines the meaning of the leaves. “This is not a neutral technical decision,” the paper argues. “It is the reinscription, at the level of compilation, of a monarchical epistemology in which meaning is always already determined from above.”

The alternative they proposed was the rhizome: a structure with no root, no privileged direction, and no hierarchy — a web of connections in which any node may affect the interpretation of any other. The paper devotes eleven pages to the theoretical justification, four pages to the proposed syntax, and zero pages to the question of how such a structure would be evaluated at runtime, an omission that the authors later described as deliberate (“evaluation order is itself an arborescent imposition”) and that Pfeiffer, in a 2023 interview, described more candidly as “we had not thought about it.”

3. The Language

3.1 Syntax

Rhizome’s syntax is, in its surface form, not dramatically different from other expression-oriented languages. Variables are bound with weave, functions are defined with strand, and control flow — to the extent that the concept applies — is expressed through confluence blocks, which the specification describes as “sites of multiplicity where several computational paths coexist without resolution until observed.” The resemblance to quantum superposition is, according to Morel, “not accidental but also not a metaphor.”

A simple Rhizome programme:

weave greeting = "hello"
weave subject = "world"
weave message = greeting ~ " " ~ subject

This appears conventional. The ~ operator concatenates strings. The programme binds three values. In any other language, evaluation would proceed top to bottom. In Rhizome, it does not, because top-to-bottom is arborescent. Instead, the compiler constructs a web in which the three bindings exist as mutually referencing nodes — message depends on greeting and subject, but greeting and subject are also, in the web, “implicated by” message, since their significance is partly constituted by how they are used. The specification calls this “bidirectional implication.” The compiler calls it a cycle.

The cycle problem is, in a technical sense, the central problem of Rhizome, and the community’s response to it is the central fact of Rhizome’s history.

3.2 The Evaluation Question

In a tree, evaluation order is determined by structure. You evaluate the leaves, then their parents, then the root. In a web, there is no structural basis for deciding what to evaluate first. The Rhizome specification addresses this in Section 4.7, titled “On the Question of Sequence,” which reads in its entirety:

Sequence is not a property of the web. It is a property of the machine on which the web is instantiated. The runtime is responsible for finding a traversal that respects the web’s topology without imposing an external hierarchy upon it. How it does this is an implementation concern and not a matter of language semantics.

This passage has been called, by sympathetic commentators, “an elegant separation of concerns,” and by less sympathetic ones, “an abdication dressed as a design principle.” It has the practical consequence that two compliant Rhizome implementations may evaluate the same programme in different orders and produce different results, and both are correct, because correctness in Rhizome is not defined relative to a canonical output but relative to “a traversal consistent with the web’s implicational structure,” which is a condition that admits many solutions, some of which are useful and some of which are not, and the language has no mechanism for distinguishing between them.

3.3 Mutual Implication and the Strand Problem

The difficulties compound when functions are introduced. A strand (function) in Rhizome does not “call” another strand the way a function calls another function in a conventional language. It implicates it. The distinction matters, or at least the community believes it matters, because calling implies a hierarchy (the caller is above the callee), while implication is lateral — a relationship between equals.

In practice, this means that when strand A implicates strand B, and strand B implicates strand A, the result is not a stack overflow but what the specification calls a “resonance” — an oscillation between two computations that continues until one of them produces a value that the web accepts as a “provisional stabilisation.” How the web decides which values are provisionally stable is determined by the runtime, which is an implementation concern, and therefore not specified.

Pfeiffer’s reference implementation resolves resonances by running both strands concurrently and accepting whichever returns first. This produces deterministic results on a single-core machine and nondeterministic results on a multi-core machine, a property that the specification does not address because the specification does not acknowledge that machines have cores, on the grounds that hardware topology is itself an arborescent structure and therefore outside the language’s ontological commitments.

4. The Compilers

4.1 rhizome-ref (Pfeiffer, 2019–2022)

The reference implementation, written in Haskell by Pfeiffer, was a heroic effort to make the specification’s abstractions interact with an actual CPU. The compiler’s central component is the web solver, which takes the abstract syntax web produced by the parser and attempts to find an evaluation order that respects all implicational relationships without introducing hierarchy. This is, in the general case, NP-hard, a fact that Pfeiffer established in a companion paper and that the community received with what can only be described as satisfaction, since it confirmed their conviction that hierarchical computation was a simplification of something fundamentally more complex.

In practice, rhizome-ref handles the NP-hardness by imposing a timeout. If the web solver cannot find a valid traversal within thirty seconds, it falls back to what Pfeiffer’s documentation calls “pragmatic sequencing” — a topological sort of the dependency graph that produces, in effect, the same evaluation order that an abstract syntax tree would have given in the first place. The pragmatic sequencing mode is used in approximately ninety-four percent of real-world Rhizome programmes. It is not discussed at community meetings.

4.2 tanglec (Herrera, 2022–present)

The second compiler, tanglec, was written by Sofia Herrera, a systems programmer in Buenos Aires who had no background in continental philosophy and whose interest in Rhizome was, by her own account, “purely structural.” Herrera’s approach was to treat the abstract syntax web not as a philosophical commitment but as a hypergraph and to apply standard graph-reduction techniques borrowed from the implementation of optimal lambda calculus evaluators.

tanglec is faster than rhizome-ref by approximately two orders of magnitude. It produces deterministic output. It handles resonances by detecting strongly connected components and evaluating them in an order determined by a fixed-point algorithm that, while technically not hierarchical, produces results identical to what a tree-based evaluator would produce in every case that the Rhizome test suite covers.

The release of tanglec precipitated the schism.

5. The Schism

The dispute, which consumed most of 2023 and the first quarter of 2024, concerned whether tanglec was a valid implementation of Rhizome or — as Morel argued in a series of increasingly heated forum posts — “a tree wearing a web’s clothing.” The charge was that tanglec’s fixed-point evaluation, while producing correct outputs, did so by covertly reintroducing hierarchy into the evaluation process. The web was being traversed in an order. The order was deterministic. Deterministic order implied sequence. Sequence implied hierarchy. Hierarchy was arborescent. Therefore tanglec was, in Morel’s phrase, “a betrayal of the rhizome from within.”

Herrera’s response was that the specification delegated evaluation order to the runtime, that her runtime’s order was consistent with the web’s topology, and that she was not interested in arguments about whether a fixed-point algorithm constituted a philosophical commitment. “I am a compiler engineer,” she wrote. “The programme produces the correct output. The output is what the user asked for. If the internal evaluation order offends you, I suggest you not look at it.”

The community divided into what came to be known as the Topological Faction (aligned with Herrera, interested in what programmes do) and the Ontological Faction (aligned with Morel, interested in what programmes are). The Topological Faction uses tanglec. The Ontological Faction uses rhizome-ref. The two compilers produce different outputs for approximately six percent of programmes, and the community cannot agree on which outputs are correct, because they cannot agree on what correctness means, because correctness implies a hierarchy between correct and incorrect, and the whole point was to avoid that.

6. The Standard Library

Rhizome’s standard library is small, partly by design and partly because the difficulty of writing Rhizome programmes that behave predictably has limited contributions. The most used module is web-io, which handles input and output by treating I/O operations as nodes in the web with special “grounding” properties that force evaluation — a concession to pragmatism that the specification describes as “a site of necessary compromise with the machinic substrate” and that Pfeiffer, again more candidly, described as “obviously you have to print things.”

The standard library also includes resonance-utils, a collection of helper functions for managing mutual implications, the most popular of which is dampen, which takes a resonating pair of strands and reduces them to a single value by averaging their outputs. This works for numerical types. For strings, dampen concatenates and truncates. For booleans, it returns perhaps, a third truth value added in version 0.4 that evaluates to true in some contexts and false in others, depending on the traversal order, and that has been described by the Ontological Faction as “the language’s most honest feature.”

The standard library does not include a package manager. An attempt to create one was abandoned after the design committee could not agree on whether dependencies should form a tree (unacceptable) or a web (which would mean that every package depends on every other package, a topology that is philosophically sound but computationally equivalent to downloading the internet). Packages are currently distributed as tarballs on a forum.

7. Notable Programmes

7.1 hello-web

The canonical first programme in Rhizome is hello-web, not hello-world, because the greeting is not directed at the world hierarchically but woven into it laterally. The programme is three lines long and takes between 0.01 seconds (tanglec) and up to thirty seconds (rhizome-ref, when the web solver times out) to execute.

7.2 The Loom

The most ambitious programme written in Rhizome is the Loom, a web application framework developed by a team of four over eighteen months. The Loom treats HTTP requests as nodes in a web alongside the application’s business logic, database queries, and template rendering, all mutually implicating one another. The result is a web server in which the response to a request is not computed sequentially but emerges from the stabilisation of a web that includes the request, all possible responses, the current database state, and — following a design decision the team later described as “a mistake we are committed to” — the server’s own configuration file.

The Loom handles approximately twelve requests per second on commodity hardware. The team considers this adequate. Benchmarking is, in any case, an arborescent practice — it imposes a linear metric on what is fundamentally a topological phenomenon.

7.3 The Web That Compiled Itself

In 2024, a graduate student in Zurich named Kessler wrote a Rhizome programme whose abstract syntax web contained, as a subweb, a description of the Rhizome compiler’s parsing stage. The programme, when compiled, produced as its output a modified version of its own abstract syntax web with one node changed. Kessler argued that this was the first self-modifying Rhizome programme. The Ontological Faction argued it was a proof that the web is a living structure. The Topological Faction argued it was a bug. It was not added to the test suite.

8. Current Status

As of early 2026, Rhizome has 847 open issues across its two compiler repositories, a number whose coincidence with the issue count of a certain internal JavaScript package at a company none of the Rhizome community has heard of would please no one and surprise no one. The language specification is on its fourth revision. Sections 4.7 through 4.12, which deal with evaluation semantics, remain marked “PROVISIONAL — AWAITING CONSENSUS,” a status they have held since 2019.

The Ontological Faction has proposed a fifth revision that would remove all references to evaluation order entirely, on the grounds that any mention of sequence in the specification constitutes an arborescent contamination. The Topological Faction has proposed an alternative revision that would make tanglec’s fixed-point semantics normative. Neither proposal has been adopted. The specification committee has not met since October 2025, when a meeting to discuss the proposals was adjourned after forty minutes following a disagreement about whether the agenda constituted a hierarchical ordering of topics and, if so, whether a non-hierarchical alternative was feasible. An alternative was proposed in which all agenda items would be discussed simultaneously. The experiment was attempted. Minutes were not taken, or if they were, they were taken in a non-sequential format that has not been successfully interpreted.

The community remains active. The annual RhizomeCon, held in a different city each year by a process the organisers describe as “non-electoral selection” and critics describe as “whoever volunteers,” drew approximately 120 attendees in 2025. The keynote was delivered jointly by Morel and Herrera, who do not agree on what Rhizome is but who have arrived, over seven years, at a mutual respect grounded in the shared recognition that whatever Rhizome is, it is at least not a tree.

The language continues.

Acknowledgments. The author thanks Lutz Pfeiffer and Sofia Herrera for extensive interviews, and Gaspard Morel for a conversation that began as an interview and became a lecture on the political economy of data structures which, while not directly usable as source material, was educational. Yasmin Okafor did not respond to interview requests but published a 12,000-word essay on the experience of co-creating a language whose community she no longer participates in, which the author has read with interest and cites below. The author declares no conflicts of interest, though she notes that her own work uses abstract syntax trees exclusively and she has experienced no crisis of conscience about this, which may itself constitute a bias.