Manifesto

The Cube Framework is built upon a simple conviction:

Architecture is more important than implementation.

Every line of code is temporary. Every implementation will eventually evolve. Only a well-designed architecture is capable of surviving continuous change.

For this reason, the framework deliberately avoids solutions that optimise only for short-term convenience. Instead, it favours systems that remain predictable as projects become larger and more complex.

Several principles guide every architectural decision.

Composition over inheritance

Behaviour should be assembled from independent building blocks rather than embedded inside deep inheritance hierarchies.

Composition reduces coupling, improves flexibility and enables systems to evolve without affecting unrelated functionality.

Data before behaviour

Runtime behaviour should emerge from data rather than hardcoded assumptions.

When data defines behaviour, systems become configurable instead of requiring constant modification of source code.

Explicit responsibilities

Every system should have exactly one clearly defined responsibility.

When responsibilities overlap, complexity grows exponentially.

When responsibilities remain isolated, complexity grows linearly.

Predictable runtime

Runtime systems should be deterministic.

Objects should not discover behaviour through hidden dependencies or implicit side effects.

Every operation should have a clearly defined owner, input and output.

Extensibility without modification

Frameworks should invite extension without requiring modification of their existing architecture.

New functionality should integrate naturally into existing systems instead of replacing them.

Long-term maintainability

Software is rarely discarded.

It is maintained.

Architectures should therefore optimise for readability, consistency and evolution instead of minimizing the number of lines of code.

The Cube Philosophy

The Cube Framework is not a collection of gameplay features.

It is a collection of architectural ideas.

Plugins, runtime systems and tools are merely concrete expressions of those ideas.

The objective has never been to build the largest framework.

The objective has always been to build one that remains understandable years after its creation.