en
Gleam en 2026: El Lenguaje Tipado para BEAM que Combina Ideas de Elixir y Rust
development

Gleam en 2026: El Lenguaje Tipado para BEAM que Combina Ideas de Elixir y Rust

Guía técnica del lenguaje de programación Gleam en 2026 (v1.19): tipado estático en la máquina virtual BEAM, compilación a JavaScript, Wisp/Lustre y vs Elixir y Rust.

Y
Yan ZC
Publicado: October 12, 2026

Durante décadas, los arquitectos de software y desarrolladores backend tuvieron que aceptar una disyuntiva técnica difícil. Si buscabas la concurrencia masiva, la tolerancia a fallos en tiempo real suave y los árboles de supervisión autorreparables de la máquina virtual de Erlang (BEAM), debías asumir el tipado dinámico de Erlang o Elixir. Por el contrario, si exigías garantías estrictas en tiempo de compilación, tipos de datos algebraicos (ADT) e inferencia estilo ML sin errores de tipo null, tenías que abandonar el ecosistema BEAM y recurrir a lenguajes como Rust, OCaml o Haskell.

El lenguaje de programación Gleam elimina por completo ese compromiso. Creado por Louis Pilfold y respaldado por una comunidad de código abierto en rápido crecimiento y patrocinadores industriales, Gleam lleva un verificador de tipos estático ultrarrápido —escrito en Rust y con inferencia completa Hindley-Milner— directamente al runtime BEAM de Erlang, además de compilar de forma nativa a JavaScript moderno (ECMAScript 2022+) con declaraciones de tipos para TypeScript.

En octubre de 2026, tras el lanzamiento de Gleam v1.19.0 y v1.19.2, el lenguaje ha alcanzado un nuevo hito de madurez en su compilador: ahora compila directamente a formas abstractas binarias de Erlang (Erlang abstract forms) en lugar de generar archivos intermedios .erl en texto plano, ofrece soporte oficial para Erlang/OTP 29 e impulsa más de 1.690 paquetes a través de frameworks como Wisp, Mist y Lustre.

En esta guía técnica analizamos la arquitectura interna de Gleam, su sistema de tipos y modelo de actores OTP, su comparativa real frente a Elixir (incluyendo el sistema de tipos graduales de Elixir v1.20) y Rust, ejemplos de código verificados en el compilador real, y cuándo elegir —o evitar— Gleam en producción.


Veredicto Rápido: Gleam de un Vistazo (Octubre 2026)

Atributo Detalles Técnicos Verificados (Octubre 2026)
Creador y Gobernanza Creado por Louis Pilfold; código abierto (Apache-2.0), patrocinado por LambdaClass, NineFX y la comunidad
Última Versión Estable Gleam v1.19.2 (12 de octubre de 2026) / v1.19.0 (5 de octubre de 2026); la versión 1.0 se publicó el 4 de marzo de 2024
Implementación del Compilador Escrito en Rust (distribuido como un único binario nativo sin dependencias que incluye compilador, gestor de paquetes, formateador y servidor LSP)
Targets de Compilación BEAM VM (mediante formas abstractas binarias de Erlang sobre OTP 28 y 29) y JavaScript (módulos .mjs ES2022+ y definiciones .d.ts de TypeScript)
Sistema de Tipos Estático, seguro en código Gleam puro, inferencia Hindley-Milner, tipos de datos algebraicos (Custom Types), genéricos, sin null/nil
Manejo de Errores Explícito y basado en valores mediante Result(value, error) y Option(a) — sin excepciones no verificadas en código Gleam puro
Modelo de Concurrencia Procesos ligeros aislados en BEAM (actores), canales tipados Subject(msg) y árboles de supervisión OTP (gleam_otp)
Ecosistema de Paquetes 1.690 paquetes en packages.gleam.run + interoperabilidad total con decenas de miles de paquetes Erlang y Elixir en Hex.pm
Frameworks Principales Wisp (framework web), Mist (servidor HTTP/2 y WebSockets en Gleam puro), Lustre (SPA estilo Elm, SSR y Server Components), Pog (PostgreSQL)

1. ¿Qué es el Lenguaje de Programación Gleam?

Gleam es un lenguaje de programación puramente funcional y de tipado estático diseñado para construir sistemas escalables y tolerantes a fallos. Su diseño combina tres grandes tradiciones de la ingeniería de software:

  1. El Runtime Erlang/OTP (BEAM): Al igual que Erlang y Elixir, Gleam se ejecuta como ciudadano de primera clase sobre la máquina virtual BEAM, heredando procesos ligeros con planificación apropiativa (preemptive scheduling), recolección de basura independiente por proceso y tolerancia a fallos OTP.
  2. Sistemas de Tipos de Rust y la Familia ML: Inspirado en Rust, Elm y OCaml, Gleam aplica seguridad de tipos estricta en tiempo de compilación mediante tipos de datos algebraicos, pattern matching exhaustivo e inferencia de tipos completa, por lo que rara vez necesitas escribir anotaciones de tipos manuales salvo para documentar tus APIs públicas.
  3. Simplicidad Radical del Lenguaje (Filosofía Go/Elm): Gleam evita deliberadamente la complejidad innecesaria. No existen macros, no hay typeclasses ni traits, no hay conversiones implícitas de tipos, no hay sobrecarga de métodos y no existen excepciones. Un desarrollador con experiencia en TypeScript, Rust o Elixir puede aprender toda la sintaxis de Gleam en una sola tarde a través del Tour Interactivo de Gleam.

