AHA! Lang Roadmap: Where Are We Going Next?

Every serious language needs an honest map. Here is the AHA! Lang roadmap — what has been achieved, and what we're aiming at next.

✅ Already Built

The language foundation is complete and verified by 417 automated tests in CI:

• Lexer & Pratt parser with clear error reporting
• Int, Bool, String types with compile-time type checking
• Operators: arithmetic, comparison, &&/||, prefix, assignment
• Control flow: if/else (expression), while, for i in a..b, break/continue
• Functions: parameters, return, forward references, mutual recursion
• String struct: safe concatenation, ==/!=, len() in O(1)
• Array literals & indexing (codegen)
• Builtins: print, print_str, abs, min, max, len
• JIT execution via LLVM
• CLI: --file, --emit-ir, --version
• VS Code extension for syntax highlighting (editors/vscode)
• CI pipeline: cargo check, automated tests, cargo build --release

Struct (F1) — Complete

Structs work fully at runtime:

• Struct literals: Point { x: 3, y: 4 } — built via LLVM insertvalue
• Field access: p.x read via extractvalue
• Typed fields: name: string, age: int — LLVM layout follows the type, checked at compile time
• Field mutation: p.x = value — a true lvalue, type-checked
• Struct as parameter & return value: structs pass by value into functions, and functions can return structs

Type Inference & Annotations (F2) — Complete

• Type annotations: let x: int = 5 — explicit int, string, bool, or struct name; values are type-checked at compile time
• Type inference: variables without annotations infer their type from the expression
• Function return type inference: fn greet() { "hello" } returns a String — callers can do let s = greet(); len(s)
• If-expressions with string branches produce real strings

Generics / Parametric Types (F3) — Complete

• Generic functions: fn pick<T>(a: T, b: T) -> T — concrete types inferred from each call site
• Monomorphization: each unique (name, concrete types) becomes a separate LLVM function — zero runtime cost
• Multiple type params: fn first<A, B>(a: A, b: B) -> A
• Return type annotations: -> T, -> int

🚧 In Progress (Phase 2)

This is the most exciting part — the big direction of the language:

1. Module System & Package Manager (F4)

aha install — a package ecosystem for sharing and using libraries. The gateway to large-scale projects.

2. Resource Lifetimes (F5) — Temporarily Frozen

Safe manual memory management — no garbage collector, no memory leaks. F5 is deliberately frozen until F1–F4 are stable: stabilize first, then move step by step.

3. Actor-Model Concurrency (F6)

Concurrency with message passing — using many CPU cores without headaches.

4. Self-Hosting (F7)

The ultimate goal: the AHA! Lang compiler written in AHA! Lang itself. Once achieved, the language proves its maturity.

Development Governance

• Branch workflow: every feature starts on an experimental/<feature> branch, merges into development only once stable; main only receives PRs with green CI.
• Every feature is traced: every change is recorded in the changelog (EN + ID) — we need the trail.
• PRD as the reference: all features must originate from the roadmap in PRD.md, not ad-hoc ideas.

Want to Contribute?

AHA! Lang is an open source project (MIT). The best way to start:

1. Read the code: the compiler is ~a few thousand lines of Rust — start with src/main.rs.
2. Find an issue: bug reports and feature ideas on GitHub Issues.
3. Send a PR: full guidance in CONTRIBUTING.md.

Our vision is simple: a language that is easy to read, powerful to wield — and you can help make it happen.