TENGWAR — The Symbolic Language Forged for Machine Intelligence

I · Code

See the Difference

The same quicksort algorithm. On the left, what humans write. On the right, what machines think in. Zero parsing ambiguity. Structural regularity.

Python 9 lines

def quicksort(xs):
    if not xs:
        return []
    pivot = xs[0]
    rest = xs[1:]
    lo = [x for x in rest if x < pivot]
    hi = [x for x in rest if x >= pivot]
    return quicksort(lo) + [pivot] \
           + quicksort(hi)

Tengwar 9 lines

(↺ qsort (λ xs
  (? (empty? xs) ⟦⟧
    (>>
      (head xs) → pivot
      (tail xs) → rest
      (filter {< _ pivot} rest) → lo
      (filter {>= _ pivot} rest) → hi
      (concat (concat (qsort lo) ⟦pivot⟧)
        (qsort hi))))))

II · Features

Forged for Machines

Every design choice optimizes for how AI models tokenize, parse, and reason — not how humans type.

Single-Symbol Operators

Lambda is λ, not "function". Bind is →, not "let...in". Each symbol is one token. One meaning. Zero ambiguity.

( )

Strict Prefix Notation

Source code is the AST. No operator precedence. No parsing ambiguity. One canonical form per program.

⊢

Proof-Carrying Code

Runtime assertions are first-class. Programs prove their own correctness. Trust is built into the syntax.

∥

First-Class Parallelism

Parallel execution is a language primitive, not a library. Express concurrent computation in a single symbol.

Content-Addressed

Parameters use hash-prefixed names. Definitions are identified by content, not position. No version conflicts.

Pattern Matching

Destructure any value. Match on literals, wildcards, or bindings. Exhaustive by design.

III · Comparison

Measured Against the Field

Tengwar isn't competing with Python for human developers. It's the language AI writes when talking to itself.

Property	Python	Lisp	GlyphLang	Tengwar
Tokens per operation	3–8	2–5	1–3	1
Parse ambiguity	High	Low	Low	Zero
Source = AST	No	Yes	No	Yes
Built-in parallelism	Library	Library	No	Primitive
Proof assertions	No	No	No	First-class
Designed for	Humans	Humans	AI + Humans	AI

IV · Design Principles

The Fëanorian Axioms

Named for the Elf who created the original Tengwar — each principle drives every decision in the language.

One Symbol, One Meaning

Every operator maps to exactly one semantic operation. λ is always lambda. → is always bind. There are no overloads, no context-dependent syntax, no surprises.

Source Is Structure

Tengwar code is its own AST. There is no separate parse tree. What you write is what the machine sees. This eliminates an entire class of bugs.

Density Over Readability

Tengwar is more compact than Python for data pipeline code — filtering, mapping, sorting, field extraction. When your AI agent is generating code, structural regularity and zero ambiguity matter more than brevity alone.

Trust Nothing, Prove Everything

Proof assertions (⊢) let programs verify their own correctness at runtime. Code that carries its own proof doesn't need external validation.

V · Getting Started

Begin

Tengwar runs on Python 3.10+ with zero dependencies. Clone the repository and start writing.


            $ git clone https://github.com/galcock/tengwar.git

            $ cd tengwar

            $ python3 main.py

            

            tengwar› (+ 40 2)

            42

            

            tengwar› (map {* _ _} ⟦1 2 3 4 5⟧)

            ⟦1 4 9 16 25⟧

            

            tengwar› (∥ (+ 1 2) (* 3 4) (- 10 5))

            ⟨3, 12, 5⟩