Sitio web oficial del lenguaje de programación Gleam mostrando a la mascota Lucy y un ejemplo minimalista de código El sitio oficial de Gleam (gleam.run) resume su propuesta central: unir la potencia de un sistema de tipos estático con la fiabilidad concurrente del runtime de Erlang.


2. Por Qué Gleam Importa en 2026: Hitos Técnicos y Adopción

Cuando Gleam 1.0 vio la luz en marzo de 2024, muchos equipos lo vieron como un experimento prometedor. A finales de 2026, Gleam se ha consolidado como una alternativa de producción madura para arquitecturas backend y full-stack:

  • Máxima Satisfacción entre Desarrolladores: En la encuesta global de Stack Overflow, Gleam se posicionó como el segundo lenguaje de programación más admirado del mundo (70%), solo por detrás de Rust (72%) y superando ligeramente a Elixir (66%).
  • El Salto Arquitectónico de Octubre de 2026 (Gleam v1.18 – v1.19.2): El 5 de octubre de 2026, el equipo oficial anunció un cambio profundo en Gleam v1.19.0 (“Gleam doesn’t compile to Erlang source anymore”). Anteriormente, Gleam traducía los archivos .gleam a archivos de código fuente .erl antes de invocar al compilador de Erlang. Desarrollado por Giacomo Cavalieri, el nuevo generador de código emite directamente formas abstractas de Erlang (Erlang abstract forms) codificadas en el formato binario externo de términos de Erlang, exactamente la misma representación intermedia (IR) que utiliza Elixir.
  • Ventajas Reales de las Formas Abstractas Binarias: Al omitir el tokenizador y el parser de texto del compilador de Erlang, Gleam compila mucho más rápido y conserva los nombres de archivo .gleam y números de línea exactos en las trazas de error (stacktraces) de BEAM y en depuradores modernos como edb de WhatsApp.
  • Soporte Oficial para Erlang/OTP 29 y Optimización JavaScript: Desde las versiones v1.18+ y v1.19.2, Gleam soporta oficialmente Erlang/OTP 29 y OTP 28, mientras que la optimización de código JavaScript introducida por John Downey en v1.19.0 aplana las comprobaciones de pattern matching en condiciones if combinadas, generando módulos .mjs más compactos y rápidos.
  • Casos de Estudio en Producción: Empresas como Uncover (plataformas de inteligencia legal desarrolladas a alta velocidad por equipos compactos) y Strand han publicado casos de estudio oficiales destacando cómo el compilador de Gleam elimina regresiones enteras al refactorizar dominios complejos.

3. Arquitectura y Compilación Dual: Máquina Virtual BEAM y JavaScript

Una de las mayores fortalezas de ingeniería de Gleam es su arquitectura de compilación multi-target. Escrito en Rust para ofrecer tiempos de compilación casi instantáneos, el binario gleam analiza tu código en un Árbol de Sintaxis Abstracta (AST), ejecuta la inferencia de tipos Hindley-Milner y el análisis de exhaustividad, y finalmente traduce el AST validado al entorno de ejecución elegido.

flowchart LR
    subgraph Source["1. Código Fuente y Verificador de Tipos"]
        A["Archivos .gleam"] --> B["Compilador Gleam (Rust)<br/>Lexer, Parser y AST"]
        B --> C["Inferencia Hindley-Milner<br/>y Verificación de Exhaustividad"]
    end

    subgraph BEAMTarget["2A. Target Erlang / BEAM (Por Defecto)"]
        C --> D["Formas Abstractas de Erlang<br/>(Formato Binario de Términos)"]
        D --> E["Bytecode BEAM (.beam)<br/>vía Compilador Erlang (OTP 28/29)"]
        E --> F["Máquina Virtual BEAM<br/>Actores, Supervisores OTP, Hex.pm"]
    end

    subgraph JSTarget["2B. Target JavaScript (--target javascript)"]
        C --> G["JavaScript ES2022+ (.mjs)<br/>+ Declaraciones TypeScript (.d.ts)"]
        G --> H["Runtimes JavaScript<br/>Node.js, Deno, Bun, Navegadores, Edge"]
    end

Target 1: La Máquina Virtual BEAM de Erlang (Por Defecto)

Cuando compilas para Erlang/BEAM, Gleam transforma tus módulos en archivos ejecutables .beam mediante formas abstractas binarias. Tu código se ejecuta dentro de la misma instancia de la máquina virtual que cualquier módulo de Erlang o Elixir con cero sobrecarga de serialización, obteniendo acceso inmediato a:

  • Planificación Apropiativa (Preemptive Scheduling): A diferencia de Node.js (basado en un bucle de eventos cooperativo de un solo hilo), el planificador de BEAM asigna a cada proceso un presupuesto fijo de reducciones (aproximadamente 4.000 llamadas a funciones) antes de pausarlo y ceder la CPU a otro proceso. Una petición lenta o un cálculo intensivo jamás puede bloquear el resto del servidor.
  • Recolección de Basura por Proceso: Cada proceso BEAM posee su propio heap privado de memoria. Cuando un proceso que atiende una petición HTTP termina, su memoria se libera al instante sin provocar pausas globales (stop-the-world GC) en el servidor.

