glide

A linguagem de programação Glide

Uma linguagem de sistemas pequena.
Memória segura, concorrência real, asm inline.

Uma linguagem de programação de sistemas moderna criada por Murillo Deolino. Binários nativos através de um backend C portátil. Stdlib, toolchain e LSP já incluídos.

Começar Ver no GitHub →

v0.3.0 — compilador auto-hospedado, alvos nativos via Zig.

hello.glide 
import stdlib::http::*;

fn handle(req: *HttpRequest) -> HttpResponse {
    if req.path.eq("/") {
        return HttpResponse::ok().body("hello!\n");
    }
    return HttpResponse::not_found();
}

fn main() -> int {
    http_listen(8080, handle);
    return 0;
}

Esta página é servida por um programa Glide próximo ao acima — TLS terminado pelo próprio binário.

Veja em ação

Um pool de workers, em 18 linhas.

Canais, spawn e erros-como-valores se compõem sem cerimônia. Nenhum async runtime para escolher, nenhum Result<T,E> para importar — apenas as formas que a linguagem já oferece.

workers.glide 
fn process(n: int) -> !int {
    if n < 0 { return err("negative: ${n}"); }
    return ok(n * n);
}

fn worker(jobs: chan<int>, out: chan<!int>) {
    while let n = jobs.recv() {
        out.send(process(n));
    }
}

fn main() -> int {
    let jobs: chan<int>  = make_chan(8);
    let out:  chan<!int> = make_chan(8);

    for _ in 0..4 { spawn worker(jobs, out); }
    for n in [1, 2, -3, 4, 5] { jobs.send(n); }
    jobs.close();

    let mut seen: int = 0;
    while seen < 5 {
        let r: !int = out.recv();
        if r.ok { println!("squared:", r.val); }
        else    { println!("skip:", r.err); }
        seen = seen + 1;
    }
    return 0;
}
  • chan<T> Canais tipados e com buffer — sem estado mutável compartilhado.
  • spawn Corrotinas M:N, escalonadas pelo runtime. spawn_thread quando você precisar de threads de SO.
  • !T Um valor ou um erro. ? propaga, campos lidos como dados.
  • "${n}" Interpolação de strings embutida na linguagem.
Por que Glide

Seis coisas que o Glide acerta.

Cada ideia abaixo substitui uma fonte de dor que você provavelmente já contornou em outra linguagem. Toda a linguagem cabe na sua cabeça — e estas são a maior parte dela.

&T

Borrows sem lifetimes

Borrows vinculados ao escopo (&T, &mut T) detectam referências penduradas, mutação com aliasing e use-after-free em tempo de compilação. Você nunca escreve 'a, 'b ou 'static. Para objetos heap próprios há *T com auto-drop na saída do escopo, além de defer e defer_err para limpezas arbitrárias.

memory.glide 
fn draw() {
    let p: *Point = Point { x: 1, y: 2 };
    render(p);
}                                  // liberado na saída do escopo

fn parse_tree() {
    let arena: *Arena = Arena::new(4096);
    defer arena.free();
    let n1: *Node = arena.create(Node);
    let n2: *Node = arena.create(Node);
}                                  // arena liberada de uma só vez
!T

Erros como valores

!T é um resultado; ?T é uma opção; ?!T é a forma combinada. O operador pós-fixo ? propaga falhas; ?? é o operador de coalescência. Sem exceções, sem Result<T, Box<dyn Error>>, sem panic handlers.

errors.glide 
fn parse(n: int) -> !int {
    if n < 0 { return err("negative"); }
    return ok(n * 2);
}

fn pipeline(n: int) -> !int {
    let v: int = parse(n)?;
    return ok(v + 1);
}
chan<T>

Concorrência real, sem callbacks

Corrotinas M:N via spawn. Canais tipados via chan<T>. O macro select! multiplexa operações de canal com arms opcionais default e sensíveis a fechamento. Precisa de uma thread de kernel? spawn_thread. Sem compartilhamento por design.

concurrency.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();
}
<T>

Generics + traits

Generics são monomorfarizados — uma fn C por T concreto. Restrições usam T: Trait + Trait. Traits suportam corpos de métodos padrão e supertraits; *dyn Trait despacha via vtable para coleções heterogêneas.

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

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

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

Metaprogramação, na linguagem

