Most programming language documentation is a reference manual: it tells you the syntax and leaves you to figure out the ideas. Lale deliberately does the opposite. Its documentation is written to teach, and to teach the general concepts of computing, not just one language.

This is a design decision, not an accident, and it shows up in three places.

1. A grammar that reduces cognitive load

The language itself is shaped for people who are not already expert programmers.

There is exactly one looping construct, loop, which replaces for, while, and do-while: 

// Similar to a for loop in many languages
loop var i as i32 from 1 to 10
    write i
end loop

// A loop with an exit condition
i = 4
loop
    write i
    i += 1
end loop when i > 5

// A loop with both entering and exit conditions
loop when i > 5
    write i
    i += 1
end loop when i > 7

// Infinite loop. Keeps repeating
loop
    write "Hello"
end loop

A beginner does not have to memorize three different keywords and the historical differences between them. They learn the single idea that matters: a loop may have a condition to enter and/or a condition to exit. The same instinct runs through the whole language. Operators read as English (bitwise and, has value, value of), and arrays start at 1, matching the convention in mathematics rather than the convention in C.

2. Documentation that explains the words it uses

Lale has an explicit documentation philosophy: specialist terms are introduced in plain language first, and the formal term follows. The user guide is written for a high-school student. The architecture document is written for a technically capable reader who has never studied compiler construction.

That is not marketing. It is enforced. When the architecture document explains the compiler, it does not say "Lale lowers to SSA and performs mem2reg." It says:

The compiler converts the program into static single assignment (SSA) form. In SSA, each variable is assigned exactly once. … mem2reg moves values out of memory into registers, and DSE is dead-store elimination.

The reader is taught what an intermediate representation is, why a compiler wants one, and why a pointer to a local variable must not escape a function — as general knowledge, with Lale as the concrete example.

3. An open implementation you can follow along

The compiler is small enough and documented well enough that the documentation doubles as a curriculum. You can read how source becomes a parse tree, how the parse tree becomes an intermediate representation, and how that representation is executed — with each stage explained in prose rather than left as an opaque box.

A student who reads the documentation does not just learn Lale. They learn what a parser is, what a symbol table is, what an ABI is, and why compilers care about memory safety — the kind of knowledge that normally sits behind a textbook or a course.

Why this matters

The project even cites peer-reviewed research on cognitive load in novice programming, because the goal is specific: lower the barrier between a curious person and a working understanding of how computers actually work.

Funding this is funding human capital, not just a compiler. A language whose documentation teaches the underlying ideas is a piece of public infrastructure: it can take someone from "I can write a loop" to "I understand what the machine is doing" without the tuition bill.

That is the claim, and the repository already backs it up.