Sobre Go como linguagem de sistemas: eu entendo a crítica. Quando falo desse espaço, penso mais em controle,
previsibilidade, binário nativo, baixo overhead e capacidade de escrever tooling, runtime, servidores e partes mais
próximas da infraestrutura. Go entra em parte disso, mas realmente não tenta ocupar o mesmo lugar que C, Zig ou Rust.

Sobre ownership/borrow no Glide: a ideia não é copiar o Rust nem dizer que o Glide “faz o que Rust não consegue”. Rust
resolve um problema muito difícil: segurança de memória sem GC, com controle fino e garantias fortes em tempo de
compilação. O custo disso é um modelo de ownership/borrow mais explícito, incluindo lifetimes quando a inferência não
basta.

No Glide, o caminho é diferente. A linguagem usa arenas como modelo principal de memória, então muitos valores vivem
dentro de um escopo/arena e são liberados em bloco. Isso reduz bastante a necessidade de rastrear ownership fino objeto
por objeto. Em vez de provar todas as relações de tempo de vida como o Rust, o Glide tenta tornar o caso comum mais
simples: alocar, usar dentro de um escopo claro e descartar tudo junto.

Isso tem limitações. Não é a mesma garantia formal do borrow checker do Rust. Se você quer controle máximo e garantias
muito fortes contra dangling references em todo cenário possível, Rust continua sendo a referência. O Glide tenta trocar
parte dessa rigidez por ergonomia e previsibilidade, usando arenas, escopos e convenções mais simples.

Sobre err(): funções que podem falhar retornam um tipo de resultado, como !T. Então um err(...) não é exceção; é um valor
de erro. Quem chama precisa lidar com isso ou propagar usando ?. A ideia é deixar o fluxo de erro explícito, mais
parecido com Result do Rust/Zig do que com exceções.

E sim, eu conheço Zig, Odin e outras linguagens nessa linha “better C”. Elas são referências importantes. Zig é muito
forte em controle explícito, comptime e integração com C. Odin tem uma pegada muito interessante para programação
prática, tooling e jogos/sistemas. Rust joga outro jogo: garantias fortes de segurança e concorrência, mas com uma
complexidade maior.

Eu diria que o Glide está mais próximo dessa família de linguagens compiladas modernas do que de Go puro. Ele tem algumas
ideias que lembram Rust/Zig/Odin, mas com outro equilíbrio: arena allocation por padrão, erros como valores, corrotinas
M:N, canais, traits e uma sintaxe que tenta continuar simples.

Então a proposta não é “fazer o que Rust não consegue”, nem fingir que Zig/Odin não existem. É explorar outro ponto no
mapa: uma linguagem generalista, grande, com controle razoável, ergonomia boa e escolhas próprias de memória, erro e
concorrência.