Skip to main content
Back to Beauty Index

Lua vs Gleam

Practical 38/60
vs
Handsome 47/60
Overlay radar chart comparing Lua and Gleam across 6 dimensions Φ Ω Λ Ψ Γ Σ
Lua
Gleam
Download comparison image

Lua

The compact Swiss army knife that fits in any pocket. Lua is so small and embeddable that it powers everything from World of Warcraft to nginx configs without anyone noticing.

Gleam

The new kid who showed up and immediately made the honor roll. Still young — hit 1.0 in 2024 — but already the number-two most admired language. No null, no exceptions, no implicit behavior. Radical simplicity as philosophy.

Gleam scores 47/60 against Lua's 38/60, leading in 6 of 6 dimensions. Gleam dominates the aesthetic, mathematical, human, and design axes. Read the comparison through Practitioner Happiness first: Gleam wins that axis by 3 points over Lua, and it is the single best lens on the pair.

See also: PHP vs Gleam , Lua .

Dimension-by-dimension analysis

Ψ Practitioner Happiness

Lua 6 · Gleam 9

Gleam wins Practitioner Happiness by 3 points — a real happiness advantage. Stack Overflow's #2 "Most Admired" at 70%. For a language that hit 1.0 in 2024, the community love is extraordinary. The compiler's error messages are famously friendly. The practitioner experience on Gleam is simply more fun, day in and day out, than on Lua. Appreciated by game developers and embedded systems programmers. The embedding experience is seamless. But as a standalone language, the ecosystem is thin and the community is niche. The winner here invites the next generation of contributors without asking them to earn it first.

Σ Conceptual Integrity

Lua 7 · Gleam 9

Gleam wins Conceptual Integrity by 2 points — a decisive philosophical edge. "Radical simplicity." Every feature omission is a deliberate design statement. Louis Pilfold's vision is crystal clear: a language where the right thing is the only thing. Few languages this young have this much conceptual integrity. Gleam speaks with a single design voice; Lua speaks with a committee. "Small, fast, embeddable." Lua knows exactly what it is and stays in its lane. The design is coherent and focused. Docked slightly because the minimalism is more pragmatic than philosophical — it's simple because it needs to be small, not because simplicity is the point. The winner's philosophical discipline is what keeps its idioms stable as the language evolves.

Γ Organic Habitability

Lua 7 · Gleam 8

Gleam edges Lua by a single point on Organic Habitability; the practical difference is slim but real. No null, no exceptions, no implicit behavior means fewer surprises as codebases grow. The radical simplicity is itself a growth-point philosophy, less to go wrong, more room to extend. The habitability edge is slim and often dominated by team culture rather than language choice. Lua's tiny footprint and simple embedding API make it exceptionally habitable in its niche, you can drop it into any C/C++ project. Metatables allow organic extension. Code accommodates change well within its scope. For application codebases the habitability edge determines whether a project survives its second rewrite.

Λ Linguistic Clarity

Lua 6 · Gleam 7

Gleam edges Lua by a single point on Linguistic Clarity; the practical difference is slim but real. Explicit, predictable, and readable. Every value is named, every path is visible. Not as fluent as Ruby or Elixir in "reads-like-prose" terms, but the absence of magic makes intent self-evident. Both Lua and Gleam communicate their intent without heroic effort; Gleam is only a little more forgiving. Lua reads simply and directly for small scripts. The table-as-everything paradigm is clear once understood. Docked because the lack of distinct data structures (no arrays, no classes, just tables) can make larger codebases harder to read. In high-level work, readable code is the difference between a 6-month onboarding and a 6-week one.

Ω Mathematical Elegance

Lua 5 · Gleam 6

Gleam edges Lua by a single point on Mathematical Elegance; the practical difference is slim but real. Deliberately simple, no higher-kinded types, no advanced abstractions. Gleam trades mathematical power for clarity. The design is intentional, but it limits the ceiling for algorithmic elegance compared to Haskell or OCaml. Gleam nudges ahead, but Lua is capable of the same expressive heights in the hands of a confident user. Lua is deliberately simple. Tables as the single data structure are elegant in concept, but the language doesn't provide tools for abstract mathematical expression. Practical economy rather than mathematical economy. The winner lets the author think in algorithms rather than in ceremony.

Φ Aesthetic Geometry

Lua 7 · Gleam 8

Gleam edges Lua by a single point on Aesthetic Geometry; the practical difference is slim but real. Clean syntax with no semicolons, no null, no exceptions. The visual layout is consistent and uncluttered. Gleam code has the proportional clarity of a well-organized document. Both Lua and Gleam care about how code looks — they simply draw the line in slightly different places. Lua's minimal syntax, function, end, local, tables, creates clean, visually proportional code. The lack of punctuation noise gives it a quiet, uncluttered feel. Small but well-composed. In a language where expressiveness is the selling point, visual calm amplifies the advantage.

Code comparison

The characteristic code snippet that best represents each language.

Lua 
local Vector = {}
Vector.__index = Vector


function Vector.new(x, y)
  return setmetatable({x = x, y = y}, Vector)
end


function Vector:length()
  return math.sqrt(self.x^2 + self.y^2)
end


function Vector.__add(a, b)
  return Vector.new(a.x + b.x, a.y + b.y)
end
Gleam 
pub fn main() {
  "Hello, Joe!"
  |> string.uppercase
  |> io.println
}

Embedding expressions and variables within string literals.

Lua 
local name = "Lua"
local version = 5.4


local msg = string.format("Hello, %s! Version: %.1f", name, version)
local concat = "Hello, " .. name .. "! Version: " .. version


print(string.format("%-10s | %5.1f", name, version))
Gleam 
import gleam/int
import gleam/string


let name = "Gleam"
let version = 1


let msg = "Hello, " <> name <> "! Version: " <> int.to_string(version)


let multi = string.concat([
  "Welcome to ", name, ".\n",
  "Version: ", int.to_string(version),
])

For/while iteration patterns and loop constructs.

Lua 
for i = 1, 10 do
    print(i)
end


for index, value in ipairs(items) do
    print(index .. ": " .. value)
end


local total = 0
while total < 100 do
    total = total + 10
end
Gleam 
import gleam/list
import gleam/io


pub fn print_items(items: List(String)) {
  list.each(items, fn(item) { io.println(item) })
}


pub fn sum(items: List(Int)) -> Int {
  list.fold(items, 0, fn(acc, n) { acc + n })
}

Frequently asked questions

Which is easier to learn, Lua or Gleam?
Gleam scores 9 on Practitioner Happiness versus Lua's 6. Stack Overflow's #2 "Most Admired" at 70%. For a language that hit 1.0 in 2024, the community love is extraordinary. The compiler's error messages are famously friendly. For a developer adding a new language to their toolbelt, the happier one is the one you will still be writing in six months.
Is Lua or Gleam better for developer happiness?
For developer happiness, Gleam has a clear edge — it scores 9/10 on Practitioner Happiness against Lua's 6/10. Stack Overflow's #2 "Most Admired" at 70%. For a language that hit 1.0 in 2024, the community love is extraordinary. The compiler's error messages are famously friendly.
Should I pick Lua or Gleam in 2026?
Lua lands in the practical tier at 38/60; Gleam in the handsome tier at 47/60. The gap is wide. Unless a specific platform or ecosystem constraint forces the other choice, go with the higher-scoring language. The score difference reflects years of community use, tooling maturity, and the editorial judgment of the Beauty Index rubric.

Related comparisons

Read the methodology →