String Field Theories: Conveying Information in 2 Dimensions

On spatial encoding, alien semiotics, and the computational universe of possible writing systems.

---

The Limitation of Linear Text

Human writing systems are fundamentally one-dimensional. Whether read left-to-right, right-to-left, or top-to-bottom, text unfolds as a sequence—a stream of symbols parsed in order. This linearity mirrors speech: phonemes arranged temporally, decoded one after another.

But screens are not pages. The web is an inherently two-dimensional medium. Yet digital interfaces largely replicate the sequential logic of print—paragraphs, bullet points, scrolling text. The spatial dimension of the screen remains underutilised for information encoding.

What would it mean to convey information in two dimensions? Not text arranged spatially, but symbols where spatial relationships constitute meaning—where position, proximity, and form encode semantics simultaneously rather than sequentially.

---

Wolfram and the Logograms of Arrival

The 2016 film Arrival, directed by Denis Villeneuve, presented this exact problem. The alien heptapods communicate through circular logograms—complete thoughts rendered as ink-like symbols, perceived holistically rather than read linearly.

Director Villeneuve approached Stephen Wolfram to consult on the linguistic and computational aspects of the alien language. Wolfram, creator of Mathematica, Wolfram|Alpha, and author of A New Kind of Science, brought a unique perspective: the idea that the universe of possible computational systems is vast, and human mathematics represents only a small, historically contingent sample of it.

In a 2016 interview with Space.com, Wolfram articulated this directly:

"The things we've been interested in in math are just samplings of the set of all possible mathematical facts... The particular ones that one has sampled are very dependent on the detailed history of a civilization."

This insight applies equally to writing systems. Human scripts evolved to represent speech—a fundamentally sequential medium. An alien species with different perceptual apparatus, or one that evolved visual communication before auditory, might develop writing that encodes information spatially from the outset.

Christopher Wolfram's Computational Analysis

Stephen Wolfram's son, Christopher Wolfram, was commissioned to build the actual code that appears on screen in Arrival. His task: create computational tools to analyse the fictional logogram language and generate visualisations for the film's scientists to interact with.

Christopher's approach, documented in a Wolfram U course titled "The Code Behind Arrival", treated the logograms as computational objects. Using Wolfram Language, he built tools to:

• Decompose logograms into constituent visual elements
• Analyse symmetry, density, and structural relationships
• Generate variations and interpolations between symbols
• Visualise the "grammar" of spatial arrangements

The code demonstrated that even fictional writing systems become tractable when treated computationally—as rule-governed generative systems rather than arbitrary drawings.

// Wolfram Language pseudocode (conceptual)
// Analysing logogram structure

