glide

Comparação

Glide vs Zig.
Uma comparação justa.

Ambas as linguagens compilam para código nativo por meio de uma infraestrutura portátil semelhante a C e distribuem um toolchain de binário único. A linguagem de programação Glide, criada por Murillo Deolino, diverge do Zig em três grandes eixos: segurança de memória (verificações em tempo de compilação vs passagem explícita de alocador), concorrência (corrotinas nativas vs nenhuma) e sistemas de macros e traits.

&T

Um borrow checker, não encanamento de alocadores

A história de memória do Zig é "passe um alocador em todo lugar". Funções que alocam recebem um parâmetro Allocator; você decide de onde vem a memória em cada ponto de chamada. É explícito e poderoso, mas significa que todo helper tem um argumento de alocador, e use-after-free é seu problema em tempo de execução. Glide rastreia a propriedade em tempo de compilação: borrows vinculados ao escopo detectam use-after-free e mutação com aliasing antes de o programa rodar. Você ainda pode usar arenas quando quiser, apenas sem um parâmetro de alocador em cada fn.

glide.glide 
fn load(path: string) -> !string {
    return ok(fs_read(path)?);
}                              // sem argumento de alocador
zig.zig 
fn load(alloc: Allocator, path: []const u8) ![]u8 {
    return std.fs.cwd().readFileAlloc(alloc, path, 1<<20);
}                              // alocador passado por todo o código
spawn

Concorrência na linguagem

O async/await do Zig foi removido da linguagem antes da versão 0.11 e ainda está sendo redesenhado — por ora, a concorrência é feita com threads do SO ou std.Thread.Pool com coordenação manual. Glide traz corrotinas M:N, canais tipados e select! no próprio compilador. spawn fn() inicia uma green thread; o runtime é um pequeno escalonador work-stealing que faz parte do design da linguagem desde o primeiro dia.

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();
}
trait

Traits, não duck typing com comptime

Os genéricos do Zig funcionam via comptime — uma função que recebe um parâmetro type e o utiliza. Não há interface formal; as restrições são verificadas tentando a compilação. Glide usa traits explícitos com assinaturas de métodos, corpos padrão, supertraits e *dyn Trait para despacho por vtable. O compilador verifica os bounds no ponto de chamada, antes da monomorfolização — menos surpresas, erros mais claros, melhores completions de LSP.

glide.glide 
trait Render {
    fn render(self: *Self) -> string;
}

impl Render for Box    {
    fn render(self: *Box) -> string {
        return "Box";
    }
}

fn show(r: *dyn Render) {
    println!(r.render());
}
@derive

Macros + derives procedurais

Zig usa comptime para programação em tempo de compilação — poderoso, mas limitado a avaliar código Zig regular durante o build. Glide possui macros declarativas no estilo macro_rules! (com matchers $x:expr, $x:ident, $x:ty, variadics) E macros procedurais (@derive(Name), @attr(...), @name!(args)) que executam dentro do compilador no momento de expansão. O interpretador de proc-macros manipula a mesma AST que o compilador usa internamente.

glide.glide 
@derive(JsonBind)
struct User {
    name: string,
    age:  int,
}                              // parse + emit gerados automaticamente
tool

Linhagem compartilhada no backend C

O recurso mais famoso do Zig fora da linguagem em si é o toolchain C/C++ incluso — zig cc é genuinamente útil como compilador cruzado. Glide usa o mesmo toolchain baseado em Zig por baixo dos panos para compilar sua saída em C, então cross-compilation, seleção de libc (glibc/musl) e triplas de target funcionam da mesma forma. --target=x86_64-linux-musl funciona em ambos, com o mesmo toolchain por baixo.

Quando escolher cada um

Duas linguagens com objetivos semelhantes e opiniões diferentes sobre segurança.

Escolha Zig se…

Você quer controle absoluto sobre alocação — cada byte, cada ponto de chamada. Você está substituindo C em uma base de código existente e precisa de interop perfeita com C. Você prefere a passagem explícita de alocadores a um borrow checker. Você não precisa de primitivos de concorrência embutidos.

Escolha Glide se…

Você quer segurança de memória em tempo de compilação sem passar alocadores por todo o código. Você precisa de corrotinas M:N e canais na linguagem, não na camada do SO. Você quer traits + macros procedurais, não duck typing com comptime. Você gosta da ergonomia do toolchain do Zig e quer o mesmo em uma superfície de mais alto nível.

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