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 is load-bearing.

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.