Moe Louanjli, Mute Syntax, Single-screen interactive poem (HTML/CSS/JavaScript, p5.js), computer, monitor and mouse, dimensions variable, 2025
First published in Kontradiktion (Finland) as: Louanjli, M. (2025, September). Mute Syntax [Digital poem]. Kontradiktion. https://kontradiktion.fi/2025/09/mute-syntax/

Forget to erase. Regenerate to speak. Drift to fall silent. Drift again to return.

Mute Syntax is not one poem but a generative system: an algorithmic engine designed to produce an open-ended array of micro-poems from recombined fragments. It is built in p5.js, styled after the 1984 Macintosh OS, and structured around the poetics of logic, glitch, and interface. Rather than authoring fixed lines, I wrote a process. Each poem consists of four lines, following a strict template:

[subject] [verb] [metaphor].

The vocabulary is drawn from three curated arrays:
- Subjects: abstract or digital figures (“The cracked zero”, “A digit behind glass”, “The forgotten operand”)
- Verbs: gestures of failure or transformation (“detunes with”, “loops back to”, “drowns beneath”)
- Metaphors: textural or ambiguous imagery (“a vowel buried in numbers”, “the lull between two equations”, “a pause no voice owns”)

The current pool contains 89 elements in total (30 subjects, 30 verbs, 29 metaphors). The generator randomly selects one element from each array per line. No filtering, memory, or semantic checking occurs. Redundancy and awkwardness are not errors but material: texture through repetition and failure.

There is no visible serial number and poems are not saved. The system does not store a per-poem identifier. A temporal counter (frameCount) exists at runtime and is used to time Drift regeneration, but it is not recorded with each generated poem. In this sense, the work privileges occurrence over archive. As with Alan Sutcliffe’s Spasmo (often styled SPASMO), where a modified base-four serial logic identifies each output, the emphasis here is not preservation but situational uniqueness: a poem occurs, then vanishes.

INTERFACE AS POETIC FORM
The graphical interface is intentionally anachronistic, mimicking the early Macintosh GUI. Each element plays a poetic and functional role:

- Forget: clears the poem, simulating memory erasure.
- Regenerate: composes a new poem from the system.
- Drift: enters a quiet, ambient state where new poems generate periodically without user input. Drift again, or a click, returns to manual reading.

These are not just buttons. They are conceptual gestures. The GUI is reimagined as a poetic apparatus, where interaction becomes a mode of reading and writing. It is designed for desktop viewing, in keeping with the work’s retro-informatic logic.

TIME AND RANDOMNESS
Randomness here is pseudo-random rather than mystical. The system uses p5.js random() to select fragments. Unless a fixed seed is explicitly set (for example with randomSeed()), outputs vary from run to run and cannot be reliably reproduced across sessions. Poems are ephemeral and cannot be recovered unless manually copied.

In Drift mode, the current version regenerates a poem after roughly 240 frames. At the default frame rate this is about 4 seconds, although exact timing depends on performance and any explicit frameRate settings. Drift shifts the reader’s role from agent to observer. Silence, slowness, and memory become structural principles.

CONCEPTUAL FRAMEWORK
The system privileges iteration over authorship, structure over story, interface over inscription. It explores how a number might be reframed as a voice, how syntax might glitch into metaphor, how logic might produce affect.

As a digital poem, Mute Syntax resonates with the lineage of algorithmic writing discussed in White Heat Cold Logic: British Computer Art 1960–1980 (MIT Press, 2008). In particular, Alan Sutcliffe’s reflections in “Patterns in Context” inform this work’s attention to structure over outcome, and to the shaping of conditions under which meaning may appear momentarily before vanishing. In Mute Syntax, a number is not just data. It is anomaly, rhythm, residue. A glitch becomes a form of saying.

MUTE SYNTAX: SYSTEM OVERVIEW

PROJECT SUMMARY
Mute Syntax is a browser-based, generative poetry system built with p5.js. It uses procedural composition to construct four-line micro-poems from a controlled vocabulary, operating within a constrained grammatical structure. The piece is framed in a UI styled after the 1984 Macintosh interface to emphasise the computer as both medium and metaphor.

