Encoded Walker, Part 2: Encoding Information in Curves

2026-02-28

In Part 1, we established the encoded walker as a generative system. Now we turn to its potential as a communication medium. How might these radial forms encode information? And could software reliably decode messages from the resulting curves?

The Circle as Alphabet

The radial arrangement from 0 to 2π provides a natural foundation for encoding. Just as a clock face divides the circle into 12 hours, we can divide our circle into segments, each representing a symbol.

The radial form provides natural segmentation

Consider dividing the circle into 26 segments for the Latin alphabet:

segmentAngle = TWO_PI / 26
letterIndex = floor(angle / segmentAngle)

A point at angle 0 represents 'A'. A point at π/13 represents 'B'. And so on around the circle. The starting position of each radial arm encodes a letter.

Lessons from Morse

Morse code teaches us that effective encoding doesn't require complex symbols. Samuel Morse's system uses just two symbols (dots and dashes) combined with silence to represent the entire alphabet. The key insight is that timing and pattern matter more than symbol complexity.

We might adapt this principle:

  • Short radial arm: dot
  • Long radial arm: dash
  • Gap between arms: letter boundary
  • Large gap: word boundary

A message like "HI" (.... ..) could be encoded as four short arms clustered together, a gap, then two short arms.

Radial Morse Encoding

In the walker system, we control:

  • Starting angle (0 to 2π)
  • Number of generation steps (affects arm length)
  • Severity (affects arm character)
  • Spacing between arms

Here's a conceptual encoding scheme:

function encodeMorse(message) {
    arms = []
    angle = 0

    for (char in message) {
        morseCode = getMorseCode(char)
        for (symbol in morseCode) {
            arm = {
                startAngle: angle,
                steps: symbol == '.' ? SHORT_STEPS : LONG_STEPS,
                severity: BASE_SEVERITY
            }
            arms.push(arm)
            angle += SYMBOL_GAP
        }
        angle += LETTER_GAP
    }

    return arms
}

The resulting image would be readable by anyone who understands the encoding, yet appear as abstract art to others.

Beyond Binary: Positional Encoding

Morse is binary (dot/dash), but we have continuous parameters. Consider a richer encoding:

Angular position encodes category:

  • 0 to π/4: Vowels
  • π/4 to π/2: Common consonants (T, N, S, R, L)
  • π/2 to 3π/4: Less common consonants
  • etc.

Step count encodes specific letter within category:

  • Fewer steps: Earlier letters in category
  • More steps: Later letters

Severity encodes emphasis or punctuation:

  • Low severity: Normal text
  • High severity: Emphasis (like italics or caps)

This creates a multi-dimensional encoding where the visual characteristics of each arm carry semantic meaning.

The SVG as Message Container

The walker system already embeds metadata in SVG output. This provides an explicit channel for encoding:

<metadata>
  <encodedWalker>
    <seed>58043</seed>
    <message encoding="radial-morse">HELLO WORLD</message>
    <alphabet>latin-26</alphabet>
  </encodedWalker>
</metadata>

But the true challenge is encoding that survives format conversion. If someone prints the image, photographs it, and crops it, can the message still be recovered?

Decoding from Visual Analysis

A robust decoder would need to:

  1. Find the center: Detect the point from which arms radiate
  2. Identify arms: Segment individual curves from the composite image
  3. Measure angles: Determine starting angle for each arm
  4. Measure lengths: Distinguish short from long arms
  5. Parse structure: Group arms into letters and words

This is essentially a computer vision problem. The SVG format simplifies it dramatically because path data is explicit:

function decodeFromSVG(svg) {
    paths = extractPaths(svg)
    arms = []

    for (path in paths) {
        startPoint = path.points[0]
        endPoint = path.points[path.points.length - 1]

        // Calculate starting angle from center
        angle = atan2(startPoint.y - centerY, startPoint.x - centerX)

        // Measure arm length (path distance)
        length = calculatePathLength(path)

        arms.push({ angle, length })
    }

    // Sort by angle
    arms.sort((a, b) => a.angle - b.angle)

    // Decode based on scheme
    return decodeArms(arms)
}

Steganography Considerations

The encoded walker system could serve steganographic purposes, hiding messages in plain sight within artwork. The aesthetic appearance is primary; the encoding is invisible to casual observers.

Walker forms can hide information in plain sight

Considerations for robust steganographic use:

  • Redundancy: Encode each letter multiple times to survive noise
  • Error correction: Apply coding theory (Hamming, Reed-Solomon) to arm patterns
  • Normalization: Standardize image before decoding to handle rotation/scaling
  • Watermarking: Embed subtle identifying features that verify authenticity

Future Directions

Several paths forward seem promising:

Generative Decoder

Train a neural network to map walker images back to messages. The network learns to see what humans might miss in the noise patterns.

Interactive Encoder

Build a tool where users type messages and see the resulting walker form in real-time. Adjust parameters to balance aesthetics with encoding clarity.

Physical Media

Explore printing walker forms on paper, fabric, or other media. The physical artifact carries the message; scanning and decoding reveals it.

Protocol Definition

Formalize the encoding scheme as a specification. Define standard alphabets, timing relationships, and error correction. Create reference implementations.

Collaborative Art

Create pieces where multiple contributors encode segments. The assembled work contains a collective message, readable only when viewed as a whole.

The Aesthetics of Information

What makes the encoded walker interesting isn't the technical capability. We have far more efficient ways to transmit data. It's the merger of aesthetic expression with information content.

Aesthetic form carrying potential meaning

Every encoded walker image is simultaneously:

  • A generative artwork following mathematical rules
  • A container for human-readable message
  • A demonstration of deterministic emergence from simple parameters

The curve that pleases the eye also carries meaning. The randomness that creates visual interest also obscures the message from casual observation. Form and function unite in a single artifact.

Conclusion

The encoded walker system points toward a future where generative art serves double duty. As we develop tools to generate and decode these forms, we create new possibilities for visual communication: messages that are beautiful first and informative second.

The code is already in place: starting angles encode position, curve lengths encode values, parameters encode metadata. What remains is to formalize the language and build the tools to speak it.

← Back to Blog