Symbology

Janus Symbology

This is the reference card for every contributor.

Glyph	Name	Semantic Role	Usage Context
☍	The Janus	Identity / Dualism	The Core, The README, The Philosophy. Represents the tension (Safe vs. Unsafe, Script vs. System).
🜏	The Antimony	Constitution / Law	Invariants that cannot change. The “Purified” Core. Used in SPEC-*.md for hard rules.
⟁	The Delta	Transformation	Where the Compiler intervenes (Ghost Memory, Desugaring, Lowering).
⊢	The Turnstile	Judgment / Truth	Semantic rules. Affine type enforcement. “The compiler proves this.”
∅	The Void	Forbidden	Anti-features. GC, inheritance, hidden control flow. “This path is closed.”
⚠	The Hazard	Raw / Unsafe	Pointer arithmetic, unchecked casts, :core profile code.
⧉	The Box	Boundary	Capabilities (ctx.net), FFI boundaries, Module interfaces.

---

The Safety Dial

The “Safety Dial” is not a knob; it is a selection of Symbolic Modes.

Mode A: ⚠ Raw (The Core)

• Profile: :core
• Glyph: ⚠
• Semantics: No guards. You are the hardware.
• Memory: Manual Pointer Arithmetic.

// ⚠ SAFETY: User guarantees bounds.
func poke(addr: usize, val: u8) do ... end

Mode B: ⊢ Strict (The System)

• Profile: :core
• Glyph: ⊢
• Semantics: Affine Types / Unique. The compiler judges ownership.
• Memory: Linear types (~T). Move-by-default.

// ⊢ INVARIANT: 'buf' is consumed.
func send(buf: ~Buffer) do ... end

Mode C: ⟁ Fluid (The Edge)

• Profile: :edge / :script
• Glyph: ⟁
• Semantics: Ghost Memory / ARC. The compiler transforms intent into safety.
• Memory: Implicit ownership. Elided ref-counts.

// ⟁ TRANSFORM: Compiler inserts 'retain/release'.
func process(data: Buffer) do ... end

---

The Rule of Thumb

The glyph table above draws a hard line between two halves of Janus. The line is the whole design:

Keep English for control flow and logic. Keep sigils for phase and type machinery.

That keeps the poem in the body, and the steel in the skeleton.

• The body — func, if, for, match, return — reads like prose. A reviewer skims it the way they skim an essay.
• The skeleton — § (compile-time), $ (extraction), @ (metadata), [T] (generics), *T (pointers), !T (errors) — carries phase and type machinery. Dense by design, because it bears the structure.

Mix them freely and both lose. English that does type computation becomes ambiguous prose. Sigils that do control flow become line noise. Janus keeps them in their lanes.

See /philosophy/haiku/ for the goal-word each profile swears by.