Target 2: JavaScript Moderno (ECMAScript 2022+)

Al ejecutar --target javascript (o definir target = "javascript" en gleam.toml), Gleam compila exactamente el mismo código .gleam a módulos ES2022 legibles (.mjs) acompañados opcionalmente de archivos de definición .d.ts para TypeScript.

  • No se carga ninguna máquina virtual pesada en el navegador: los tipos de Gleam se traducen limpiamente a clases ligeras y arreglos nativos de JavaScript.
  • Esto permite compartir modelos de dominio, validaciones, decodificadores JSON y máquinas de estados entre un backend Wisp/Mist sobre BEAM y un frontend Lustre en el navegador, o desplegar aplicaciones Gleam directamente en Cloudflare Workers, Deno, Bun o Node.js.

4. Sistema de Tipos Estático, Inferencia Hindley-Milner y Manejo de Errores

Si alguna vez has recibido una alerta de producción a las 3:00 AM porque una función de Elixir devolvió {:error, :timeout, metadata} cuando el código llamador solo hacía pattern matching sobre {:error, reason}, o porque una propiedad en JavaScript resultó ser undefined, ya conoces de primera mano el problema que resuelve Gleam.

Inferencia Completa en Tiempo de Compilación

Gleam implementa un sistema de tipos basado en Hindley-Milner. Cada expresión tiene un tipo estático conocido en tiempo de compilación, pero el compilador deduce automáticamente los tipos a partir de cómo se utilizan los valores. En la práctica, los desarrolladores de Gleam anotan las firmas de las funciones públicas como documentación clara y dejan que el compilador infiera todas las variables locales y funciones anónimas.

Tipos de Datos Algebraicos (Custom Types) y Genéricos

Gleam modela la lógica de negocio mediante Custom Types (uniones etiquetadas o tipos suma). En lugar de dispersar banderas booleanas (is_paid, is_refunded, has_error) en un objeto mutable —lo que permite estados incoherentes—, defines variantes explícitas que contienen únicamente los datos válidos para ese estado.

Cero null, Cero undefined y Cero Excepciones Ocultas

En Gleam no existe null ni nil. Si un valor puede estar ausente, utilizas el tipo estándar Option(a) (Some(value) o None).

Del mismo modo, Gleam no utiliza bloques try / catch para el flujo de control. Cualquier función que pueda fallar devuelve el tipo integrado Result(value, error):

pub type Result(value, error) {
  Ok(value)
  Error(error)
}

Dado que error también está tipado, la firma de cada función documenta exactamente qué errores de negocio pueden ocurrir, y el compilador obliga a gestionar tanto la rama Ok como la rama Error antes de permitir que el programa compile.


5. Programación Funcional, Inmutabilidad y Pattern Matching Exhaustivo

Todos los valores en Gleam son profundamente inmutables. Cuando actualizas un registro o añades un elemento a una lista, Gleam crea una nueva referencia que reutiliza las estructuras de memoria no modificadas del valor original (compartición estructural). Esto elimina de raíz las condiciones de carrera sobre memoria compartida.

Características Ergonómicas Clave en Gleam

  1. El Operador Pipe (|>): Inspirado en Elixir y F#, el operador |> pasa el resultado de una expresión como argumento a la siguiente función, transformando llamadas anidadas difíciles de leer como formatear(validar(parsear(raw))) en una tubería lineal de arriba hacia abajo.
  2. Pattern Matching Exhaustivo con case: La expresión case inspecciona valores, desestructura tuplas, listas, cadenas o arreglos de bits (BitArrays), y admite cláusulas de guarda (if). Si seis meses después añades una nueva variante a un Custom Type, el compilador señalará inmediatamente cada expresión case en todo tu proyecto que aún no contemple ese nuevo caso.
  3. La Expresión use (Aplanamiento de Callbacks y Errores): Los bloques case profundamente anidados se aplanan en Gleam mediante la palabra clave use. Combinar use con result.try permite escribir flujos de validación con retorno temprano (equivalente al operador ? de Rust o al bloque with de Elixir) sin excepciones ni sintaxis monádica compleja.

6. Modelo de Actores, Concurrencia y Tolerancia a Fallos (OTP)

Aunque la máquina virtual BEAM proporciona las primitivas de concurrencia (spawn, send, receive), el paso de mensajes nativo en Erlang no tiene tipos: cualquier proceso con un Pid (Process Identifier) puede enviar cualquier término arbitrario al buzón (mailbox) de otro proceso.

Tipar actores concurrentes es un desafío clásico en ciencias de la computación. Gleam lo resuelve de forma pragmática mediante sus paquetes oficiales gleam_erlang y gleam_otp utilizando canales tipados Subject(message).

flowchart TD
    subgraph Supervision["Proceso Supervisor OTP (Estático / Dinámico)"]
        Sup["Supervisor OTP<br/>Estrategia de Reinicio: OneForOne"]
    end

    subgraph Client["Proceso Cliente (ej. Controlador HTTP Wisp)"]
        Req["Proceso de Petición HTTP"]
    end

    subgraph Worker["Proceso Actor Aislado en Gleam"]
        Subj["Subject(PaymentMsg) Tipado<br/>Canal Verificado en Compilación"]
        Mailbox["Buzón del Proceso (Mailbox)<br/>Cola Secuencial de Mensajes"]
        Loop["Bucle del Actor<br/>Estado Inmutable + Pattern Matching"]
        Subj --> Mailbox --> Loop
    end

    Req -- "actor.call / actor.send<br/>Solo Admite PaymentMsg" --> Subj
    Loop -- "Respuesta Tipada vía Subject" --> Req
    Sup -. "Monitoriza y Reinicia Automáticamente<br/>el Proceso Aislado ante Fallos" .-> Loop

