Mission
Build a configurable Laboratory Campus where people learn data systems by using, inspecting, and helping to build the same engine, language, documentation, and proof tools that operate the campus.
x64base exists to make database literacy practical and visible. It should run well enough to support real work while remaining transparent enough for a learner to trace a table, command, schema, index, document, decision, and proof back to the system that produced it.
Vision
A self-describing, increasingly self-hosting learning ecosystem in which:
- x64base is the stateful data substrate for tables, records, fields, memos, indexes, relations, work areas, validation, and storage lifecycles.
- DotTalk++ is the executable campus language for commands, scripts, observation, repeatable labs, and proof readback.
- HELP, metadata, contracts, SelfDoc, and MDO are institutional memory: they explain, organize, validate, preserve, and publish what the system does.
- The Laboratory Campus is the configurable learning environment that turns live project work into labs, lessons, cases, datasets, tools, and learning paths.
- Students, developers, educators, and AI collaborators share governed evidence instead of receiving separate simplified stories.
The long-term goal is not merely a database product with training attached. It is a place where the database, its development process, and its curriculum are made from the same inspectable materials.
The Campus Direction
Everything is data.
Everything can become a lesson.
Everything important should be inspectable.
That is a direction with proof gates, not a claim that every part is already self-hosted. The current system still uses source files, YAML registries, runtime transcripts, generated reports, and companion tools. Those assets move toward x64base-backed curation through explicit import, validation, export, and recovery proof.
Glass but Real
"Glass" means observable, explainable, and traceable. It does not mean fragile or toy-like.
The engine and campus should:
- run reasonably well on supported paths;
- expose state, cost, and failure honestly;
- distinguish implemented, runtime-proven, source-defined, simulated, historical, planned, and experimental material;
- preserve reproducible evidence;
- teach why mutation boundaries, reliability, backup, recovery, and validation matter.
Co-development Is Curriculum
The system develops recursively:
x64base behavior
-> DotTalk++ command or script
-> source, HELP, metadata, and contract evidence
-> SelfDoc preservation and MDO organization
-> manual, diagram, lab, lesson, and website derivative
-> review exposes drift, weak proof, or hidden behavior
-> findings return to the engine, language, metadata, and tests
A new feature becomes a state lesson. A bug becomes a lesson in assumptions and proof. A documentation correction becomes a lesson in authority. A generator becomes a lesson in how data becomes an explanation. Students learn not only the finished answer, but how a real system is examined and strengthened.
Tools Are Part of the Campus
The campus progressively exposes the same tools used to build it: DotTalk++ and DotScript, source review and AI-assisted exploration, SelfDoc, MDO/manualgen, validators, diagram generators, portal registries, build systems, and publication checks.
Beginners receive a usable path first. They can then open the glass and follow the deeper tooling, evidence, and decisions behind it.
The AI Portal
The AI Portal is intended to give an AI collaborator a rapid, task-specific introduction to the ecosystem. It follows curated, typed jumps between projects and artifacts, checks authority and proof, and assembles a bounded context packet for a series of related tasks.
The AI Portal lane is Alpha/Experimental. It is not production autonomous memory, an independent source of truth, or permission to bypass human approval. Generated context may be incomplete or stale; it must explain its evidence and default to read-only preparation.
Read the AI Portal Alpha/Experimental lane.
One Campus, Three Journeys
learner: concept -> example -> data -> command -> observation -> proof -> lesson
developer: request -> source -> change -> test -> proof -> documentation -> publication
AI collaborator: task -> curated context -> constraints -> action -> verification -> closeout
These are different entrances into the same evidence system.
Public Identity
x64base is building a glass-but-real Laboratory Campus where the database is infrastructure and subject, DotTalk++ is the teaching language, documentation is executable institutional memory, and development itself becomes proof-backed curriculum.
The project is more than a product, but it is not less than one. The engine and tools must remain useful, testable, and honestly described while the campus grows around them.
The smiling database mark is the selected site icon for this publication pass.
Collaboration Direction
The campus welcomes review from computer science and database educators, technical-writing instructors, general-education specialists, learning-science researchers, practitioners, students, and maintainers.
The goal is not to present every lane as finished. The goal is to make the system transparent enough to decide what should become curriculum, what should remain experimental, and what requires stronger evidence before promotion.