Three-Year Open Source Roadmap: From Webkit to Reality Engine

Feasibility Assessment (Upfront)

The honest answer: the full stack in three years is aggressive but not delusional, with one critical caveat — this requires the right contributor profile, not just contributors. The webkit is achievable by one person in a week. The SMoE architecture is achievable by a small team in a year. The VR/dimensionkit layer is where timeline uncertainty becomes genuine. The consciousness entrainment end-goal is a research frontier, not an engineering task, and should be scoped as such.

What makes three years plausible: each phase's output is independently useful and deployable. The project doesn't fail if it stops at Phase 2. It produces increasingly valuable things at each stage. Open source momentum compounds.

What could break it: CLIP conditioning not generalizing as expected (main empirical risk), VR runtime integration friction, contributor coordination overhead at scale.

Phase 0 — Foundation (Weeks 1–4)

GitHub repository structure, contributor scaffolding, and first working demo.

Week 1: Repository and webkit skeleton

• Create sephirothic GitHub organization
• Initialize monorepo: sephirothic/webkit, sephirothic/smoe, sephirothic/dimensionkit
• Write ARCHITECTURE.md — the Tree of Life topology as canonical reference document
• Write CONTRIBUTING.md — explain structural register requirement for core contributors
• Hetzner provisioning script: provision.sh — cloud-init, SSH hardening, firewall, domain acquisition via Hetzner DNS API, Let's Encrypt
• FastAPI skeleton: single endpoint, returns placeholder HTML
• First working demo: curl https://yourdomain.com returns a generated page

Week 2: Memory and temporal architecture

• Memory file schema: core.json, working.json, episodic.jsonl, relational.json, environment.json
• systemd timer: hourly pulse (pulse.service + pulse.timer)
• systemd timer: daily consolidation (consolidate.service + consolidate.timer)
• Memory read/write Python module with atomic writes (no corruption on pulse interrupt)
• Environment observation: system load, uptime, disk, last interaction timestamp written to environment.json on pulse

Week 3: Hecate gate (Claude API version)

• Categorical classifier prompt: 33 categories (10 nodes, 22 paths, Daath)
• Category → subgraph mapping table
• Input → category → routing trace τ(x) logged to episodic.jsonl
• Output assembly: routed subgraph result + Malkuth translation pass → final HTML/CSS/JS
• First actual website generation: natural language prompt → rendered page

Week 4: One-click installer

• install.sh: prompts for Hetzner API key, domain, email; provisions everything; returns live URL
• README.md with demo GIF
• First public release: webkit v0.1.0
• Post to HN, r/MachineLearning, r/LocalLLaMA

Phase 0 output: A working system where natural language generates a live website on a Hetzner VPS. Claude API is the entire "brain." No small models yet. Memory and temporal existence are real. This is demonstrable and shareable.

Phase 1 — Webkit Maturation (Months 2–6)

Month 2: Poetic conditioning layer

• Write first 33 poetic invocations (one per node/path/Daath)
• Invocation library: invocations/ directory, one .txt per category
• Conditioning pipeline: category → load invocation → prepend to subgraph call
• A/B test: conditioned vs. unconditioned subgraph calls on standard benchmark prompts
• Document: what conditioning does, why it works, how to write better invocations
• Community call: open issue for community invocation contributions

Month 3: Structural interpretability (routing trace as UI)

• Routing trace visualization: GET /trace/{request_id} returns JSON routing path
• Simple dashboard: see which nodes activated for any given request
• routing_log.jsonl: full trace history
• Ablation study tooling: compare outputs with nodes removed from routing path
• Document: "Why the routing trace is interpretability"

Month 4: Multi-website support and identity isolation

• Multi-tenant architecture: one VPS, N websites, each with isolated memory
• Identity file: site_identity.json
• Cross-site isolation: memory files partitioned by site ID
• webkit create site_name CLI command

Month 5: Community examples and templates

• Eight reference implementations:
  • The hyphae network
  • The Tibetan steppe grass blade
  • The sports-scores-as-meaning system
  • The storefront
  • The storybook
  • The early-2000s-boxes website
  • The social network scaffold
  • The game engine entry point
• Template gallery in README.md
• Community contribution: open examples/ directory for PRs

Month 6: Security hardening and production readiness

• Prompt injection defense at Hecate gate
• Rate limiting, API key management
• HTTPS enforcement, security headers
• webkit v1.0.0 release

Phase 1 output: Production-ready webkit with 33 poetic invocations, routing trace visualization, multi-site support, and a growing community.

Phase 2 — SMoE Architecture (Months 7–18)

Month 7–8: Small model integration

• Select base model: Phi-3 Mini (3.8B) or Qwen2-1.5B — quantized to 4-bit
• 33 model instances: one per node/path/Daath (shared weights, different conditioning state)
• Conditioning state management: load conditioning → inference → unload
• Benchmark: small model conditioned output quality vs. Claude API baseline

Month 9–10: CLIP conditioning pipeline