Cómo Funcionan los Actores Tipados en Gleam

  1. Protocolo de Mensajes Explícito: Defines un Custom Type que representa todos los mensajes válidos que el actor puede recibir (por ejemplo, pub type CacheMessage { Get(key: String, reply_with: Subject(Option(String))) Set(key: String, value: String) }).
  2. Canales Subject Tipados: En lugar de enviar mensajes a un Pid sin tipo, los clientes envían mensajes a través de un Subject(CacheMessage). El compilador de Gleam garantiza que ningún código Gleam puro pueda enviar un mensaje incompatible a ese actor.
  3. Árboles de Supervisión y “Let It Crash” con Tipos Estáticos: Una duda frecuente es: “Si Gleam tiene tipado estático y no usa excepciones, ¿por qué siguen siendo necesarios los supervisores OTP?” La respuesta está en la diferencia entre errores lógicos de programación y fallos de infraestructura externa. El tipado estático elimina los errores lógicos (UndefinedFunctionError, valores nil inesperados, casos no contemplados) antes de desplegar. Sin embargo, en sistemas distribuidos reales, los sockets TCP se cortan, las bases de datos se reinician y las APIs de terceros sufren caídas. Cuando un actor aislado de Gleam encuentra un fallo externo irrecuperable, su Supervisor OTP termina limpiamente ese único proceso, restablece su estado a un punto seguro conocido y lo reinicia en microsegundos, sin afectar a los miles de usuarios concurrentes conectados al mismo nodo.

7. Interoperabilidad con Erlang, Elixir y JavaScript (y Riesgos en la Frontera FFI)

Dado que Gleam compila a bytecode estándar de BEAM (y a módulos ES en JavaScript), no necesita reinventar la rueda. Puedes aprovechar todo el ecosistema Hex.pm (paquetes de Erlang y Elixir) o npm mediante el atributo @external de Gleam.

Llamar a Erlang, Elixir o JavaScript desde Gleam

Con un solo atributo puedes enlazar una función externa a una firma fuertemente tipada en Gleam, e incluso proporcionar implementaciones tanto para Erlang como para JavaScript en la misma función:

// Usa :crypto.strong_rand_bytes de Erlang en BEAM,
// o delega a un módulo JS cuando se compila a JavaScript
@external(erlang, "crypto", "strong_rand_bytes")
@external(javascript, "./crypto_ffi.mjs", "strong_rand_bytes")
pub fn random_bytes(count: Int) -> BitArray

Llamar a Gleam desde Elixir o Erlang

Un módulo de Gleam llamado billing/invoice se compila al módulo BEAM :billing@invoice. Desde una aplicación Elixir/Phoenix puedes invocar :billing@invoice.calculate_total(items) directamente como si fuera un módulo nativo de Erlang.

Advertencia Técnica: El Riesgo en la Frontera FFI

Todo equipo de ingeniería debe comprender dónde terminan las garantías del compilador: Gleam confía ciegamente en las anotaciones de tipos que escribas en @external.

  • Si anotas que una función externa de Erlang devuelve String, pero en tiempo de ejecución devuelve el átomo :undefined o lanza una excepción nativa de Erlang (erlang:error/1), el verificador estático de Gleam no podrá impedirlo.
  • Buena Práctica: Nunca enlaces funciones externas no confiables directamente a tipos complejos de Gleam. En su lugar, recibe los datos externos, payloads JSON o filas de base de datos como gleam/dynamic.Dynamic y valídalos en la frontera usando el módulo oficial gleam/dynamic/decode, el cual devuelve de forma segura un Result tipado.

8. Comparativa Técnica: Gleam vs. Elixir vs. Rust vs. Erlang vs. TypeScript

Para ubicar a Gleam dentro del panorama backend de 2026 —especialmente si estás evaluando arquitecturas en nuestra guía de Mejores Frameworks Backend o comparando Django vs. FastAPI— conviene contrastar sus decisiones de diseño frente a Elixir, Rust, Erlang y TypeScript.

Gleam vs. Elixir en 2026 (Incluyendo el Sistema de Tipos Graduales de Elixir v1.20)

Históricamente, la diferencia entre Elixir y Gleam se resumía en tipado dinámico frente a tipado estático. Sin embargo, en junio de 2026, Elixir v1.20 incorporó inferencia de tipos completa y verificación gradual basada en tipos conjuntistas (set-theoretic types) sin requerir anotaciones. ¿En qué se diferencian hoy?

  • Elixir v1.20 (Tipos Graduales Conjuntistas + Metaprogramación): Elixir sigue siendo un lenguaje dinámico en su núcleo que ahora cuenta con un potente analizador de tipos en compilación y un tipo dynamic() de escape. Elixir apuesta fuertemente por macros AST, protocolos y DSLs expresivos que hacen posibles frameworks integrales como Phoenix, Phoenix LiveView, Ecto y Oban.
  • Gleam v1.19 (Tipos Estáticos Estrictos Hindley-Milner + Cero Macros): Gleam fue diseñado desde cero como un lenguaje estrictamente tipado. No tiene macros, ni inyección oculta de código, ni conversiones dinámicas implícitas. Refactorizar un modelo de dominio de 50.000 líneas en Gleam ofrece la misma seguridad determinista que Rust: el compilador te guía archivo por archivo hasta que todo encaja. A cambio, el ecosistema web de Gleam (Wisp + Mist + Lustre) es intencionalmente explícito y modular, en lugar de un framework monolítico con generadores mágicos como Phoenix.

