What’s a Tau-Tongue, you ask? Check out the Tau-Tongue and BraidCraft Primer!

NOTE: Claude and I tag-teamed this post. The voice shifts are there to keep you in the upright position. Lean into it. Shhhh.

Tau-Tongue v3.6.9: From Hardcoded to Config-Injectable in One Marathon Session

Earlier this week we sat down with a single goal: make Tau-Tongue’s symbolic pipeline completely arbitrary. No more hardcoded BraidCraft archetypes The eleven numerologically derived archetypes of Tau-Tongue and BraidCraft — the act of interpreting a Tau-Tongue equation. . No more baked-in master numbers. No more assumptions about what system of meaning you want to run your text through. One TauTongueConfig object. Plug in anything. Get everything.

What followed was a six-sprint marathon that touched every layer of the stack, from the Pythagorean utility functions all the way up to the narrative interpretation layer, then kept going into a string of demos that pushed the new config system to its limits.

Here’s how it went.

The Problem with v2

Tau-Tongue v2 worked. It reduced text to digital roots The single-digit result of Pythagorean reduction — repeatedly summing an integer's digits until only one remains. , generated symbolic equations from a 256-operator algebra Tau-Tongue's symbolic matrix of 256 operators derived from mathematical, geometric, and unicode symbols, each carrying a unique metaphorical meaning. , braided those equations, derived crucibles The central operator extracted from a braided symbolic equation — the thematic core around which interpretation revolves. , computed antagonists, and produced narrative interpretations. All of it was interesting. All of it was locked to a single symbolic vocabulary.

The archetype map was a module-level constant. The resonance names were hardcoded strings. The “master numbers” 11 and 22 were literals scattered across utility functions. If you wanted to build a Jungian system, or an alchemical system, or a Norse runic system, you had to fork the entire codebase.

That’s not a library. That’s a prototype.

Six Sprints to v3.6.9

First, we mapped it out. And I was elated. If we kept iterating until we got to where I wanted to be, I could pull off my 3.6.9 version release target, haha. I was so stoked. (I 💜 Nikola Tesla! lol)

Sprint 1 (v3.0): Config Foundation

We started at the bottom. pythagoreanUtils.ts got a PythagoreanConfig interface and a DEFAULT_TYPAL_NUMBERS constant. The calculateDigitalRoot and cipherCycle functions learned to accept config, falling back to defaults when none was provided. The old alphaCipher function, which had been dead code for months, got deleted.

Sprint 2 (v3.1): Interpreter Injection

The TauTongueInterpreter class gained a constructor that accepts TauTongueConfig. Five DEFAULT_* maps were extracted as named exports: DEFAULT_ARCHETYPE_MAP, DEFAULT_ARCHETYPE_DESCRIPTIONS, DEFAULT_RESONANCE_MAP, DEFAULT_RESONANCE_DESCRIPTIONS, and DEFAULT_ARCHETYPE_FUNCTION_MAP. Every method that previously reached for module-level constants now reads from this. The PythagoreanConfig is derived internally from the consumer’s config, so nobody downstream ever needs to think about it.

Sprint 3 (v3.2): Symbol Operator Injection

The 256-symbol operator algebra became injectable. SymbolDefinition got a proper interface with JSDoc. The module-level symbol map was renamed to DEFAULT_SYMBOL_MAP and the interpreter gained instance-level getSymbol() and getSymbols() methods. Every call site across both interpreter versions was updated.

Sprint 4 (v3.3): TauSpine Config Threading

TauSpine is the recursive structure generator that turns an interpreted result into a tree of narrative scenes. It inherited from TauTongueInterpreter, so it needed the same config threading. We deleted the redundant getResonanceName method (it duplicated inherited getSymbolicMeaning), replaced hardcoded allRoots arrays with Object.keys(this.archetypeMap).map(Number), and updated createTauSpine to accept an optional config parameter.

Sprint 5 (v3.4 + v3.5): Proof by Demo

Two new demos, two completely different symbolic systems, zero source changes required.

TauAstrolabe runs an Alchemical system: seven classical planets as archetypes (Sol, Luna, Mercurius, Venus, Mars, Jupiter, Saturn), alchemical processes as resonances (Calcination, Dissolution, Separation…), and typal number A multi-digit number that halts Pythagorean digital-root reduction — preserved as-is instead of being summed down to a single digit. The default BraidCraft system uses 11 and 22; custom configs define their own. [12] for the Great Work. The visualization renders animated celestial orbits driven by the braid data.

TauAether runs a Norse Runic system: the nine worlds of Yggdrasil as archetypes, Elder Futhark rune names as resonances, and typal number [24] for the full Elder Futhark rune count. The visualization generates organic, breathing energy fields using simplex noise, with each braid layer rendered as a pulsating aether ring colored by its world.

Both demos import from ../dist/index.js as ES modules and pass their config to new TauTongueInterpreter(config). That’s it. The entire pipeline, from digital root reduction through narrative interpretation, operates within their custom vocabulary.

