Project Status and Roadmap: Zen Programming Language

The Zen Programming Language project is actively under development, aiming to deliver a revolutionary, keyword-free programming experience.

Project Status Overview

The core language features of Zen are largely complete, with a strong focus on stability and a robust testing infrastructure.

• Current Status: 90% Language Core Complete
• Test Pass Rate: 100% (195/195 tests passing)
• Stability: Zero segfaults reported
• Disabled Tests: 7 tests are currently disabled, awaiting the implementation of required features such as certain behaviors, pointers, and inline C FFI.
• Showcase Example: showcase.zen is fully operational, demonstrating all implemented features.
• Test Runner: A dedicated ./scripts/run_tests.sh script provides easy execution of the comprehensive test suite.

Feature Implementation Status

Working Features (✅)

The following core features have been fully implemented and are working as designed:

• Zero keywords design
• Pattern matching with ? (all forms)
• All 6 variable forms (immutable/mutable, typed/inferred)
• Basic types (i8/i16/i32/i64, f32/f64, bool, string)
• Structs and enums (full support with payloads)
• UFC (Uniform Function Call) (method chaining and overloading)
• String interpolation ("${expr}" syntax)
• Comprehensive string methods (.len(), .substr(), .char_at(), .split(), .to_i32(), .to_i64(), .to_f64(), .trim(), .contains(), .starts_with(), .ends_with(), .index_of())
• Range iteration ((0..10).loop(), (1..=5).loop())
• Range structs (can store and use ranges as values)
• Infinite loops (loop() with break/continue)
• Block expressions (return last expression)
• Closures (arrow functions with captures)
• Enum patterns (both Enum.Variant and .Variant)
• Option<T> (Some/None with pattern matching)
• Result<T,E> (Ok/Err with basic support)
• Error propagation (.raise() extracts values correctly)
• Collections (DynVec<T>, HashMap<K,V>, HashSet<T>)
• Allocator-based async (GPA (sync) and AsyncPool (async) allocators)
• Behaviors system (structural contracts without keywords)

Partially Working Features (⚠️)

These features have initial implementations but require further development or refinement:

• Generic instantiation: Basic Result/Option work, but complex nested types still need work.
• Result<T,E> returns: Pattern matching works, but function returns exhibit type mismatch issues.

Not Yet Implemented Features (❌)

The following features are planned for future development:

• Metaprogramming: Compile-time AST manipulation.
• Pointer types: Full support for Ptr<T>, MutPtr<T>, RawPtr<T> (currently partial).
• Actor model: Message passing concurrency.
• Channels: CSP-style concurrency primitives.
• Module exports: module.exports/import functionality.
• Build system: A self-hosted build.zen environment.
• Full FFI: Complete Foreign Function Interface (inline.c() currently has partial functionality).

Build System

Current Build System: Makefile + Cargo

The Zen compiler itself is currently built using a combination of Makefile and Cargo.

• make build: Compiles the Zen compiler.
• make test: Runs the test suite.
• make lint: Executes the linter.

This setup provides a robust and familiar development environment for the compiler's implementation in Rust.

Future Vision: Self-Hosted build.zen

The long-term vision for the Zen language includes a self-hosted build system written entirely in Zen. Example build.zen files are already present in the tools/ and examples/ directories to demonstrate this concept. However, the current compiler implementation does not yet support executing these build.zen files. This self-hosted build system is a significant future goal, aligning with Zen's philosophy of being a fully expressive and self-sufficient language.