Orthon is built on the belief that a programming language should be small in its core, consistent in its rules, and extensible by design. The language favors orthogonality over historical compatibility and composition over special cases.
The language evolves as a coherent system, not as an accumulation of legacy decisions.
A single idea should have a single canonical representation.
Every symbol, operator, and keyword has exactly one meaning regardless of context.
Behavior is expressed through modifiers rather than special-case syntax.
Code should express intent rather than implementation details.
Every capability available to the compiler should, whenever practical, be available to the programmer.
Language evolution should primarily happen through libraries and user-defined modifiers instead of introducing new keywords.
New capabilities should emerge by composing existing mechanisms instead of adding special cases.
Variables, functions, types, classes, and modules follow the same declaration principles and modifier system.
The language minimizes fundamental concepts while maximizing expressiveness through composition.
Orthon is designed around a small set of orthogonal concepts:
- One symbol — one role.
- One concept — one syntax.
- Modifiers define semantics.
- Composition replaces special cases.
- Language features are extensible.
- Readability comes from consistency rather than convention.
This manifesto defines the philosophy of the language.
Implementation strategies, performance trade-offs, standard library design, optimization techniques, and programming idioms belong to the Orthon Zen and are intentionally outside the scope of this document.