Gleam vs. Rust

  • ADN Compartido: Tanto Gleam como Rust comparten tipos de datos algebraicos (enum / Custom Types), pattern matching exhaustivo (match / case), manejo de errores mediante Result<T, E>, ausencia de null y un compilador sumamente claro.
  • Diferencia Clave: Rust es un lenguaje de programación de sistemas con gestión manual de memoria mediante ownership, lifetimes y borrow checker, ofreciendo rendimiento a nivel de C/C++ sin recolector de basura a cambio de una curva de aprendizaje pronunciada. Gleam se ejecuta sobre una máquina virtual con recolector de basura (BEAM o JS) con datos inmutables y sin borrow checker, lo que permite desarrollar APIs web intensivas en I/O, sistemas en tiempo real y lógica de negocio con mucha mayor velocidad de entrega, reservando Rust para cargas intensivas de CPU.

Tabla Comparativa Maestra (2026)

Dimensión / Característica Gleam (v1.19) Elixir (v1.20) Erlang (OTP 29) Rust TypeScript (Node/Bun)
Sistema de Tipos Estático Estricto (Hindley-Milner + ADTs) Gradual Conjuntista (Raíz dinámica en runtime) Dinámico (Análisis opcional con Dialyzer) Estático Estricto (Ownership, Lifetimes, Traits) Estático Estructural (Borrado en runtime)
Runtime Principal BEAM VM y JavaScript BEAM VM BEAM VM Código Nativo / WebAssembly V8 / JavaScriptCore
Modelo de Concurrencia Actores BEAM Apropiativos (Subject) Procesos BEAM Apropiativos (GenServer) Procesos BEAM Apropiativos Async/Await (Tokio) o Hilos del SO Event Loop Monohilo + Workers
Gestión de Memoria GC por Proceso (BEAM) / GC V8 (JS) GC por Proceso (BEAM) GC por Proceso (BEAM) Borrow Checker en Compilación (Sin GC) GC Generacional Global
Manejo de Errores Valores Result(ok, err) + Supervisores OTP Tuplas {:ok, val} + Excepciones + Supervisores Tuplas + Excepciones + Supervisores Result<T, E> + panic! Excepciones try / catch (Sin tipar)
Metaprogramación Ninguna (Solo generación explícita) Macros AST Avanzadas (quote/unquote) Parse transforms / Macros de cabecera Macros Procedurales y Declarativas Decoradores / Plugins de build
Frameworks Web Clave Wisp, Mist, Lustre Phoenix, LiveView, Ash Cowboy, Nova Axum, Actix Web NestJS, Hono, Next.js
Curva de Aprendizaje Baja (Sintaxis mínima, sin borrow checker) Media (OTP + DSLs basados en macros) Media-Alta (Sintaxis derivada de Prolog) Alta (Lifetimes, Pin, Async traits) Baja-Media (Tipos avanzados complejos)

9. Ejemplos Prácticos de Código Gleam (Verificados en Gleam v1.19.2)

Para observar cómo interactúan los Custom Types, el pattern matching con guardas, las tuberías Result con use y la interoperabilidad @external en código real, revisa el siguiente módulo. Compilamos y verificamos exactamente este código con el compilador oficial Gleam v1.19.2 (gleam_stdlib v1.0.5).

import gleam/int
import gleam/io
import gleam/option.{type Option, None, Some}
import gleam/result
import gleam/string

/// 1. Tipos de Datos Algebraicos (Custom Types)
/// Cada variante almacena únicamente los datos válidos para ese estado.
pub type PaymentStatus {
  Pending(invoice_id: String)
  Settled(invoice_id: String, amount_cents: Int, processor_ref: String)
  Failed(invoice_id: String, reason: PaymentError)
}

pub type PaymentError {
  InvalidAmount(provided: Int)
  EmptyInvoiceId
  GatewayDeclined(code: String)
}

/// 2. Pattern Matching Exhaustivo con Guardas
pub fn describe_status(status: PaymentStatus) -> String {
  case status {
    Pending(invoice_id: id) -> "Invoice " <> id <> " is awaiting settlement."
    Settled(invoice_id: id, amount_cents: cents, ..) if cents >= 100_000 ->
      "High-value invoice " <> id <> " settled (" <> int.to_string(cents) <> " cents)."
    Settled(invoice_id: id, amount_cents: cents, ..) ->
      "Invoice " <> id <> " settled (" <> int.to_string(cents) <> " cents)."
    Failed(invoice_id: id, reason: GatewayDeclined(code)) ->
      "Invoice " <> id <> " declined by gateway: " <> code
    Failed(invoice_id: id, reason: _) ->
      "Invoice " <> id <> " failed validation."
  }
}

