When an engine starts as a collection of useful commands, it is easy to let every new feature attach to whichever module already has access to the right state. That is convenient for the first prototype and expensive for everything after it.

For a new Rust-based Xonext project, I want the architecture to be easier to understand from the start. This is a separate effort rather than a claim that an older implementation has simply been renamed or ported.

Why start with the boundaries?

The first question was which responsibilities belong in the engine and which should stay outside it. A command-line interface should be able to ask the engine to start work. It shouldn't secretly be the engine. A GUI can make that same work visible later without inventing a parallel set of rules.

Likewise, the execution environment may vary: a native host, a Linux process, or a separately configured sandbox runtime. The core should not need to pretend they are the same environment to offer a consistent task lifecycle.

The shape I'm aiming for

CLI / future TUI / future GUI │ ▼ Application API │ ▼ Rust engine core ├── Project and session state ├── Work planning / orchestration ├── Runtime adapter contract └── Storage / audit records │ ▼ Configured execution runtime

Target separation of responsibilities; this drawing is a design sketch, not a verified release architecture.

The adapter boundary is especially important. If an execution target is missing, misconfigured or incompatible, I want the error to stay at that boundary. It should not become a generic failure that leaves the rest of the application guessing.

One engine, several interfaces

I still want a friendly experience for someone using the software outside a developer terminal. But usability does not require a graphical interface to own the underlying logic.

The practical order is to keep a dependable command surface, establish typed operations and state, and then let TUI or desktop views consume those same contracts. The user should not get different results depending on where the command was started.

The interface should explain the state. It should not become the only place that state exists.

What is still open

This note describes the architecture I am working toward. It is not a statement that every runtime adapter, TUI screen or GUI workflow has been completed. Before publishing a build, I would want to show reproducible installation steps, supported environments, observed error behavior and test evidence for the exact version being released.

For now, the useful result is a narrower design target: a modular Rust core that stays readable as new features are added, with the operator experience built around it rather than into it.

Back to journal ↗