Roadmap

Basic Language Features

Structs/Records: Implement structures or records as compound data types that can hold data of different types. This includes syntax for defining structs, initializing them, and accessing their members.
Enums: Add enumerated types with associated data (like in Rust), which are useful for representing a fixed set of possibilities.

Traits/Interfaces: Implement traits (similar to Rust) or interfaces that define methods a type must implement, allowing for polymorphism and behavior abstraction.
Type Aliases: Allow users to create aliases for existing types for readability and convenience.

Modules/Namespace: Implement a module or namespace system for better code organization, allowing for encapsulation and reusability of code.
Imports and Exports: Define syntax for importing and exporting functions, types, and constants from modules.
Package System: Develop a simple package system to manage dependencies and module versioning.

Compile-Time Evaluation: Introduce compile-time evaluation of expressions where possible, to optimize runtime performance.
Macros: Implement macros that allow writing code that generates other code at compile time, enhancing the power of metaprogramming.
Attribute-Based Programming: Introduce attributes or annotations that can be used to modify the behavior of the compiler or runtime for certain elements.

Pattern Matching: Enhance pattern matching, allowing for more expressive and concise ways to handle complex data types like enums and structs.
Higher-Order Functions: Ensure first-class support for functions that can accept other functions as arguments or return them as results.
Immutability and Side-Effect Control: Introduce language constructs to enforce or encourage immutability and control side effects, promoting functional programming paradigms.

Ownership and Borrowing: Depending on the memory model, consider implementing an ownership and borrowing system (like Rust) to manage memory safely and efficiently.
Safe References and Pointers: Introduce safe references and pointers, providing a way to point to memory locations without the usual risks associated with pointer arithmetic in languages like C.

Advanced Error Handling: Implement advanced error handling mechanisms, like Result types or Option types, for managing the presence or absence of values and handling errors in a more robust way.
Assertions and Contracts: Provide built-in support for assertions and design-by-contract programming to ensure program correctness.

Async/Await: Implement async/await syntax for easier handling of asynchronous operations.
Concurrency Primitives: Introduce threads, mutexes, channels, etc., for concurrency management.