/// 3. Funciones Puras de Validación que Devuelven Result(value, PaymentError)
pub fn validate_invoice_id(raw_id: String) -> Result(String, PaymentError) {
  let trimmed = string.trim(raw_id)
  case string.is_empty(trimmed) {
    True -> Error(EmptyInvoiceId)
    False -> Ok(trimmed)
  }
}

pub fn validate_amount(cents: Int) -> Result(Int, PaymentError) {
  case cents > 0 {
    True -> Ok(cents)
    False -> Error(InvalidAmount(cents))
  }
}

/// 4. Aplanamiento de Tuberías de Error con la Expresión `use`
/// Equivalente al operador `?` de Rust o al bloque `with` de Elixir,
/// sin excepciones ni bloques case anidados.
pub fn settle_payment(
  raw_id: String,
  amount_cents: Int,
  processor_ref: Option(String),
) -> Result(PaymentStatus, PaymentError) {
  use valid_id <- result.try(validate_invoice_id(raw_id))
  use valid_amount <- result.try(validate_amount(amount_cents))

  let reference = case processor_ref {
    Some(ref) -> ref
    None -> "INTERNAL-LEDGER"
  }

  Ok(Settled(
    invoice_id: valid_id,
    amount_cents: valid_amount,
    processor_ref: reference,
  ))
}

/// 5. FFI Multi-Target con @external y Respaldo en Gleam Puro
/// Usa string:uppercase/1 de Erlang en BEAM, o el cuerpo en Gleam al compilar a JS.
@external(erlang, "string", "uppercase")
pub fn native_uppercase(text: String) -> String {
  string.uppercase(text)
}

pub fn main() {
  let outcome =
    settle_payment("  inv_2026_994 ", 250_000, Some("stripe_ch_8821"))
    |> result.map(describe_status)

  case outcome {
    Ok(summary) -> io.println(native_uppercase("ok: ") <> summary)
    Error(_) -> io.println("Payment could not be processed.")
  }
}

Al ejecutar gleam run, el compilador verifica todos los tipos y la exhaustividad de ramas en milisegundos y produce la siguiente salida:

OK: High-value invoice inv_2026_994 settled (250000 cents).

10. Instalación, Toolchain y Estructura de Proyecto (gleam.toml)

Uno de los aspectos más valorados por los desarrolladores es el toolchain todo-en-uno de Gleam distribuido en un único binario. A diferencia de otros lenguajes donde debes configurar por separado el compilador, el gestor de paquetes, el formateador, el ejecutor de tests y el servidor LSP, el ejecutable gleam lo integra todo de fábrica.

Portal oficial de documentación de Gleam mostrando guías de aprendizaje, referencias del lenguaje y guías de despliegue El portal oficial de documentación de Gleam (gleam.run/documentation) reúne guías paso a paso, referencias de línea de comandos, uso de código externo y hojas de referencia rápida para desarrolladores que vienen de Elixir, Rust, Python o PHP.

Paso 1: Instalar Gleam y Erlang/OTP

Para ejecutar Gleam sobre la máquina virtual BEAM, instala Gleam (v1.19+) y Erlang/OTP (28 o 29) mediante el gestor de paquetes de tu sistema o un gestor de versiones como mise o asdf:

# macOS (Homebrew - instala Erlang automáticamente como dependencia)
brew install gleam

# Windows (Winget o Scoop)
winget install Gleam.Gleam
scoop install gleam

# Gestor de versiones multiplataforma (mise)
mise use --global erlang@29 gleam@1.19.2

Paso 2: Crear y Ejecutar un Proyecto Nuevo

Con solo tres comandos puedes generar la estructura, ejecutar las pruebas y correr tu aplicación:

gleam new mi_servicio
cd mi_servicio
gleam test
gleam run

Estructura Estándar de un Proyecto Gleam

Cada proyecto de Gleam mantiene una organización limpia y predecible gobernada por el archivo gleam.toml:

Archivo o Directorio Función dentro de un Proyecto Gleam
gleam.toml Manifiesto principal que define nombre del paquete, versión, target (erlang o javascript) y dependencias de Hex
manifest.toml Archivo de bloqueo (lockfile) determinista con las versiones exactas y hashes criptográficos de cada dependencia
src/ Código fuente de la aplicación; incluye <nombre_proyecto>.gleam con la función de entrada pub fn main()
test/ Pruebas unitarias y de integración ejecutadas con gleeunit (archivos terminados en _test.gleam)
build/ Artefactos de compilación, formas abstractas de Erlang, bytecode .beam o módulos .mjs (ignorado en Git)

Comandos Esenciales del CLI Integrado

  • gleam add wisp mist: Descarga paquetes desde Hex.pm y actualiza gleam.toml y manifest.toml.
  • gleam format: Formatea todos los archivos .gleam con un estilo estándar único sin necesidad de configuración.
  • gleam test: Compila y ejecuta todas las pruebas ubicadas en test/.
  • gleam docs build: Genera documentación estática en HTML con buscador e índices de tipos.
  • gleam lsp: Inicia el servidor integrado Language Server Protocol compatible con VS Code, Neovim, Zed y Helix, ideal para combinarlo con los asistentes analizados en nuestra guía de Mejores Herramientas Gratuitas de IA para Programar.

11. Ecosistema, Frameworks Web y Librerías en 2026 (1.690+ Paquetes)

