← Back to projects

L Programming Language

A programming language with readable, sentence-style source, first-class Apps, and native compilation through Rust.

  • go
  • rust
  • programming-language
  • compilers
  • open-source
L programming language logo with the words Readable source. Native programs. on a dark blue background.

Highlights

  • Designed a precise, sentence-style language with explicit imports and applications modeled as values.
  • Built a Go compiler pipeline that lowers L through structured markup into Rust and native Cargo builds.
  • Implemented a native orchestrator that coordinates separate App processes and exposes their status, output, and errors.

Screenshots

L compiler pipeline from sentence-style source through Lyger and AML to generated Rust, Cargo builds, and native App processes.
Official L compiler diagram: source analysis, structured intermediate representation, Rust generation, and native builds.
L native orchestrator running App processes, with App-owned Service libraries shown separately from standalone Service values.
Official L process diagram: the orchestrator coordinates App processes; App-owned Services are library build artifacts.

What it is

L is an open-source programming language I created to explore readable source and applications as first-class values. Programs use sentence-style syntax with a defined grammar, explicit imports, and named values. The compiler checks those rules and produces native programs through Rust and Cargo.

Apps are values that can be composed and executed as separate processes. They carry structure and lifecycle information, including status, output, and errors, so a program can describe both its work and how its applications run. The language guide introduces this model through small programs and concrete syntax.

What I contributed

  • Designed the language grammar and value model, including explicit name binding, imports, Apps, and Services. Readability comes from a precise sentence structure that the compiler can validate.
  • Built the compiler in Go, with Lyger analyzing source and emitting Assembly Markup Language (AML), followed by Rust code generation. The CLI assembles a Cargo workspace to build the native orchestrator, App binaries, and App-owned Service libraries.
  • Implemented process orchestration around ordered source execution. Apps run as separate OS processes, with explicit launch and wait operations and access to their results.
  • Created the CLI, native release workflow, and documentation, covering installation, first programs, the language specification, compiler internals, and the evidence behind examples.

The diagrams above come from the official internals documentation and show the compilation and process boundaries. App-owned Service libraries are build artifacts; a standalone Service declaration remains a structural value and does not start a process.

Outcome and current scope

L's first public release includes native tooling for Apple Silicon macOS and Linux on ARM64 and x86-64. A compiled program can run without L or the Go and Rust toolchains installed, with its companion .apps directory alongside the executable. The first-program walkthrough takes a small source file through that build-and-run flow.

The project is in early development. The current release uses English language resources, and compatibility is not guaranteed before version 1.0. The specification documents the supported language surface; broader features such as cross-compilation and in-code concurrency remain outside the current release.

Tech (high-level)

Go · Rust · Cargo · Assembly Markup Language · Compiler design · Native process orchestration