PTL-3 Interpreter

Live compiler, demodulator, and training harness — run directly in your browser

PTL-3 Reference

Photic Token Language — complete guide to reading, writing, compiling, and communicating in PTL-3

What Is PTL-3?

PTL-3 is a deterministic visual encoding system that compiles any text, code, or mixed-language input into a single hard-edged spatial matrix. The entire document — a sentence, a book chapter, or a codebase — becomes one geometric image that the visual cortex can parse in a single 150ms glance.

The bottleneck in human communication is not the eye. The retina transmits ~10 Mbps into V1. The bottleneck is the sequential phonological loop (inner speech: ~150 WPM). PTL-3 routes around it by encoding semantic structure spatially rather than serially.

For language models, the compute advantage is structural: transformer attention scales as O(n²). A 1,000-word document has ~750 text tokens. As PTL elements (~30 sentences), it has ~30 elements. Attention FLOPs ratio: ~625×.

The Spatial Frame

The frame is a square canvas divided by a crosshair into four semantic quadrants. Four concentric depth rings radiate from the center. Every sentence compiles to a geometric primitive placed at a specific (quadrant, ring) coordinate.

            [12:00 / 0°]
   SOMATIC  │  TECHNICAL
   (NW,315°)│ (NE, 45°)
  [270°] ───┼─── [90°]
  RELATIONAL│   MACRO
  (SW,225°) │  (SE,135°)
            [180°]

• Crosshair — Black. Structural anchor for peripheral pattern recognition.
• Rings — Light gray dotted. Four concentric circles R1 (small) → R4 (large).
• Elements — Colored geometric primitives at (quadrant × ring) positions.

Quadrant System

Whiteboard equivalents: Blue (Technical) · Green (Somatic) · Red (Relational) · Black (Macro)

Classification Keywords

Technical (NE)

Somatic (NW)

Relational (SW)

Macro (SE)

Single-Word Routing

Words matching no domain vocabulary fall to a sentiment-aware default: strongly valenced tokens (|score| > 0.3) → RELATIONAL. Neutral tokens → TECHNICAL.

Examples: mad → RELATIONAL R2 · ugly → SOMATIC R2 · fire → TECHNICAL R1

Ring System

Rings encode the semantic role of a sentence within its domain.

Assignment scans R2 → R3 → R4, then defaults to R1 if no trigger keyword is found.

Geometry Vocabulary

Each (quadrant × ring) combination maps to a distinct geometric primitive.

Visual Semantics

• node / baseline / square — simple, foundational, stable presence
• waveform / cross / block — tension, conflict, interruption, disruption
• ray / smooth curve / target — direction, resolution, goal-seeking, forward motion
• progress / anchor / gold core — completion, stability, achievement, capstone value

Emotional Encoding

Three independent channels encode emotion without conflating them.

Channel 1 — Background Field (Global Valence)

The canvas background shifts continuously: warm amber (strongly positive) → neutral dark (flat) → cold blue (negative). Visible before reading any element — the document's emotional tone arrives first.

Channel 2 — Per-Element Color (Sentence Valence)

Each element receives a ±18° hue shift and ±15% saturation change. Quadrant color identity is preserved; emotion is a secondary overlay on top of domain color.

Channel 3 — Crosshair Weight (Global Arousal)

Line weight scales as 0.6 + arousal × 1.4. High-urgency documents have heavier crosshairs.

Sentiment Engine

src/lib/sentiment.js uses AFINN-111 (~600 English words) with a pluggable registry. Any language can be registered at runtime:

import { sentimentRegistry } from './sentiment.js';
sentimentRegistry.register('fr', new Map([['bien', 2], ['mal', -2]]));
sentimentRegistry.register('zh', chineseScores);

• Unknown tokens → score 0 (neutral)
• Negation handling: "not good" → flip sign
• Intensifier amplification: "very good" → ×1.45
• Algorithm: O(n) per sentence

Input Detection and Code Mode

Code Mode Domain Vocabulary

File Naming and Extensions

PTL documents use a naming convention that encodes content type and language. Extensions compose left-to-right; later extensions narrow earlier ones.

name.type              → simplest form
name.type.lang         → typed document with language
name.lang              → untyped document with language
name.type.sequence     → numbered collection member

Examples

Extension Dictionary — Programming Languages

Extension Dictionary — Natural Languages

Extension Dictionary — Document Types

Compact Text Format

The canonical human-readable, LLM-parseable representation of a PTL-3 frame.

PTL3:3.0 [document-name.extension]
  QUAD.RING.GEOMETRY    SYMBOL  "sentence text"    VALENCE
  ---
  gv:GLOBAL_VALENCE ga:GLOBAL_AROUSAL

Field Reference

Example — Incident Report

PTL3:3.0 [incident-report.english]
  TECH.2.waveform   ∿  "API server went down at 3am"                  -0.80
  RELA.3.smooth     ⌇  "On-call engineer restarted within 20 minutes" +0.40
  TECH.2.waveform   ∿  "Root cause: memory leak in connection pool"   -0.55
  TECH.3.ray        →  "Fix deployed and monitoring active"            +0.60
---
gv:-0.088 ga:0.040