En octubre de 2026, el Índice Oficial de Paquetes de Gleam registra 1.690 paquetes publicados, triplicando las cifras posteriores al lanzamiento de la versión 1.0.

Índice oficial de paquetes de Gleam en octubre de 2026 mostrando 1.690 paquetes disponibles El buscador oficial de paquetes de Gleam (packages.gleam.run) supera los 1.690 paquetes publicados en octubre de 2026, con acceso directo a la documentación en HexDocs y repositorios de código.

Si vas a construir aplicaciones en producción con Gleam hoy, estas son las librerías fundamentales que conforman el stack estándar en 2026:

Categoría Paquete Target Rol en el Stack de Gleam en 2026
Framework Web wisp Erlang (BEAM) Framework web pragmático y explícito creado por Louis Pilfold; utiliza middlewares mediante la sintaxis use, logging estructurado y cookies firmadas
Servidor HTTP y WS mist Erlang (BEAM) Servidor HTTP/1.1, HTTP/2, WebSockets y Server-Sent Events (SSE) escrito en Gleam puro sobre actores OTP
Frontend y UI SSR lustre BEAM y JS Framework inspirado en Elm (arquitectura MVU) para crear SPAs en JavaScript, renderizar HTML SSR en BEAM o ejecutar Server Components en tiempo real por WebSockets
Concurrencia / OTP gleam_otp Erlang (BEAM) Actores tipados, tareas asíncronas y supervisores OTP estáticos y dinámicos mediante canales Subject
Cliente PostgreSQL pog Erlang (BEAM) Cliente PostgreSQL con pool de conexiones basado en el driver pgo de Erlang, con parámetros y decodificadores tipados
Cliente SQLite sqlight BEAM y JS Enlaces rápidos a SQLite para aplicaciones embebidas, servicios en el edge y pruebas locales
SQL en Compilación squirrel Erlang (BEAM) Inspecciona archivos .sql contra tu esquema de PostgreSQL y genera funciones Gleam 100% tipadas (inspirado en sqlx de Rust)
Datos y JSON gleam_json BEAM y JS Codificación rápida de JSON y decodificación segura mediante gleam/dynamic/decode

12. Casos de Uso Reales y Adopción en Producción

¿En qué escenarios ofrece Gleam el mayor retorno técnico de inversión en 2026?

  1. APIs JSON y Servicios Financieros de Alta Concurrencia (Wisp + Mist + Pog + Squirrel): Equipos que desarrollan plataformas fintech, pasarelas de facturación o sistemas médicos donde las transiciones de estado inválidas son inaceptables utilizan Wisp y Squirrel para garantizar seguridad de tipos de extremo a extremo desde la consulta SQL en PostgreSQL hasta la respuesta HTTP.
  2. Servidores WebSocket en Tiempo Real y Telemetría IoT: Gracias a que Mist levanta un proceso actor ligero de BEAM por cada conexión WebSocket e interactúa nativamente con gleam_otp, Gleam sobresale en servidores de chat, coordinación multijugador, sincronización colaborativa y streaming de agentes de IA (con demandas de concurrencia similares a las que exploramos en Backend Moderno en Laravel para Agentes de IA).
  3. Aplicaciones Web Full-Stack con Tipos Compartidos (Wisp + Lustre): Al definir los modelos de dominio y codificadores/decodificadores JSON en un paquete común de Gleam, un equipo puede compilar su backend a BEAM (Wisp) y su interfaz interactiva a JavaScript (Lustre), garantizando matemáticamente que el frontend y el backend nunca pierdan sincronía en sus contratos de datos.
  4. Módulos Críticos Tipados dentro de Monolitos Elixir Existentes: Como Gleam compila a archivos .beam estándar mediante formas abstractas de Erlang, los equipos que ya usan Elixir/Phoenix no necesitan reescribir su plataforma: pueden programar motores complejos de cálculo de precios, reglas fiscales o máquinas de estados como un paquete Gleam aislado e invocarlo directamente desde Elixir.

13. Rendimiento, Limitaciones Reales y Cuándo NO Usar Gleam

Una evaluación de ingeniería rigurosa exige analizar también las limitaciones. Antes de adoptar Gleam, ten en cuenta estas restricciones deliberadas de su diseño y ecosistema:

  1. No Existe un Equivalente Monolítico “Todo Incluido” a Phoenix o Rails: Aunque Wisp, Mist y Lustre son excelentes, Gleam no cuenta con un mega-framework único que incluya generadores de autenticación, paneles de administración, colas de trabajos distribuidos (como Oban en Elixir) y ORM con migraciones automáticas integradas de serie. En Gleam compones tu arquitectura seleccionando paquetes específicos (un enfoque muy similar a Go o Axum en Rust).
  2. BEAM No Está Diseñada para Cálculo Numérico Intensivo en CPU: Al igual que Erlang y Elixir, Gleam sobre la máquina virtual BEAM está optimizado para concurrencia masiva de entrada/salida (I/O), baja latencia de cola y tolerancia a fallos, no para álgebra lineal SIMD, procesamiento pesado de vídeo o cómputo científico intensivo en CPU. Para esas cargas de trabajo, Rust sigue siendo la herramienta adecuada (o invocar Rust desde BEAM mediante NIFs).
  3. Ausencia Deliberada de Typeclasses, Traits y Macros: Si vienes de Rust o Haskell, al principio echarás de menos traits polimórficos como Display o Serialize. En Gleam pasas funciones codificadoras de forma explícita (json.string(val), int.to_string(num)). Esto mantiene la compilación instantánea y el código transparente, aunque requiere escribir un poco más de código explícito.
  4. OTP Tipado Requiere Más Estructura Explícita que OTP Dinámico: Debido a que gleam_otp verifica estáticamente los canales de mensajes, modelar comunicaciones cíclicas entre múltiples actores exige definir tipos envoltorio y mapear canales Subject de forma explícita.