The project treats the interface not just as a means of delivery, but as a poetic apparatus itself. Menu elements such as “Forget”, “Regenerate”, and “Drift” function both as technical triggers and as conceptual gestures, invoking memory, recursion, and ambient silence.

1. POEM GENERATION LOGIC
Each poem consists of 4 lines, and each line is composed using the template:
[subject] [verb] [metaphor].

These components are pulled from three arrays:
- subjects[] (30 entries)
- verbs[] (30 entries)
- metaphors[] (29 entries)

The generator randomly selects one element from each array for each line. There is no filtering, no grammar checking, and no memory of past outputs. This ensures that:

- Redundancy is possible
- Results are occasionally awkward, surreal, or surprising
- No line is ever “correct”, only structurally valid

Complexity space:
- Each line has 26,100 combinations (30 × 30 × 29).
- Each 4-line poem has 463,856,010,000,000,000 combinations (26,100^4 = 4.6385601 × 10^17).

That is approximately 464 quadrillion possible poems. Put simply: the chance of generating the exact same poem twice by accident is extremely low.

The main function generatePoem() constructs the four lines by sampling the arrays using random() from p5.js. Each time it is called, it redraws the poem on the canvas.

2. RANDOMNESS AND STATE
- Poem generation is triggered either by mouse clicks on GUI elements or, in Drift mode, by a frame-based timer.
- The system uses p5.js random(). Unless a fixed seed is set, output varies across runs and is effectively non-repeatable across sessions.
- There is no internal state tracking or saving. Poems are ephemeral and unrepeatable unless copied by the user.
- frameCount is the primary temporal counter at runtime. In the current version, it times Drift regeneration rather than being stored as a per-poem timestamp.

3. UI AS POETIC INTERFACE
The interface mimics a minimal desktop GUI with hard-coded bounding boxes over drawn menu items. User interaction is managed by manually checking mouseX and mouseY inside mousePressed().

Interface elements perform poetic roles:
- Forget clears the poem.
- Regenerate composes a new poem instantly.
- Drift toggles an ambient mode in which generatePoem() is automatically triggered after roughly 240 frames (about 4 seconds at the default frame rate).
- An “i” control (and the I key) opens an information panel that overlays the work, framing the system as the poem.

The GUI is not passive. It is styled to behave as a conceptual constraint: an intentional friction that shapes interaction and reflection.

4. DESIGN INTENT
The interface is both poetic and functional:
- Menu labels are semantic gestures: Forget as memory erasure, Regenerate as recomposition, Drift as ambient silence.
- The system evokes not only the aesthetics of early computers but their conceptual grammar: structured input, output, and failure.
- No poem is saved. Transience is part of the work’s claim.

5. CODE PHILOSOPHY
The system reflects a few guiding principles:
- Structuralism over storytelling: meaning arises from recombination, not authorial control.
- Poetic ambiguity by design: lines are allowed to misfire, loop, or contradict.
- Interface as aesthetic form: the GUI is part of the poem.
- Silence and slowness: Drift introduces time as a structural constraint.
The design invites the reader to treat computation not as a neutral tool but as expressive material.

TECHNOLOGIES
- Framework: p5.js
- Deployment: browser-based (for example, GitHub Pages if hosted there)
- Interface: custom HTML/CSS with a canvas
- User interaction: GUI labels implemented as coordinate-based click zones
- Randomness: p5.js random()
- Aesthetics: monospace system font, low-resolution GUI palette

LICENSING AND ATTRIBUTION
Mute Syntax (c) 2025 Mohamed Louanjli
Released under the MIT Licence (see repository for details).

AI: No poems are generated by AI at runtime. AI-assisted writing tools were used during development to iterate the system description and to refine the project’s conceptual framing. The generator’s vocabulary arrays were curated by the artist.

REFERENCE
Brown, Paul, Charlie Gere, Nicholas Lambert, and Catherine Mason, eds. White Heat Cold Logic: British Computer Art 1960–1980. Cambridge, MA: MIT Press, 2008. (Sutcliffe chapter: “Patterns in Context”.)