glide

Comparação

Glide vs Rust.
Uma comparação justa.

Ambas as linguagens oferecem segurança de memória em tempo de compilação e abstrações de custo zero sobre código nativo. A linguagem de programação Glide, criada por Murillo Deolino, faz escolhas diferentes das do Rust em cinco pontos que importam no dia a dia: lifetimes, tratamento de erros, concorrência, ferramentas de build e complexidade de superfície.

&T

Empréstimos sem anotações de lifetime

O Rust garante segurança de memória com um verificador de empréstimos (borrow checker) acrescido de parâmetros de lifetime explícitos ('a, 'static) quando referências cruzam fronteiras de funções. O Glide aplica as mesmas regras contra uso após liberação e mutação com aliasing, mas os lifetimes são inferidos apenas pelo escopo — você nunca escreve 'a. O custo mental de "brigar com o borrow checker" é significativamente menor, ao preço de padrões de empréstimo ligeiramente menos expressivos (sem structs autorreferenciadas sem uma arena).

glide.glide 
fn first_word(s: &string) -> &string {
    return s.split(" ").get(0);
}                              // sem parâmetros de lifetime
rust.rs 
fn first_word<'a>(s: &'a str) -> &'a str {
    s.split(' ').next().unwrap()
}                              // 'a explícito
!T

Erros como valores, sem importar Result<T, E>

O Result<T, E> do Rust está em std::result; o tipo de erro é um parâmetro genérico, e crates idiomáticas envolvem tudo em Result<T, Box<dyn Error>> ou em um enum de erros personalizado. O !T do Glide é embutido na linguagem — o canal de erros é sempre uma string (com payload estruturado opcional), o operador pós-fixado ? funciona da mesma forma, mas você nunca importa uma trait de erro nem define um enum de 30 variantes só para propagar falhas.

glide.glide 
fn parse(s: string) -> !int {
    if s.eq("") { return err("empty"); }
    return ok(s.to_int());
}

fn pipe(s: string) -> !int {
    let n: int = parse(s)?;
    return ok(n + 1);
}
rust.rs 
use std::num::ParseIntError;

fn parse(s: &str) -> Result<i64, ParseIntError> {
    s.parse::<i64>()
}

fn pipe(s: &str) -> Result<i64, ParseIntError> {
    Ok(parse(s)? + 1)
}
spawn

Concorrência na linguagem, não em uma crate

A história de async do Rust está dividida entre std, tokio, async-std, smol e a trait Future — cada um com seu próprio runtime, executor e regras de coloração. O Glide inclui corrotinas M:N e canais no próprio compilador: spawn fn(args) inicia uma green thread, chan<T> é um canal tipado, select! os multiplexa. Nada a escolher, nada a importar, sem coloração de async fn.

glide.glide 
fn worker(c: chan<int>) {
    c.send(42);
}

fn main() -> int {
    let c: chan<int> = make_chan(1);
    spawn worker(c);
    return c.recv();
}
rust.rs (tokio) 
use tokio::sync::mpsc;

async fn worker(tx: mpsc::Sender<i32>) {
    tx.send(42).await.unwrap();
}

#[tokio::main]
async fn main() {
    let (tx, mut rx) = mpsc::channel(1);
    tokio::spawn(worker(tx));
    println!("{}", rx.recv().await.unwrap());
}
@derive

Macros procedurais sem crate separada

O proc_macro do Rust exige um tipo de crate dedicado (proc-macro = true), syn + quote, e uma unidade de compilação separada que tem como alvo o host. As macros procedurais do Glide (@derive(Name), @attr(...)) executam dentro do compilador no momento da expansão por meio de um interpretador embutido — elas manipulam os mesmos nós de AST que o compilador usa internamente, no mesmo módulo, sem toolchain separada.

glide.glide 
@derive(JsonBind)
struct User {
    name: string,
    age:  int,
}                              // sem crate separada
tool

Um binário, sem rustup + cargo + rust-analyzer

A ergonomia do Rust está distribuída em cargo (build), rustup (gerenciador de toolchain), rust-analyzer (LSP), rustfmt (formatador) e clippy (linter) — cinco binários separados. O Glide é um único binário: glide build, glide run, glide test, glide bench, glide doc, glide install, glide lsp, glide fmt, tudo no mesmo executável. Instalação menor, menos bugs de incompatibilidade de versão.

Quando escolher cada um

Ambos são boas opções para código nativo; a resposta certa depende do que você valoriza.

Escolha Rust se…

Você precisar do ecossistema maduro (crates.io tem ~150k crates). Você estiver fazendo deploy em targets embarcados com restrições rígidas de no_std hoje. Sua equipe já domina lifetimes e você quer o controle mais preciso possível sobre alocação e aliasing.

Escolha Glide se…

Você quiser segurança de memória no nível do Rust sem o custo de lifetimes. Você quiser concorrência no nível do Go embutida na linguagem, não em uma crate de runtime. Você valoriza uma superfície pequena e ferramentas em um único binário. Você está começando do zero e quer erros como valores sem enums de erro de 30 linhas.

Experimente o Glide

Linux / macOS

$ curl -fsSL https://glide-lang.org/install.sh | bash

Windows (PowerShell)

> iwr https://glide-lang.org/install.ps1 -UseB | iex