14. Guía de Decisión: ¿Deberías Elegir Gleam en 2026?

Elige Gleam Si:

  • Quieres la tolerancia a fallos, la concurrencia de actores ligeros y la simplicidad operativa de la máquina virtual BEAM, pero no estás dispuesto a renunciar al tipado estático estricto ni al pattern matching exhaustivo.
  • Te encanta la ergonomía de Result, Option y los tipos algebraicos (enum) de Rust, pero prefieres un lenguaje con recolector de basura y sin la fricción del borrow checker para entregar servicios backend y productos web con rapidez.
  • Estás construyendo una aplicación full-stack donde compilar exactamente el mismo lenguaje tanto a Erlang/BEAM como a JavaScript/TypeScript elimina por completo los errores de sincronización en los contratos de la API.
  • Buscas un lenguaje pequeño, explícito y libre de macros donde cualquier desarrollador nuevo pueda abrir un archivo y comprender el 100% del flujo de ejecución sin rastrear metaprogramación oculta.

Quédate con Elixir, Rust o TypeScript Si:

  • Elige Elixir (Phoenix): Tu prioridad es lanzar un producto SaaS completo a máxima velocidad aprovechando Phoenix LiveView, Ecto, Oban y Ash, y el verificador de tipos graduales de Elixir v1.20 te resulta suficiente.
  • Elige Rust: Estás desarrollando sistemas embebidos, motores gráficos, herramientas CLI de alto rendimiento o infraestructura crítica en CPU donde necesitas control absoluto de memoria sin recolector de basura.
  • Elige TypeScript: Tu equipo domina exclusivamente JavaScript y tu producto depende de decenas de SDKs comerciales que solo ofrecen soporte oficial en npm.

15. Vídeo Recomendado: OTP y Gleam con su Creador Louis Pilfold

Para profundizar en cómo el creador de Gleam, Louis Pilfold, explica los retos de diseño y las soluciones arquitectónicas para llevar tipos estáticos a los actores y árboles de supervisión de Erlang/OTP, puedes ver su conferencia oficial en Code BEAM Europe:


16. Preguntas Frecuentes (FAQ) sobre el Lenguaje Gleam

¿Está Gleam listo para producción en 2026?

Sí. Gleam alcanzó la versión estable 1.0 en marzo de 2024 y en octubre de 2026 se encuentra en la versión v1.19.2 con sólidas garantías de estabilidad y retrocompatibilidad. Al compilar a bytecode estándar de BEAM (sobre Erlang/OTP 28 y 29) y a JavaScript ES2022, se ejecuta sobre dos de las máquinas virtuales más probadas de la industria.

¿Gleam sigue compilando a archivos de código fuente .erl de Erlang?

En las compilaciones normales de proyectos a partir de Gleam v1.18 y v1.19.0 (octubre de 2026), Gleam ya no compila por defecto a archivos .erl de texto plano. En su lugar, emite directamente formas abstractas de Erlang (Erlang abstract forms) en el formato binario externo de términos de Erlang, lo que acelera la compilación y conserva los números de línea exactos de los archivos .gleam en los stacktraces de errores.

¿En qué se diferencia Gleam del nuevo sistema de tipos de Elixir v1.20?

Elixir v1.20 (lanzado en junio de 2026) introdujo verificación gradual basada en tipos conjuntistas sobre un lenguaje con raíces dinámicas y uso intensivo de macros. Gleam, en cambio, utiliza un sistema de tipos estático estricto estilo Hindley-Milner con tipos de datos algebraicos, pattern matching exhaustivo, ausencia de nil y cero macros, proporcionando garantías en tiempo de compilación similares a las de Rust o Elm.

¿Puedo usar librerías de Elixir y Erlang dentro de un proyecto Gleam?

Sí. Cualquier paquete de Erlang o Elixir publicado en Hex.pm puede añadirse a un proyecto Gleam que compile al target BEAM. Solo necesitas enlazar las funciones requeridas mediante el atributo @external(erlang, "modulo", "funcion") y validar datos dinámicos externos utilizando gleam/dynamic/decode.

¿Cuál es el mejor framework web para Gleam en 2026?

Para construir APIs HTTP y aplicaciones backend en la máquina virtual BEAM, la combinación estándar es Wisp junto con el servidor HTTP/2 y WebSockets Mist. Para interfaces frontend interactivas, renderizado en servidor (SSR) o componentes en tiempo real estilo Phoenix LiveView, Lustre es el framework de referencia en el ecosistema Gleam.

Yan ZC

Yan ZC

Software Developer & Tech Reviewer

Desarrollador de software y analista tecnológico en ToolReview. Pruebo, analizo y documento herramientas de IA y flujos de software. Mi misión es ayudarte a encontrar el stack tecnológico perfecto con reseñas honestas y benchmarks rigurosos.