Obfusku

Where Symbols Carry Meaning & Code Becomes Ritual

Most programming languages use symbols merely as syntactic shorthand for human-readable keywords. Obfusku inverts this relationship to establish symbol primacy — a paradigm where glyphs are the foundational carriers of semantics themselves, verified underneath by a strict Hindley-Milner type system.

In Obfusku, programs are not simply written and compiled; they are structured as arcane rituals and executed as spells — every ritual sealed shut with ❧, every binding declared with ≔, every function captured as λ.

“Where symbols carry meaning, and code becomes ritual.”

The Principles of Symbol Primacy

Obfusku has no if, no type, no let — every keyword an ordinary language reaches for is either eliminated outright or replaced with a glyph that carries its own semantic weight:

• ⟁, ⧆, and ⌘ don’t abbreviate Int, Real, and String — they are the base types themselves.
• ❧ does not mark the syntactic end of a file — it seals the ritual.
• λ does not define a callable wrapper — it captures an executable spell, curried and closed over its lexical scope.
• ≔ binds a name to a value; ˚ marks that binding mutable, ⟳ exports it — modifiers live on the binder itself, never on the name.

Sound Types, Not Just Symbols

Beneath the glyphs, Obfusku is a strictly typed language with a complete Algorithm W (Hindley-Milner) inference engine:

• Principal Type Inference: Every binding’s type is inferred, with parametric polymorphism and explicit annotations required only at module boundaries and function signatures.
• First-Class Algebraic Data Types: Shape ≔ { Circle(Real) ⟢ Rectangle(Real, Real) } declares a sum type with no type keyword at all — the parser tells a type declaration apart from an ordinary binding purely by its uppercase name.
• Exhaustive Pattern Matching: ⟡ doubles as both conditional and match — ⟡ x { ◉ → … ⟢ ◎ → … } is literally the same grammar as matching any other closed type’s variants, and the compiler statically rejects a match that doesn’t cover every constructor.
• Constant-Stack Recursion: Adjacent function declarations form one recursive binding group by position alone, evaluated through a trampoline — self- and mutual recursion never grow the call stack.

Ritual Execution Discipline

• Ritual Sealing: Every program ends in the terminal glyph ❧.
• Structured Exceptions: ☄ raises, ☊ catches — against a closed Exception ADT, not string-typed errors.
• Generics Without Angle Brackets: Array ▷ Int reads as Array<Int> — ▷ is ordinary left-associative type application, so generic syntax can never collide with </> comparison operators.

Tooling Built on the Same Grammar

Obfusku ships as a language, not just a specification — obfusku-lsp pushes live type errors and parse diagnostics into any LSP-aware editor as you type, and obfusku-fmt canonicalizes source layout deterministically. Both are dedicated crates inside the same multi-crate workspace as the core interpreter, sharing one frozen grammar with zero drift between what the spec says and what ships.

The Formal Specification

Obfusku’s complete grammar, type system, and semantics are frozen and documented as normative specs, not prose promises — SEMANTIC_CORE.md for meaning, CONCRETE_SYMBOLIC_GRAMMAR.md for every glyph’s exact grammar position, and a running set of ADRs recording why each design decision landed where it did.