Back to the Drawing Board: Strengthening the Foundations of Luma

Sometimes the best way forward is a few steps back — especially when building something as intricate and expressive as a programming language.

Over the past weeks, we’ve been shaping Luma, our small, readable, and expressive scripting language. Progress has been exciting: we’ve supported basic types, function calls, collections, and even interpolated strings. But then came lambdas — and everything began to wobble.

Lambdas Exposed a Cracked Foundation

Implementing lambda expressions (x -> x + 1) seemed straightforward at first, but as we integrated them deeper into our parser, problems started surfacing. Adding lambdas triggered a cascade of subtle bugs. Functionality we thought was solid — like parsing chained method calls or indexing expressions — began to break.

It became clear: our parser wasn’t built to evolve safely. There were too many assumptions, too few guards, and not enough test coverage.

Starting Over — with Confidence

The goal hasn’t changed: we still want Luma to be a simple yet expressive language that feels intuitive to write and understand. But to reach that vision, the internals must be as elegant and robust as the surface syntax.

From here, we’re taking measured steps. We’re not rushing features — we’re establishing a solid, testable foundation so Luma can grow without regressions or surprises.

What’s Next?

We’re continuing to:

• Rewrite the parser with clear responsibilities

• Expand our test suite with real-world examples

• Support core constructs like lambdas, conditionals, functions, and collections in a sustainable way

We believe this phase will pay off — not just for us as developers, but for everyone who writes Luma in the future.

Thanks for following along. The best is still ahead.