Macros declarativos estilo macro_rules! com matchers ($x:expr, $x:ident, $x:ty) e a forma variádica $($x:expr),*. Macros procedurais — @derive(Name), @attr(...), @name!(args) — rodam no compilador em tempo de expansão via um interpretador embutido, manipulando os mesmos nós AST que o compilador usa internamente. Nenhum toolchain de plugin separado.

meta.glide 
@derive(JsonBind)
struct User { name: string, age: int }

macro_rules! sum {
    ($($x:expr),*) => { {
        let mut t: int = 0;
        $( t = t + $x; )*
        t
    } };
}

let total: int = sum!(1, 2, 3, 4);   // 10
asm

Controles de baixo nível quando necessário

Assembly inline com restrições de operandos no estilo GCC. naked fn remove o prólogo/epílogo para que você possa definir sua própria convenção de chamada. c_raw! { … } injeta C literal; @cfg("posix" | "windows") condiciona declarações por plataforma. As saídas de emergência não comprometem os padrões seguros — são explícitas, locais e visíveis no ponto de chamada.

tsc.glide 
fn read_tsc() -> u64 {
    let lo: u32 = 0;
    let hi: u32 = 0;
    asm volatile { "rdtsc" : "=a"(lo), "=d"(hi) }
    return ((hi as u64) << 32) | (lo as u64);
}
Incluído com o compilador

A biblioteca padrão é a plataforma.

Sem bootstrap estilo crates.io. As peças que você usa todo dia — HTTP, TLS, JSON, canais, crypto — são distribuídas dentro do toolchain. Uma instalação, um import.

Ferramentas

Um binário. Tudo que você precisa.

Gerenciador de pacotes, gerador de documentação, executor de testes, benchmarker, formatador, LSP — tudo no mesmo comando glide.

pkg

Gerenciador de pacotes

glide new, glide add, glide fetch, glide update, glide install. Dependências por caminho + dependências git (atalho por tarball do GitHub, fallback git-clone para o resto). Seleção de versão mínima no grafo de dependências; cache bloqueado por SHA-256.

~ shell 
$ glide new my_app
$ cd my_app
$ glide add http_x github.com/glide-lang/http_x v0.3.1
$ glide run
doc

Gerador de documentação

glide doc emite HTML estático diretamente dos comentários ///. --serve roda um servidor local de preview; --ai adicionalmente gera um arquivo AGENTS.md e um resumo flat llms.txt voltado para ingestão por IA.

~ shell 
$ glide doc --serve=8080
$ glide doc --ai --stdlib
doc: wrote 56 modules / 336 items -> ./build/doc/index.html
doc: wrote LLM-friendly summary -> ./build/doc/llms.txt
test

Executores de teste + bench

glide test descobre arquivos *_test.glide e executa cada fn test_* dentro deles; --golden faz diff de stdout. glide bench ajusta automaticamente a contagem de iterações e reporta ns/op.

~ shell 
$ glide test
PASS test_parse_negative                  0.3ms
PASS test_pipeline_propagates             0.4ms
2 passed, 0 failed

$ glide bench src/hash_bench.glide
bench_sha256_1kb       8421 ns/op
lsp

Servidor LSP, editores como cidadãos de primeira classe

glide lsp fala LSP via stdio: hover, completion, goto-definition (variáveis locais, parâmetros, fns, structs, enums, traits, macros, proc-macros, campos, segmentos de import), referências, rename, formatação — indexado na stdlib + dependências. Gramática Tree-sitter, extensão para Zed e extensão para VS Code estão todas no repositório.

~ shell 
$ glide lsp                  # servidor LSP via stdio

# no seu editor:
# - hover em qualquer símbolo -> doc + assinatura
# - F12 em uma fn da stdlib -> vai para o código-fonte
# - rename refatora em todo o grafo de dependências
Em contexto

Glide vs Rust, Go e Zig.

Glide escolhe um ponto diferente no espaço de design de linguagens de sistemas. Comparações lado a lado de onde ele se posiciona em relação às linguagens que as pessoas já conhecem.

Glide vs Rust →

Segurança de memória sem anotações de lifetime. !T em vez de Result<T, E>. Corrotinas na linguagem, não em um crate.

Glide vs Go →

Verificações de memória em tempo de compilação em vez de GC. Generics + traits + sum types. Mesmas corrotinas M:N, mesma ergonomia de canais.