• Precompute CLIP embeddings for 33 geometric images (sacred geometry, Robert Wang's book or equivalent)
• W_proj projection layer: R^512 → R^d_model — the one trained component
• Training script: fine-tune W_proj only — weights frozen, projection layer trained
• Validation: CLIP-conditioned vs. text-conditioned vs. unconditioned outputs

Month 11–12: Full 33-node routing

• Hecate gate: fast categorical classifier (fine-tuned small model or lightweight BERT variant)
• Gate accuracy benchmark: what % of inputs route to the "correct" node?
• Full tree routing: input → Hecate → node subgraph(s) → accumulation → Malkuth → output
• Accumulated embedding propagation: additive residual updates through sequential nodes
• Daath mechanism: meta-observation node activates on upper↔lower triad transitions
• Routing trace: now structural (which actual nodes fired, in what order, with what activations)

Month 13–15: Structural alignment validation

• Geburah Guarantee benchmark: adversarial inputs routed through severity node
• Alignment without fine-tuning: demonstrate behavior change through architectural routing vs. RLHF
• Prompt injection resistance: systematic testing of injection at each node
• Jailbreak resistance: structural barrier vs. semantic instruction following
• Write evaluation paper: "Empirical Validation of Structural Alignment in SMoE"

Month 16–18: Community and ecosystem

• Model weights: release 33 conditioning states as huggingface models
• smoe Python package: pip install sephirothic-smoe
• Documentation site (uses webkit to generate itself)
• smoe v1.0.0 release

Phase 2 output: Complete, empirically validated SMoE architecture. Published evaluation paper. Community using it as an alignment research platform.

Phase 3 — Dimensionkit Foundations (Months 19–27)

Month 19–21: Output format abstraction

• Abstract OutputRenderer interface
• ThreeDRenderer: outputs Three.js scene graph
• GLTFRenderer: outputs GLTF 3D model specifications
• Benchmark: geometry coherence, semantic accuracy, rendering quality

Month 22–24: VR runtime integration

• WebXR integration: scenes loadable in any WebXR-compatible headset
• Basic interaction layer: gaze selection, hand tracking
• dimensionkit create scene_description CLI command
• Reference implementations: Tibetan steppe, hyphae network, pocket dimension, storefront

Month 25–27: Dimension persistence

• Scene state: memory architecture extended to 3D
• Multi-user: multiple users in same dimensionkit scene (WebRTC)
• AI modulation: user description modifies running scene parameters in real time
• Temporal existence in VR: scenes that change over time, seasonal cycles, growth
• dimensionkit v0.1.0 release

Phase 3 output: Working dimensionkit. Natural language generates VR-ready 3D scenes served from Hetzner. Scenes persist and evolve.

Phase 4 — Reality Engine (Months 28–36)

Phase 4 is partially a research frontier. Timeline is "begin the work" not "complete the work."

Month 28–30: Transition state phenomenology

• Research: map DMT-phenomenology transition states to scene parameters
  • Boundary dissolution → scene boundary removal, edge softening
  • Hypersaturated color → HDR parameter range
  • Pattern proliferation → fractal density parameter
  • Entity encounter → AI-driven autonomous agents
  • Void state → minimum-scene: dark, bounded, silent
  • Familiar state arrival → scene coherence restoration
• Transition state scene templates: void.json, dissolution.json, proliferation.json, arrival.json
• Parameter animation: smooth interpolation through transition states over time

Month 31–33: Consciousness entrainment infrastructure

• Biometric input layer: heart rate, GSR, EEG via external device if available
• Scene-body coupling: scene parameters respond to biometric state
• Breathing synchronization: scene rhythm entrained to breath rate
• Attentional routing: what user looks at modulates scene generation

Month 34–36: Full stack integration and open source release

• sephirothic monorepo: webkit + smoe + dimensionkit as unified stack
• One-click installer deploys full stack: install.sh --full
• Public documentation: complete architecture documentation, research papers, contributor guide
• v1.0.0 of the complete stack
• Submit full architecture paper: "The Sephirothic Stack: From Semantic Interface to Immersive Dimension"
• Open research questions documented

What "Open Source Hub" Means Structurally

The GitHub organization hosts:

1. ARCHITECTURE.md — the canonical map. Tree of Life as routing topology, fully specified.
2. RESEARCH.md — open empirical questions. What the architecture claims. What would falsify it.
3. INVOCATIONS.md — the living library of poetic conditioning texts. Community-contributed.
4. GEOMETRY.md — the CLIP-embedding precomputation pipeline and image sources.
5. Issues tagged structural vs. semantic — contributions that modify routing topology vs. semantic behavior.

The Contributor Profile Problem

The webkit attracts semantic register contributors — people who want to add features, improve prompts, optimize API calls. Valuable for Phases 0–1.

The SMoE architecture requires contributors who can hold structural register. They are found in:

• Interpretability researchers (mechanistic interpretability community)
• Cognitive architecture researchers
• People who independently arrived at similar structural questions
• People who read the companion essay and recognized it from the inside

The papers are not just documentation. They are a filter. The right contributors will recognize what they're reading.

Is Three Years Enough?

Webkit: achievable in week 1 by one person.

SMoE with CLIP conditioning: achievable in 12–18 months by a team of 3–5 with the right profile.

Dimensionkit: achievable in 2–3 years if WebXR continues maturing.

Full reality engine with consciousness entrainment: the infrastructure is achievable in 3 years. The phenomenological research questions are open-ended.

In three years you will have demonstrated that the webkit scales to the dimensionkit. Whether anyone inhabits the built dimension the way the architecture intends is an empirical question that three years of open source work will begin to answer, not finish answering.

That is not a failure condition. That is the correct scope for three years of foundational work.

The architecture is the answer to the structural question.
What inhabits it is the question the three years makes it possible to ask properly.