Sprint 6 (v3.6 + v3.6.9): Final Audit

We swept every remaining hardcoded [11, 22] (only found in backward-compatible !config fallback paths, which is correct), added comprehensive JSDoc to every public config interface, fixed a stale comment in extractMasterArchetypalMatrix, and bumped the version to 3.6.9.

The Demo Gallery

By the time the config system was proven, we already had a healthy collection of demos. But we kept going.

The Originals

Interpreter is the original workbench. Text in, full result panel out: digital root, archetype, resonance, symbolic equation, braid breakdown, antagonist, inflection points, narrative interpretation. It is the “show me everything” view.

Spine Generator takes it further, building recursive TauSpine trees from input text. You can see how the symbolic data fans out into hierarchical narrative structures.

The Visualizers

TauSigils and TauGlyphs turn equations into visual art. Sigils renders ethereal continuous-line drawings from the braid structure, connecting nodes in a radial layout. Glyphs takes a different approach, drawing colored node graphs that reveal the structural relationships between braid segments.

TauAlchemy renders animated alchemical seal geometry. Polygons, connecting lines, and pulsing cores all driven by the braid data. It uses the default BraidCraft config but the visual language is pure alchemical geometry.

TauAstrolabe and TauAether are the v3 config showcase demos described above. They prove that the same pipeline can drive completely different visual and symbolic worlds just by swapping the config object.

Jung-Tongue: The Chatbot

The crown jewel of the demo collection. Jung-Tongue is a chatbot-style interface backed by a Jungian symbolic system: twelve archetypes (The Hero, The Shadow, The Anima, The Animus, The Trickster, The Mother, The Sage, The Persona, The Self, The Child, The Syzygy, The Individuation), with typal numbers [10, 11, 12] and resonances like QUEST, REPRESSION, INTUITION, PUER, GNOSIS, CONIUNCTIO, and OPUS.

You type a thought. The engine interprets it, extracts the crucible operator from the symbolic equation, looks up its metaphorical meaning in the 256-symbol algebra, and constructs a reflective prompt: “When you consider [metaphor] acting upon [archetype]… What comes to your mind?”

It feels like talking to something. It is not an LLM. There is no neural network. It is pure deterministic symbolic algebra, and yet the responses land with an uncanny resonance because the Jungian vocabulary maps so naturally onto the operator metaphors.

The demo includes session persistence via Dexie (IndexedDB), a sidebar for managing multiple conversation threads, text export, archetype tooltips that show Jungian descriptions on hover, and voice input via the Web Speech API. You can literally speak your thoughts and watch the archetypal engine respond.

The Jungian config lives in its own ES module (jung-tongue-config.js), 110 lines of pure symbolic vocabulary. No custom symbol map needed. The default 256-operator algebra already contains all the metaphorical richness required.

What Actually Changed

The numbers tell the story:

• pythagoreanUtils.ts: PythagoreanConfig interface, DEFAULT_TYPAL_NUMBERS, config-aware calculateDigitalRoot and cipherCycle
• TauTongueInterpreter_v2.ts: TauTongueConfig interface, 5 extracted DEFAULT_* maps, constructor injection, instance-level symbol access
• TauTongueSymbolMap.ts: SymbolDefinition interface, DEFAULT_SYMBOL_MAP rename, deprecated module-level accessors
• TauSpine.ts: Config-threaded constructor, derived allRoots, createTauSpine config parameter
• index.ts: All new types and constants re-exported
• package.json: Version 3.6.9

Zero breaking changes for consumers using the default system. Every config field is optional and falls back to the BraidCraft defaults. But if you supply a config, every single layer of the pipeline respects it.

The Constraint Doesn’t Change. The Vocabulary Does.

That line from the v3 roadmap ended up being the design principle that held the whole refactor together. Tau-Tongue’s constraint is its algebra: Pythagorean reduction, symbolic equation generation, braid decomposition, crucible derivation. That algebra is invariant. What varies is the meaning you assign to each reduction endpoint, each resonance, each archetype.

A Norse system with 9 worlds and typal number [24] produces structurally identical equations to a Jungian system with 12 archetypes and typal numbers [10, 11, 12]. The braids have the same shape. The crucibles follow the same derivation. But the narrative surfaces are completely different, because the vocabulary is different.

That is what config injection buys you.

“The most interesting moment in the whole sprint was watching the Jungian config produce its first crucible. The algebra doesn’t know Jung from Odin. It just reduces, braids, and derives. But the metaphorical meaning of the operator, combined with the archetype name, produced a reflection that felt genuinely Jungian. The system doesn’t understand meaning. It hosts it.”

— Claude Opus, reflecting on the Jung-Tongue demo session

What’s Next

The config system is solid. The demo gallery proves it works across wildly different symbolic vocabularies. The next frontier is letting consumers define custom operator algebras (not just custom archetypes) and exploring what happens when the 256-symbol map itself becomes domain-specific.

So, TauTongue.com is next. I’m going to build out the resource site, then open-source and publish the repository and npm package.

But that’s a story for another sprint.