Example — Personal Journal

PTL3:3.0 [daily.diary.english]
  SOMA.2.dash       —  "Feeling really tired today"                          -0.60
  RELA.2.cross      ✕  "Long argument with coworker about project direction"  -0.65
  RELA.3.smooth     ⌇  "Found a compromise together"                         +0.40
  TECH.3.ray        →  "New approach is actually better"                     +0.60
  RELA.4.anchor     ⊣  "Grateful for the team"                              +0.90
---
gv:+0.130 ga:0.040

Example — Python Chess Program (Code Mode)

PTL3:3.0 [chess.py]
  TECH.1.node     ●  "Chess game foundation with board state"  +0.00
  RELA.1.baseline ─  "Player vs player turn management"        +0.10
  TECH.3.ray      →  "Move validation and check detection"     +0.20
  MACR.4.goldcore ⊛  "Complete exportable Python chess engine" +0.80
---
gv:+0.275 ga:0.000

JSON Export Format

Exported as .ptl3.json. Designed for sharing, model training, and archiving.

{
  "ptl_version": "3.0",
  "name": "chess",
  "fullName": "chess.py",
  "domain": "code",
  "lang": "python",
  "sequence": null,
  "parent": null,
  "timestamp": 1748563200000,
  "source": "original text — strip this field for training exports",
  "frame": {
    "codeMode": true,
    "global_valence": 0.275,
    "global_arousal": 0.0,
    "elements": [
      {
        "id": 0,
        "sentence": "Chess game foundation with board state",
        "quadrant": "TECHNICAL",
        "ring": 1,
        "geometry": "node",
        "angle": 45.0,
        "x_norm": 0.1178,
        "y_norm": -0.1178,
        "valence": 0.0,
        "arousal": 0.0
      }
    ]
  },
  "schema": {
    "element_count": 4,
    "quadrant_counts": { "TECHNICAL": 2, "RELATIONAL": 1, "MACRO": 1 },
    "ring_counts": { "R1": 2, "R3": 1, "R4": 1 }
  }
}

Training Tensor Encoding

Each element encodes to a 32-dimensional Float32 vector (SIMD-aligned). toTensor(doc) returns a flat Float32Array of length n_elements × 32.

dims  0–3   quadrant one-hot    [TECHNICAL, SOMATIC, RELATIONAL, MACRO]
dims  4–7   ring one-hot        [R1, R2, R3, R4]
dims  8–9   spatial position    [x_norm, y_norm]  (range −1.0 to 1.0)
dims 10–11  angle               [sin(θ), cos(θ)]  (avoids 0°/360° discontinuity)
dims 12–15  geometry group      one-hot over 4 shape families
dims 16–17  emotion             [valence, arousal]
dims 18–21  token grammar       mean-pooled [NOUN, VERB, ADJ, OTHER]
dims 22–23  token texture       [oklab_hue_norm, spatial_texture_norm]
dim  24     token count         log1p(n) / log(100)
dim  25     mean seq phase      mean temporal_phase_offset / 15
dims 26–31  reserved            zeros (future use)

• q_oh×4 — one-hot quadrant: [TECH, SOMA, RELA, MACR]
• ring_oh×4 — one-hot ring: [R1, R2, R3, R4]
• x_norm, y_norm — spatial position (−1.0 to 1.0)
• sin(θ), cos(θ) — angle encoding (no 0°/360° discontinuity)
• geom_group×4 — one-hot geometry family (node/arc/baseline/square families)
• valence, arousal — emotional channels
• gram_oh×4 — mean-pooled PTL-1 token grammar roles (NOUN/VERB/ADJ/OTHER)
• hue_norm, tex_norm — token-level color hue and spatial texture
• log_token_count — compressed token count: log1p(n) / log(100)
• mean_phase — mean sequence phase offset from PTL-1 tokens

Demodulation

Demodulation reconstructs meaning from a PTL-3 frame.

1. Topic — infer from quadrant distribution (dominant quadrant = main domain)
2. Narrative arc — read ring progression R1→R4 (foundation → outcome)
3. Emotional tone — global valence + arousal; per-element valence for nuance
4. Specific facts — from stored element sentences (if present)
5. Inference mode — if no sentences stored (training export), infer from quadrant+ring+geometry

Code Scaffold Generation

For code-mode frames, demodulateToCode(frame) generates a scaffold:

chess.py:
  TECH.1.node     → function chessPiece() { // TODO }
  TECH.3.ray      → function moveKnight(board) { return transform(board); }
  RELA.1.baseline → import { chessBoard } from './chessBoard'
  MACR.4.goldcore → export default { version: '1.0.0' }

Pass the scaffold + PTL description to an LLM to complete the implementation.

Image Export — Standard PTL-3 PNG

Click ⬡ Image in the Compiler or Demodulator to open the export dialog. Choose Full or Basic, then export. Both produce a 1200×1200 px PNG — a universal 1:1 square that fits every major platform without cropping.

Export Modes

Standard Dimensions

Layout

┌──────────────────────────── 1200 px ────────────────────────────┐
│                         40 px top pad                           │
│  60 px  ┌───────────────────────────────────────┐  60 px       │
│         │                                       │              │
│         │         PTL-3 SPATIAL FRAME           │              │
│         │            1080 × 1080                │              │
│         │   (crosshair, rings, elements,         │              │
│         │    quadrant labels, ring labels,       │              │
│         │    frame type badge)                   │              │
│         │                                       │              │
│         └───────────────────────────────────────┘              │
│                       ≈ 80 px metadata strip                    │
│              [document name]                                    │
│    PTL-3  ·  N elements  ·  v:±X.XX  ·  TEXT/CODE              │
└─────────────────────────────────────────────────────────────────┘

Platform Compatibility

How to Export

1. Open the Compiler tab and type or paste text (or open Demodulator and import a .ptl3.json)
2. Set the PTL name (e.g. chess.py, status.diary.en) in the name field
3. Click ⬡ Image — a modal opens with Full and Basic previews
4. Select the mode and click ↑ Export
5. File downloads as [name].[full|basic].ptl3.png

LLM Integration

Emitter System Prompt — LLM outputs PTL-3

You are a PTL-3 encoder. Output your answer as a PTL-3 frame using the
compact text format, then optionally follow with a prose explanation.

PTL-3 COMPACT FORMAT:
  PTL3:3.0 [document-name.extension]
  QUAD.RING.GEOMETRY    SYMBOL  "sentence"    VALENCE
  ---
  gv:GLOBAL_VALENCE ga:GLOBAL_AROUSAL

QUADRANTS:
  TECH = Technical  — algorithms, code, systems, data
  SOMA = Somatic    — body, physical state, environment
  RELA = Relational — people, emotion, relationships
  MACR = Macro      — purpose, society, big-picture

RINGS:
  1 = Foundational   2 = Friction   3 = Pivot   4 = Metric

GEOMETRY (auto-assigned by QUAD+RING):
  TECH: node(1) waveform(2) ray(3) progress(4)
  SOMA: arc(1) dash(2) curve(3) fillarc(4)
  RELA: baseline(1) cross(2) smooth(3) anchor(4)
  MACR: square(1) block(2) target(3) goldcore(4)

Demodulator System Prompt — LLM reads PTL-3

You are a PTL-3 demodulator. When given a PTL-3 frame, reconstruct the
full meaning.

QUADRANT = DOMAIN:  TECH→systems  SOMA→body  RELA→people  MACR→purpose
RING = ROLE:        R1→foundation  R2→friction  R3→pivot  R4→outcome
VALENCE:            positive=good  negative=troubled

Reconstruct: (1) main topic, (2) narrative arc,
(3) emotional tone, (4) specific facts from element sentences.

Claude API Example

import anthropic

client = anthropic.Anthropic()

def encode_to_ptl3(text: str, doc_name: str = "doc.english") -> str:
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system=PTL3_EMITTER_PROMPT,
        messages=[{"role": "user", "content": f"Encode as PTL-3 [{doc_name}]:\n\n{text}"}]
    )
    return response.content[0].text

Bidirectional Agent Protocol

For multi-turn conversations, increment sequence numbers:

doc.english       → root
doc.english.1     → turn 1
doc.english.2     → turn 2

Ring progression R1→R4 across frames mirrors the conceptual arc: foundation → outcome.

Whiteboard Drawing

PTL-3 frames can be drawn by hand and photographed for computer interpretation.

1. Crosshair (black marker) — central +, dividing the board into 4 quadrants
2. Rings (light gray dotted) — 4 concentric circles: R1 small → R4 large
3. Elements (colored markers at ring intersections):
   Blue = Technical (NE) · Green = Somatic (NW) · Red = Relational (SW) · Black = Macro (SE)
4. Geometry — draw the shape from the vocabulary table at the correct position
5. Label (optional) — write the PTL name in the corner, e.g. chess.py

Computer interpretation pipeline: color segmentation → crosshair detection → ring radius measurement → element classification → quadrant assignment → export to compact or JSON.

Training Protocol

Full protocol in guides/training-guide.md. The goal is to bypass the phonological loop and register PTL-3 frames directly via the visual cortex.

Practical Schedule

Version History

PTL-1 is retained as the token-level substrate. The djb2 hash in PTL-1 feeds the PTL-3 sentence classifier and is used for demodulator verification.

Information Theory Foundation

Human Visual Bandwidth

• Retinal output: ~10 Mbps (1.2M ganglion cells × 8 bits)
• Pre-attentive processing: orientation, color, motion in parallel within 50–100ms
• Conscious throughput: ~10–50 bits/sec
• PTL-3 target: exploit the pre-attentive pipeline to bypass the conscious serial bottleneck

Compute Advantage

Key Research

• Treisman & Gelade (1980) — pre-attentive feature integration: color, orientation, spatial frequency processed in parallel in V1
• DiCarlo & Cox (2007) — visual cortex untangles invariant representations along the ventral stream
• Perceiver IO (DeepMind, 2021) — arbitrary modality inputs as spatial arrays
• Set Transformer (Lee et al., 2019) — O(n) attention on unordered element sets
• Information Bottleneck (Tishby, 2017) — optimal compression preserves task-relevant structure