x64base
A glass-box database engine for building and teaching data systems.
x64base is the stateful substrate of a configurable Laboratory Campus. DotTalk++ makes the engine executable and observable; SelfDoc and MDO turn source, HELP, metadata, contracts, and proof into documentation and curriculum. The goal is a glass-but-real system whose development can be inspected, taught, and improved from the same evidence.
Active beta — proof-gated SDLC
Runtime claims move through source, contracts, tests, maintainer review, and publication gates. Experimental and planned lanes remain labeled until their evidence is complete.
engine status
DotTalk++ CLI + DBF runtime + metadata validation
open architecture
The extension seams are part of the product.
x64base is not only a DBF runtime. It is an intentionally open architecture for index backends, workbench front ends, custom commands and functions, student code hooks, polling, triggers, and runtime lifecycle observation. That work remains visible because it is part of how the engine is learned, extended, reviewed, and proved.
Live runtime evidence already includes central command registration, Open Index API boundaries, education hooks, and order-aware traversal work.
That means the architecture is open by design, not by accident.
Open Index API
Indexing is not a sealed implementation detail. x64base publishes attach, rebuild, order, seek, and verification seams so CNX, CDX, LMDB, INX, and teaching-lab formats can be reasoned about as architecture.
Workbench Front Ends
GUI, TUI, and scriptable workbench surfaces are consumers of the same runtime truth. Ordering, cursor state, relations, validation, and command execution stay in DotTalk++ and the engine, not in duplicate UI logic.
Custom Commands and Functions
Built-in commands stay centrally governed, while student and local extensions can self-register through protected extension lanes. The same pattern supports custom functions, controlled hooks, and curriculum work.
Polling, Triggers, and Lifecycle Hooks
Pre/post polling seams, command lifecycle observation, mutation hooks, and relation/order maintenance are treated as explicit integration boundaries. They belong to the engine contract, not to ad hoc side effects.
x64base Engine
DBF-style runtime, x64-family table work, indexes, memos, work areas, and validation.
OpenDotTalk++
A readable command language for teaching, inspection, and scripted workflows.
OpenDotScript
The script language product for repeatable command files, loops, variables, comments, and automation.
OpenTupTalk
Tuple-centered tools for row inspection, export, validation, and record movement.
OpenRelTalk
A relation-focused layer for joins, algebra, and connected data exploration.
OpenLaboratory Campus / LabTalk
The configurable education and collaboration campus where engine work, tools, documentation, and proof become lessons.
Openstart points
A practical place to begin.
Source, build notes, runtime evidence, and generated-documentation paths are gathered without turning the homepage into a release page.
Source, build notes, runtime footprint, command catalog, and evidence starting points.
The visible doorway into campus cases, source-memory stories, and the systems storyboard deck.
Why dottalkpp.exe is the full command/runtime host while LMDB and SQLite stay external.
SelfDoc, MDO, generated manuals, diagrams, matrices, and reviewed documentation layers.
documentation
Readable status for real implementation work.
The site tracks reviewed implementation truth: C++20 CMake build options, DotTalk++ command surfaces, workspaces over DbArea objects, object-oriented memos, custom field type hooks, Open Index API, Open GUI API, and runtime validation work.
research context
The xBase ecosystem is still alive.
x64base belongs in the xBase conversation, but it is not a claim to replace every compiler, migration tool, DBF library, or commercial modernization platform. It is a focused 64-bit DBF-style architecture experiment with a recognizable table workflow.
Read the ecosystem contextView the feature comparisonOpen-source, commercial, migration, DBF-engine, and legacy branches all still matter.
Classic DBF-family formats carry structural assumptions from earlier computing eras.
x64base uses its own metadata and documentation infrastructure to describe, validate, and increasingly prove itself.
A feature matrix compares x64base with Harbour, xHarbour, Alaska Xbase++, XSharp, dBASE tools, and Python DBF libraries without overstating alpha work.
DotTalk++ can script database workflows today; the Application UI DSL lane explores menus, windows, dialogs, controls, and event handlers for future TUI/GUI targets.
Co-development documentation
SelfDoc and the Master Documentation Organizer are part of the engine’s working loop, not a separate after-the-fact publishing process.
Build with the engine
Start with the DBF_64 and FPT64 references, then move into APIs and index rules.
Teach with the shell
Use DotTalk++, DotTalk++ Workbench, Parallel GUI/TUI, Arctic TUI, and Laboratory Campus material for labs, front-end learning, command literacy, and database fundamentals.