EZ-Language (EZ) is designed to make programming easy, fast, and universally accessible. Whether you're a beginner or a seasoned developer, EZ empowers you to build complex projects with minimal friction, supporting reproducible environments and multi-language integration out-of-the-box.
- Easy: Simple syntax and setup for rapid development.
- Universal: Multi-language support lets you mix and match code across ecosystems.
- Reproducible: Nix-powered environments guarantee consistent builds and development experiences.
- Community-first: Open, extensible, and driven by contributors.
EZ-Language is an active experimental project. This codebase is under active development and should be treated accordingly.
- Rapid iteration: APIs, behaviors, file structures, and tooling can change significantly between releases without advance notice
- Unpolished code: This project includes rapid prototypes, AI-assisted scaffolding, and research utilities that have not undergone the same quality review as production-grade code
- Instability expected: Breaking changes are frequent; backward compatibility is not guaranteed
- Limited testing: Components may lack comprehensive test coverage and edge-case handling
If you choose to use EZ-Language:
- Thoroughly audit all code before integration
- Expect breaking changes between versions
- Be prepared to adapt to API modifications
- Test extensively in non-critical contexts first
- Monitor the project regularly for stability improvements
Verified on 2026-03-19.
Working now:
env native;environment declaration and config/Nix-aware execution flowfriend <stem>: <c|cpp|python> as <alias>;modules with build planning and native artifact generation- Typed variables (
int,float,boolean,string,void) with assignments and semantic checks - Interpreter support for arithmetic/comparison/logical expressions, function declarations/calls, returns, and negative numbers
- Control flow in interpreter:
if/else if/else,while, C-stylefor,break,continue - Built-in
print/printf - Quiet/verbose output controls (
--quiet,-v/--verbose) - C backend flow:
--emit-c,--build-native,--run-native - Backend comparison script (
./scripts/compare_backends.sh) showing interpreter vs compiled-native parity on supported samples
Quality signals:
- Test suite result (2026-03-19):
26 PASSED, 0 FAILED, 1 XFAIL - Includes friend type translator and control-flow regression tests
Known limitations:
- C/native backend is intentionally a subset and currently does not compile friend calls
- C/native backend coverage is narrower than interpreter coverage (advanced control-flow/forms may require interpreter mode)
foreach, classes, and fulltry/catch/finallyruntime behavior remain incomplete- Supported friend languages in this repo are currently
c,cpp, andpython
cmake -S . -B build
cmake --build build
./build/ez_main examples/demo.ez --run # quiet
./build/ez_main examples/demo.ez --run --verbose # verbose
./build/ez_main examples/demo.ez --run --non-interactive # no prompts (CI/demo safe)Example examples/demo.ez:
env native;
friend native_math: cpp as m;
int x = 1 + 2 * 3;
print("sum:", m.add(x,2));
Build + run (compiles friend first):
./build/ez_main examples/demo.ez --build --runNix dev shell (optional, auto-activates when available):
./build/ez_main examples/demo.ez --prepare # prefetch/build env
./build/ez_main examples/demo.ez --run # auto-enters nix-shell unless --no-env
./build/ez_main examples/demo.ez --env-info # show resolved env file/sourceFor scripted runs and CI, prefer one of:
./build/ez_main examples/demo.ez --run --no-env
./build/ez_main examples/demo.ez --run --non-interactiveQuiet: only user print/printf output.
Verbose: environment banner, friend build plan, compile/link commands, evaluation results (=>), variable state.
Declare and call external native code:
friend native_math: cpp as m;
print(m.add(3,2));
Use --build to produce .ezenv/build/lib<alias>.dylib.
Python friends also supported (python language) via generated shim.
Generate C source and optional native binary from int-only subset:
./build/ez_main examples/math.ez --emit-c
./build/ez_main examples/math.ez --build-native
./build/ez_main examples/math.ez --run-nativeBackend parity demo (interpreter vs compiled-native on the same input):
./scripts/compare_backends.sh ./tests/test_simple_printf.ez
# or omit argument to use the default sample
./scripts/compare_backends.shUse the project wiki as the canonical documentation source:
This roadmap moves from a minimal core toward a reproducible, multi-language coordination layer with strong tooling and community ecosystem.
- Parser, grammar, tiny interpreter (ints, expressions, print)
- Basic environment declaration (
env native;) - Friend modules (C/C++ & Python shim)
- Map environment declarations to Nix expressions
- Auto-generation/import of Nix files for reproducible builds
- Layered override model (base env + project customizations)
- Expanded friend module types (Rust, JS/WASM, Mojo, Rust, etc..)
- Glue/interface layer with signature introspection & basic type marshaling
- Deterministic build graph visualization
- EZ → C/LLVM/WASM backends (beyond int subset)
- Function execution, returns, boolean operators, richer types (string, array, map)
- Unified error & reporting system (structured diagnostics, machine-readable JSON)
- Registry for modules, environments, templates
- CLI search, install, update, verify provenance
- Dependency manifest + lock format
- VS Code extension: syntax highlighting, hover docs, inline diagnostics, friend build tasks
- Command palette actions (run, build, emit C, plan)
- Incremental parsing & semantic lint loop
- High-level glue automation (signature inference, type adapters)
- WASM sandboxed execution path
- Performance profiling & trace export
- Unified error/reporting pipeline (colorized CLI, structured logs, JSON output flag)
- Build metadata cache + reproducibility audit
- Test harness integration for friend modules
- Documentation expansion & examples
- Stability & performance passes
- Community feedback loop shaping language additions
Short-term upcoming: execute class functions & returns, boolean operators, extended type system, initial module/package manifest.
Use the wiki contribution and setup pages for the latest workflow details.
See LICENSE.