Article by Ayman Alheraki on January 11 2026 10:37 AM
The design of a new programming language is not merely a technical exercise, but an articulation of a clear philosophy—a vision that defines the language’s purpose, its audience, and its boundaries. Informed by decades of evolution in system programming, the shortcomings of legacy tools, and the growing power of modern C++ (particularly C++20 and C++23), this section defines the core goals and guiding philosophy of our new C-style language.
Rather than reinventing syntax for novelty or copying features blindly, we aim to deliver a cohesive, efficient, safe, and expressive language tailored for system-level tasks, scripting, and educational use, implemented entirely using the capabilities of modern C++.
One of the critical lessons from languages like Go and Zig is the value of simplicity: a language should be learnable, readable, and predictable. Yet, simplicity must not come at the cost of expressive power. Our language aims to:
Reduce cognitive overload through clean, orthogonal syntax
Eliminate unnecessary boilerplate while preserving semantic clarity
Adopt a small, consistent set of core constructs that serve multiple roles
Using C++20 concepts, constexpr, and clean recursive descent parsing (enabled by std::variant, std::visit, and pattern matching constructs), we will design a grammar and interpreter that enable simplicity at both the syntax and runtime level.
Memory safety is a core concern of any new language. Instead of relying on garbage collection or complex borrow-checking like Rust, we embrace explicit ownership with deterministic lifetime rules. This approach is enabled by:
Stack-first allocation model with scoped lifetime (RAII style)
Optional heap allocation with explicit ownership transfer
Value semantics by default; references must be opt-in and visible in syntax
Built-in types for ownership: ptr, ref, slice, and own
These concepts map cleanly to C++23 primitives like std::unique_ptr, std::span, and std::optional, and can be mirrored in our language using similar idioms and internal representations.
Concurrency is a necessity in modern computing but remains error-prone in many languages. Our language will introduce a simplified concurrency model inspired by the advances in C++20/23:
Concurrency primitives built into the language (spawn, join, atomic)
Lightweight thread abstraction using std::jthread or coroutine-based dispatch
No shared mutable state by default; message-passing and copy semantics preferred
Race condition mitigation through compile-time ownership enforcement
By designing the interpreter using std::atomic, std::barrier, and std::latch where needed, concurrency can be tested and verified directly in the core runtime, ensuring safety without over-complexity.
Static correctness and performance optimization often require compile-time logic. We embrace this with first-class compile-time evaluation, inspired by both Zig’s comptime and C++’s consteval:
Functions and expressions can be marked to evaluate at compile time
Constants are resolved and validated during parsing or AST building
Type reflection and introspection tools are available in user space
Simplified compile-time dispatch based on traits and argument types
Modern C++ provides robust compile-time execution using constexpr, consteval, and template constraints. Our language can abstract these through a type system capable of static dispatch, constant folding, and error generation at parse time, not runtime.
A powerful type system helps detect errors early without overwhelming the user. Our language will feature:
Statically typed variables with optional type inference
Algebraic data types and tagged unions
Custom types, traits, and interfaces
Structural typing for generic programming
Optional nullability via explicit maybe<T> or option<T>
This design is deeply inspired by C++'s modern tools:
std::variant and std::monostate for safe unions
std::optional for nullable values
concepts and requires for generic constraints
The type checker in our interpreter will be built using C++20 type traits and std::is_... utilities, extended by custom concepts to enforce trait conformance, making the language safe and predictable.
To serve embedded systems, education, and rapid tooling, our language must maintain a minimal runtime. That means:
No dependency on external garbage collection or JIT engines
No dynamic linking or external runtime initialization
Self-contained interpreter with clear execution model
Portability across platforms and architectures
Thanks to C++ modules, constexpr allocation, and modern ABI-stable components, we can design a runtime that is small, deterministic, and portable across operating systems and hardware targets without external dependencies.
A modern language must facilitate large-scale software construction. Our language will include:
Module-based code organization from the ground up
Namespaces or packages to prevent symbol collisions
File-based compilation units with explicit imports and exports
Optional inline modules for scripting and REPL usage
C++20’s module system gives us the tools to build a modular interpreter backend. This will be reflected in the new language’s compiler and runtime, allowing developers to encapsulate logic and share reusable components cleanly.
The language will remain C-style in its surface syntax to lower the learning barrier and attract existing C/C++ developers, but it will diverge from legacy semantics by enforcing:
No implicit type conversions between incompatible types
No default integer promotion rules
Explicit pointer dereferencing and address acquisition
Clear expression of mutability and ownership in function parameters
In other words, syntax will feel familiar, but behavior will be safer, stricter, and more predictable, thanks to a rigorous parser and semantic checker built using C++20 constructs like std::variant, std::monostate, and std::visit.
The philosophy of our language can be summarized in the following core principles:
Clarity over cleverness: No hidden magic; behavior is explicit
Safety by design: Eliminate undefined behavior at compile time
Performance transparency: Developers should understand the cost of every abstraction
Modern by default: The language will use idioms and patterns enabled by C++20/23
Minimalism and completeness: Few core features, but deeply composable
Practicality over perfection: Designed for real-world use, not theoretical elegance
Our new language is not intended to replace C++ or compete with Rust—it is a response to the challenges faced by developers today, using the most powerful and refined tools C++ has introduced in the last five years. By embedding our interpreter in modern C++20/23, we gain unparalleled performance, abstraction, and safety in the implementation itself. At the same time, we produce a language that serves a purpose: clarity, correctness, and control in the hands of those who build systems.