Glide vs Zig →

Borrow checker em vez de encanamento de allocator. Macros + traits. Canais e corrotinas como cidadãos de primeira classe.

FAQ

Perguntas frequentes.

Respostas curtas para o que as pessoas mais perguntam sobre a linguagem de programação Glide.

O que é a linguagem de programação Glide?

Glide é uma linguagem de programação de sistemas moderna que ocupa o mesmo nicho que Rust, Go e Zig: binários nativos com desempenho previsível, mas com um modelo de memória mais simples (borrows vinculados ao escopo, sem anotações de lifetime) e corrotinas M:N embutidas. O compilador é auto-hospedado e emite C portátil; um toolchain empacotado produz código de máquina para Linux, macOS e Windows.

Quem criou o Glide?

Glide foi criado e é mantido por Murillo Deolino. O código-fonte está em github.com/glide-lang/Glide sob a licença MIT. O compilador, a biblioteca padrão, o gerenciador de pacotes, o servidor LSP e o gerador de documentação estão todos nesse único repositório.

Como o Glide lang é diferente de Rust ou Go?

Glide oferece segurança de memória no nível do Rust (verificações de use-after-free e mutação com aliasing em tempo de compilação) sem nunca escrever anotações de lifetime. Oferece concorrência no nível do Go (corrotinas M:N, canais, select) sem um async runtime separado para escolher. Erros são valores via o tipo !T — sem exceções, sem panic handlers. Toda a linguagem cabe na sua cabeça; o tooling é um único binário.

Quais plataformas o Glide suporta?

Glide distribui binários nativos para Linux x86_64, Linux aarch64, macOS Apple Silicon e Windows x86_64. Cross-compilation para qualquer alvo suportado pelo toolchain C baseado em Zig está embutida no compilador via --target=<triple>.

O Glide está pronto para produção?

Glide está na v0.3.0 — a linguagem e a biblioteca padrão são estáveis o suficiente para construir serviços reais (este site é servido por um binário Glide), mas o ecossistema ainda é jovem. Use-o para projetos pessoais, ferramentas internas e utilitários de CLI hoje. Acompanhe o changelog para o caminho até a versão 1.0.

Como instalo o Glide?

Instaladores em uma linha para Linux, macOS e Windows abaixo. Eles colocam o toolchain em um diretório por usuário — nenhum direito de administrador é necessário. Veja a seção de instalação para os comandos exatos.

Instalação

Instalação por usuário — nenhum direito de administrador necessário. Abra um novo shell após o instalador terminar; glide --version deve exibir a versão instalada.

Linux / macOS

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

Windows (PowerShell)

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

Início rápido

Criar um projeto

$ glide new my_app
$ cd my_app
$ glide run                  # compilar + executar pelo manifest

Ou uma biblioteca

$ glide new my_lib --lib     # sem `bin`, src/lib.glide
$ cd my_lib
$ glide test

Estrutura do projeto

my_app/
├── glide.glide       # manifest: nome, versão, bin, deps
├── src/
│   └── main.glide
├── build/            # saída do compilador (gerenciado automaticamente, no gitignore)
├── glide_modules/    # dependências baixadas / vinculadas
└── glide.lock        # revisões resolvidas + hashes de conteúdo

Compilar do código-fonte

O compilador é escrito em Glide e distribui um seed em C que compila para um binário bootstrap; a partir daí o Glide compila a si mesmo.

$ git clone https://github.com/glide-lang/Glide.git
$ cd Glide

# POSIX
$ cc bootstrap/seed/bootstrap.c -o glide_seed -O2 -lpthread -lm

# Hosts Windows precisam de -lws2_32 para os builtins de socket
$ cc bootstrap/seed/bootstrap.c -o glide_seed -O2 -lpthread -lm -lws2_32

$ bash tools/install_toolchain.sh             # baixar toolchain C empacotado
$ ./glide_seed build bootstrap/main.glide -o glide
$ ./glide install .                           # em ~/.glide/bin

Cross-compile via --target=<triple> — qualquer alvo suportado pelo toolchain C empacotado: x86_64-linux-{gnu,musl}, aarch64-linux-{gnu,musl}, x86_64-windows-{gnu,msvc}, aarch64-macos, riscv64-linux-musl e mais.