Luma documentation

Luma documentation

A Small, Friendly Programming Language Designed for Learning and Clarity

Created by Guido Gröön

Luma is a modern, minimal, expressive programming language built with a single purpose:

Help people understand programming more clearly - not confuse them with unnecessary complexity.

Whether you are taking your first steps in coding or coming from another language looking for something more elegant and safe, Luma provides a clean, beginner-friendly environment that stays powerful enough for real problem-solving.

Why Luma?

Most programming languages grow over decades, accumulating exceptions, historic quirks, and confusing features.

Luma takes the opposite approach:

  • Start small.
  • Grow thoughtfully.
  • Prioritize readability and predictability.

Luma is not trying to be the fastest, or the biggest, or the most clever language. Instead, it focuses on being:

  • Safe - fewer footguns, fewer surprises
  • Consistent - same patterns everywhere
  • Understandable - clear data types, clear rules
  • Friendly - great for learning and teaching
  • Useful - built on top of Go for real execution speed

It’s a language that feels good to write.

Perfect for Students & New Programmers

Many languages hide their logic behind syntax, clever tricks, or magic behavior. Luma deliberately avoids this.

Students using Luma will learn:

  • How variables work
  • What data types really are
  • Optional values and nil
  • Lists, maps, iteration
  • Basic functional ideas (lambdas, walk/filter)
  • Functions with explicit signatures
  • Clear execution flow
  • Type-safe arithmetic
  • How real languages parse, compile, and run

Instead of learning a giant language, students learn concepts that stay valid no matter what language they use next.

A Clean, Minimal Core

Luma includes just the essential building blocks:

Primitive Types

int, float, str, bool, byte

Optional Types

?int, ?str - designed for safe handling of “maybe” values

Lists, Maps & Sets

  • .walk(...)
  • .filter(...)
  • .add, .remove, .intersect, .sort, etc.

Interpolated Strings

Readable formatting:

print("Hello ${name}, age ${age}")

Functions

Readable, explicit function definitions:

fn add(a: int, b: int) -> int {
    return a + b
}

fn greet(name: str) -> str => "Hello, ${name}!"

Lambdas

Lightweight inline expressions:

nums.filter(x -> x > 0)

Safe Arithmetic

Automatic int/float coercion without surprises.

Powered by a Modern Compiler

Luma is not an interpreter. Your source code is parsed, checked, and compiled into real Go, then executed at native speed.

This gives you:

  • fast runtime performance
  • strong type checking
  • real error messages
  • a clear, transparent compilation model

Luma’s core is open and readable - an excellent learning resource itself.

Design Philosophy

Luma is based on a few simple principles:

1. Clarity Over Cleverness

No ambiguous symbols. No hidden casts. No implicit magic.

2. Safety by Default

Optionals, nil-checks, explicit types - Luma avoids “billion-dollar mistakes”.

3. Consistency Everywhere

The same patterns work across primitives, lists, maps, functions.

4. Minimal Syntax

If something can be expressed in a clean way, it should be.

5. A Language You Can Understand Fully

You don’t need 500 pages of documentation. The core language is small enough to learn in a weekend.

Who Is Luma For?

Students learning programming
Clear syntax, no footguns, no legacy baggage.

Teachers who want a clean teaching language
Great for assignments, lessons, and explaining concepts.

Developers who value simplicity
A refreshing alternative to bloated ecosystems.

Language enthusiasts
If you enjoy language design, Luma is compact, experimental, and fun to explore.

Anyone who wants to understand compilers
The Luma compiler is intentionally readable and educational.

Where Luma Is Going

Luma grows carefully and steadily. Recent additions include:

  • Structs, traits, and impl blocks
  • Multi-file modules and imports
  • Web server with routes, middleware, and JSON responses
  • File I/O, JSON, and CLI support
  • Date, time, and datetime types
  • Sets with union, intersect, and difference

Planned features:

  • Function closures
  • Pattern matching
  • Generics (later, not rushed)

Everything is added only if it fits Luma’s core philosophy.

Try Luma

Use the online playground: https://luma.crowned-phoenix.com/

Or install the CLI from the repository and start writing .luma files.

About the Author

Luma is created by Guido Gröön, who designed it with the goal of building a programming language that is:

  • friendly
  • educational
  • practical
  • and enjoyable to work with

The language reflects a love for clean design, simplicity, and the joy of teaching and learning.

Last updated on