logograms = Import["logograms/*.png"];
contours = ImageContour /@ logograms;
symmetryScores = RotationalSymmetry /@ contours;
densityMaps = ImageData[GaussianFilter[#, 5]] & /@ logograms;

// Cluster by structural similarity
clusters = FindClusters[logograms, 
  DistanceFunction -> ImageDistance,
  Method -> "KMeans"
];

---

The Computational Universe of Writing Systems

Wolfram's broader research programme—exploring the computational universe through cellular automata, Turing machines, and simple programs—provides a framework for thinking about emergent writing systems.

In A New Kind of Science, Wolfram demonstrated that extremely simple rules can generate extraordinary complexity. Rule 30, a one-dimensional cellular automaton with only three inputs and two states, produces patterns indistinguishable from randomness yet entirely deterministic. Rule 110 is proven to be Turing-complete—capable, in principle, of universal computation.

If simple rules can generate such complexity, they can also generate writing. Not writing that humans designed, but writing that emerges—symbols with internal structure, consistency, and the capacity to encode information, even if that encoding is alien to human parsing.

// Elementary Cellular Automaton (Rule 30)
// Generates complex, pseudorandom patterns from simple rules

function rule30(left, center, right) {
  const neighborhood = (left << 2) | (center << 1) | right;
  const rule = 30; // Binary: 00011110
  return (rule >> neighborhood) & 1;
}

function generateCA(width, height, seed) {
  let grid = Array(height).fill(null).map(() => Array(width).fill(0));
  
  // Seed initial row
  grid[0] = seedToRow(seed, width);
  
  // Evolve
  for (let y = 1; y < height; y++) {
    for (let x = 0; x < width; x++) {
      const left = grid[y-1][(x - 1 + width) % width];
      const center = grid[y-1][x];
      const right = grid[y-1][(x + 1) % width];
      grid[y][x] = rule30(left, center, right);
    }
  }
  
  return grid;
}

When bounded within a glyph-sized container, cellular automata produce forms that read as symbols—structured, non-random, yet unfamiliar. Different rules produce different visual families. Different seeds produce different instances within a family.

---

2D Encoding: From Sequence to Simultaneity

The fundamental shift in two-dimensional information encoding is from sequential parsing to simultaneous perception.

Property	1D (Linear Text)	2D (Spatial Glyphs)
Processing	Sequential, left-to-right	Holistic, gestalt perception
Time	Unfolds over reading duration	Entire meaning available instantly
Relationships	Adjacency (before/after)	Proximity, symmetry, containment
Density	Limited by line length	Potentially higher per symbol
Ambiguity	Resolved by context (later words)	Resolved by spatial relationships

Human vision processes images holistically before analytically. The gestalt principles—proximity, similarity, continuity, closure—describe how the visual system groups elements into perceived wholes. A 2D writing system leverages this: meaning emerges from pattern recognition rather than sequential decoding.

The Arrival logograms exemplify this. A heptapod symbol is not "read" from any starting point. It is perceived as a complete thought, with modifying elements positioned spatially relative to a core meaning.

---

Generative Approaches to Emergent Glyphs

Several algorithmic families can generate forms suitable for a 2D writing system. Each produces distinct visual qualities.

1. Cellular Automata

As demonstrated above, elementary CA generate complex patterns deterministically. The visual aesthetic is digital, crystalline—grids and edges. Wolfram's research catalogued 256 elementary rules; each produces a distinct visual signature.

// Generate glyph from CA with semantic seeding
function caGlyph(seed, rule = 30, size = 32) {
  const grid = generateCA(size, size, seed);
  
  // Convert to SVG path
  let path = '';
  for (let y = 0; y < size; y++) {
    for (let x = 0; x < size; x++) {
      if (grid[y][x] === 1) {
        path += `M${x} ${y} h1 v1 h-1 Z `;
      }
    }
  }
  
  return ``;
}

2. L-Systems (Lindenmayer Systems)

L-systems encode recursive growth—rules that rewrite strings, interpreted as drawing instructions. Originally modelling plant morphology, they produce organic, branching forms with fractal self-similarity.

// L-System with turtle graphics interpretation
const lsystemRules = {
  'F': 'FF+[+F-F-F]-[-F+F+F]',  // Tree-like branching
};

function evolve(axiom, rules, iterations) {
  let result = axiom;
  for (let i = 0; i < iterations; i++) {
    result = result.split('').map(c => rules[c] || c).join('');
  }
  return result;
}

function interpret(instructions, angle = 25) {
  const stack = [];
  let x = 0, y = 0, theta = -90;
  let path = `M ${x} ${y}`;
  
  for (const char of instructions) {
    switch (char) {
      case 'F':
        x += Math.cos(theta * Math.PI / 180) * 5;
        y += Math.sin(theta * Math.PI / 180) * 5;
        path += ` L ${x} ${y}`;
        break;
      case '+': theta += angle; break;
      case '-': theta -= angle; break;
      case '[': stack.push({ x, y, theta }); break;
      case ']':
        const state = stack.pop();
        x = state.x; y = state.y; theta = state.theta;
        path += ` M ${x} ${y}`;
        break;
    }
  }
  
  return path;
}

// Generate: interpret(evolve('F', lsystemRules, 3), 25)

L-systems offer precise control over complexity through iteration depth. Low iterations produce simple geometric forms; higher iterations yield intricate, glyph-like structures.

3. Reaction-Diffusion

Gray-Scott and Turing patterns simulate chemical diffusion, producing organic spots, stripes, and labyrinthine forms. The aesthetic is biological—coral, lichen, fingerprints.

// Gray-Scott Reaction-Diffusion (simplified)
// Requires iterative simulation—expensive but distinctive

const config = {
  feed: 0.055,    // Feed rate
  kill: 0.062,    // Kill rate
  dA: 1.0,        // Diffusion rate A
  dB: 0.5,        // Diffusion rate B
};

function stepSimulation(gridA, gridB, config) {
  const { feed, kill, dA, dB } = config;
  const newA = [], newB = [];
  
  for (let y = 0; y < height; y++) {
    newA[y] = []; newB[y] = [];
    for (let x = 0; x < width; x++) {
      const a = gridA[y][x];
      const b = gridB[y][x];
      const lapA = laplacian(gridA, x, y);
      const lapB = laplacian(gridB, x, y);
      const reaction = a * b * b;
      
      newA[y][x] = a + (dA * lapA - reaction + feed * (1 - a));
      newB[y][x] = b + (dB * lapB + reaction - (kill + feed) * b);
    }
  }
  
  return [newA, newB];
}

Reaction-diffusion is computationally expensive. For web deployment, pre-computed frames or WebGL shaders are necessary.

4. Wolfram-Inspired Hybrid Systems

Following Christopher Wolfram's approach to the Arrival logograms, a hybrid system combines multiple generative methods:

// Hybrid glyph generator inspired by Wolfram's logogram analysis
function generateHybridGlyph(seed) {
  // 1. Core structure: L-system skeleton
  const skeleton = interpret(evolve('F', treeRules, 2), 60);
  
  // 2. Texture: CA-based fill pattern
  const texture = generateCA(16, 16, seed);
  
  // 3. Boundary: Circular containment (like Arrival logograms)
  const radius = 50;
  const boundary = `M ${radius} 0 A ${radius} ${radius} 0 1 1 ${radius} 0.01 Z`;
  
  // 4. Composite: Mask skeleton with texture, contain within boundary
  return {
    skeleton,
    texture: textureToPattern(texture),
    boundary,
    composite: clipPathComposite(skeleton, texture, boundary)
  };
}

---

Semantic Encoding in 2D Space

The question of meaning: can emergent glyphs encode actual information, or are they purely decorative?

Wolfram's observation about the "computational universe" suggests a middle path. Glyphs need not be human-readable to be information-bearing. If generation is deterministic—same seed produces same glyph—then the glyph is the information, encoded visually.

Encoding Strategies

• Route-based seeding: Each page's URL seeds generation. The /about page always produces the same glyph; /projects produces another. The glyph becomes the page's visual signature.

// Deterministic route-to-glyph mapping
function glyphForRoute(pathname) {
  const hash = cyrb53(pathname);  // Fast, deterministic hash
  const seed = hash % 100000;
  const rule = 30 + (hash % 90);  // Rules 30-119
  
  return caGlyph(seed, rule, 32);
}

// cyrb53: fast string hash
function cyrb53(str, seed = 0) {
  let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
  for (let i = 0; i < str.length; i++) {
    const ch = str.charCodeAt(i);
    h1 = Math.imul(h1 ^ ch, 2654435761);
    h2 = Math.imul(h2 ^ ch, 1597334677);
  }
  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
  h2 = Math.imul(h2 ^ (h2 >>> 13), 3266489909);
  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
}

• Content hashing: Hash the page's title or primary content. Content changes produce glyph changes—a visual diff.
• Temporal encoding: Incorporate publication timestamps. Blog posts from the same month share visual characteristics while remaining distinct.
• Categorical encoding: Different generative rules for different content types. L-systems for organic/creative content; CA for technical/structured content.

The result: visitors cannot "read" the glyphs, but consistent rules ensure internal logic. Patterns emerge across pages. The writing system is alien but not arbitrary.

---

Application Across a Visual System

Where might emergent glyphs appear within a website's visual identity?

Location	Behaviour	Encoding
Page headers	Static, route-seeded	Unique identity per page
Section dividers	Interpolate between adjacent glyphs	Transitional meaning
Loading states	Animate generation process	Meaning emerging in real-time
Background	Tiled CA patterns, slowly evolving	Ambient complexity
Navigation	Glyphs as route indicators	Functional wayfinding
Error states	Fragmented or corrupted glyphs	Semantic breakdown
Favicon	Simplified site glyph	Brand mark

---

Performance and Implementation

Generative systems risk blocking the main thread. Mitigation strategies:

• Build-time generation: Pre-compute glyphs for known routes during static site generation. Store as SVG in a manifest.
• Web Workers: Offload runtime generation to background threads.
• WebGL: GPU-accelerate complex patterns (reaction-diffusion, high-iteration CA).
• Memoization: Cache generated glyphs by seed. Same input = same output, no recomputation.
• Progressive rendering: Display low-complexity glyph immediately; refine asynchronously.

// Build-time glyph generation (Next.js example)
// scripts/generate-glyphs.ts

import { writeFileSync } from 'fs';
import { getAllRoutes } from '../lib/routes';
import { glyphForRoute } from '../lib/glyph-generator';

const routes = getAllRoutes();
const manifest = {};

for (const route of routes) {
  manifest[route] = glyphForRoute(route);
}

writeFileSync(
  './public/glyphs/manifest.json',
  JSON.stringify(manifest, null, 2)
);

// Runtime: import manifest, lookup by route
// No generation cost at runtime for known routes

---

The Tension: Mystery vs. Accessibility

Glyphs that "mean something" but cannot be read present design tensions:

• Screen readers: Glyphs should be aria-hidden unless replacing functional elements. Meaning exists visually, not semantically.
• Cognitive load: Too many glyphs, or glyphs in critical paths, may confuse rather than intrigue.
• Motion: Evolving glyphs must respect prefers-reduced-motion.

The goal is ambient mystery—glyphs exist in peripheral vision, reward attention, but do not gate navigation or comprehension.

---

Open Questions

Several design questions remain unresolved:

• Visual family: Should all glyphs share a generator (same algorithm, different seeds) or vary by context?
• Temporal evolution: Should glyphs be immutable, or subtly shift across visits, seasons, or content updates?
• User participation: Could visitors generate their own glyphs—input that produces a personal symbol?
• Decipherability: Should dedicated visitors be able to decode the system? An easter egg key?
• Cross-reference: If two pages share semantic content, should their glyphs share visual elements?

These questions echo Wolfram's observation about interestingness being context-dependent. What makes a glyph system compelling depends on the site's purpose and audience.

---

Conclusion: Writing Systems as Emergence

Human writing evolved to transcribe speech—a solution to a specific problem in a specific context. The computational universe contains countless alternative solutions: writing systems that encode meaning spatially, holistically, or through emergent structural relationships.

Wolfram's work—both Stephen's theoretical framework and Christopher's applied code for Arrival—demonstrates that alien writing is not mysticism but computation. Given rules, a generative system produces symbols with internal logic. Whether that logic is human-readable is a separate question from whether it is meaningful.

For a website built around emergence and complex systems, an emergent writing system is not decoration. It is demonstration: structure arising from simple rules, meaning encoded in two dimensions, the computational universe made visible.

---

Technical Stack (Proposed)

• Generator: TypeScript library, framework-agnostic
• Algorithms: Cellular automata (Wolfram rules), L-systems, hybrid approaches
• Rendering: SVG for static glyphs, Canvas/WebGL for animation
• Build-time: Pre-generate via build script, output manifest
• Runtime: Web Worker + memoization for dynamic routes

References

• Wolfram, S. (2016). "Arrival, AI and Alien Math: Q&A with Stephen Wolfram". Space.com.
• Wolfram, C. (2016). "The Code Behind Arrival". Wolfram U.
• Wolfram, S. (2002). A New Kind of Science. Wolfram Media.