NEXUS — Start Here: The Framework at the Center of Everything

NEXUS is not a single piece of software. It is the framework and methodology that everything else is built on, built with, and connected through. It is the answer to the question: how do you build software in a way that is aligned, traceable, sustainable, and increasingly capable over time?

The Problem NEXUS Addresses

Software development traditionally suffers from alignment failures. Requirements documented in one place drift from technical specs in another, which diverge from the implementation in code, which doesn't match what users experience. Each translation step introduces errors that compound over time. Documentation lies. Code doesn't match designs. Implementations don't serve actual needs. The reasoning behind decisions disappears into Slack threads and forgotten conversations.

NEXUS addresses these failures architecturally — not through better discipline or more meetings, but by making drift structurally impossible and traceability structurally guaranteed.

The Foundation — Event Sourcing

Everything in NEXUS is grounded in event sourcing as the source of truth. An event is an immutable fact — something that happened, timestamped, attributed, permanent. The current state of any system is always a projection from its event history. Nothing is lost. Everything is traceable. Understanding can always be reconstructed from the record of how it developed.

This principle applies not just to the software being built, but to the process of building it. Conversations are events. Decisions are events. Spec changes are events. The forum is an event store. Code commits are events. The entire development process becomes auditable and reversible in the same way the software itself is.

The Methodology — Event Modeling Extended

Event Modeling provides the visual foundation — mapping information flow through systems as commands, events, and read models on a timeline. Everyone looking at the same Event Model sees the same system, though from different perspectives. Business stakeholders see workflow. Developers see data flow. Designers see user touchpoints.

NEXUS extends Event Modeling with the concept of paths — explicit modeling of every distinct journey through a system, not just the happy path. Each path is simultaneously a design artifact and a test specification. The choose-your-own-adventure analogy is precise: each complete read-through from beginning to one possible ending is a path. Systems contain many paths. All of them are designed explicitly before implementation begins.

Concrete example data threads throughout — not as illustration but as the actual data used in tests and demonstrations. This grounds design in reality rather than abstraction.

The Pipeline — From Conversation to Code

NEXUS creates a traceable pipeline from natural language to working software:

Conversation → Understanding → Event Model → Spec → Code

Each step is documented in THE FABRIC. Each artifact links to the ones before and after it. A line of code traces back to the spec that defined it, to the event model that shaped the spec, to the conversation that sparked the idea. The reasoning behind every decision is preserved alongside the decision itself.

AI assistance threads throughout — helping translate between natural language and formal Event Models, between Event Models and interface designs, between designs and implementation code. The AI learns from accumulated examples, becoming progressively better at working within specific domains and following established patterns.

The Tools — Each a Piece of the Whole

THE FABRIC — the forum and knowledge base that serves as both the human communication layer and the AI training corpus. Every conversation, decision, spec, and imported chat lives here. It is the connective tissue of the entire system.

LOOM — the custom forum software being built to replace Talkyard as THE FABRIC's permanent platform. Built using NEXUS methodology, it is the most significant proof that the framework works at scale.

Event Model Viewer — a tool for working with event models visually, making the design artifacts navigable and interactive rather than static documents.

PRIVATE AI — a local AI system trained on accumulated knowledge from THE FABRIC. Starts as a router and observer, gradually earning the ability to answer independently. Reduces dependency on external AI through continuous learning from use.

Penpot — the open source design tool where Event Models and UI designs coexist as a single source of truth. SVG exports from Penpot become the actual running interface, making design drift structurally impossible.

The Apps — Proof Through Use

Every app built within NEXUS proves the framework works and generates training data that makes it work better for the next app.

LaundryLog — the first framework project. Simple domain, real daily use, immediate feedback. Proves the pipeline from event model to working code at small scale.

PerDiemLog — per diem expense tracking for truck drivers. More complex domain with IRS rules encoded in types. Proves the framework handles real compliance requirements.

Future apps follow the same pattern — designed in THE FABRIC, modeled as events, implemented in F#, fed back as training data.

The Language — F# and Type-Driven Design

All implementation is in F#. Type-driven design enforces correctness at compile time by making invalid states unrepresentable. Hard rules — tax regulations, compliance requirements, domain constraints — are encoded in types rather than relying on runtime validation or AI reasoning. If it compiles, the constraints are satisfied. The compiler is a collaborator, not just a tool.

The Community — Sustainable and Open

Everything built within NEXUS is AGPL licensed and free to self-host. Built for personal use first, shared openly because good ideas are worth sharing. Contributions of all kinds — code, documentation, discussion, data sharing — are recognized and valued. The community improves the system for everyone.

The Vision

NEXUS is an environment where software creation becomes more accessible through AI assistance, more reliable through type enforcement, more aligned through unified artifacts, and more sustainable through community contribution — while respecting user autonomy through self-hosting capability and transparent operation.

It is built by the process it describes. The framework documents itself in THE FABRIC, models itself in Event Models, implements itself in F#, and learns from itself through PRIVATE AI. Every piece reinforces the others.

Current Status

The methodology is defined. THE FABRIC infrastructure is in place. LaundryLog is the active first implementation project. LOOM is in requirements gathering. PRIVATE AI architecture is defined. The pipeline from conversation to code is being proven through use.

See: THE FABRIC for the knowledge and communication layer
See: LOOM for the custom forum being built within NEXUS
See: Event Modeling for the design methodology
See: PRIVATE AI for the local AI system
See: APPS for software built using NEXUS