glide

Comparison

Glide vs Zig.
A fair head-to-head.

Both languages compile to native code through portable C-like infrastructure and ship one binary toolchain. The Glide programming language by Murillo Deolino diverges from Zig on three big axes: memory safety (compile-time checks vs explicit allocator passing), concurrency (built-in coroutines vs none), and macro / trait systems.

&T

A borrow checker, not allocator plumbing

Zig's memory story is "pass an allocator everywhere". Functions that allocate take an Allocator parameter; you decide where memory comes from at every call site. It's explicit and powerful, but it means every helper has an allocator argument, and use-after-free is your problem at runtime. Glide tracks ownership at compile time: scope-bound borrows catch use-after-free and aliased mutation before the program runs. You still get arenas when you want them, just without an allocator parameter on every fn.

glide.glide 
fn load(path: string) -> !string {
    return ok(fs_read(path)?);
}                              // no allocator arg
zig.zig 
fn load(alloc: Allocator, path: []const u8) ![]u8 {
    return std.fs.cwd().readFileAlloc(alloc, path, 1<<20);
}                              // alloc threaded through
spawn

Concurrency in the language

Zig's async/await was removed from the language ahead of 0.11 and is still being redesigned — for the moment, concurrency is OS threads or std.Thread.Pool plus manual coordination. Glide ships M:N coroutines, typed channels, and select! in the compiler itself. spawn fn() kicks off a green thread; the runtime is a small work-stealing scheduler that's been the language design from day one.

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, not comptime duck typing

Zig's generics work via comptime — a function that takes a type parameter and uses it. There's no formal interface; constraints are checked by attempting compilation. Glide uses explicit traits with method signatures, default bodies, supertraits, and *dyn Trait for vtable dispatch. The compiler enforces bounds at the call site, before monomorphisation — fewer surprises, cleaner errors, better LSP completions.

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 + procedural derives

Zig uses comptime for compile-time programming — powerful but limited to evaluating regular Zig code at build time. Glide has both macro_rules!-style declarative macros (with $x:expr, $x:ident, $x:ty matchers, variadics) AND procedural macros (@derive(Name), @attr(...), @name!(args)) that run inside the compiler at expansion time. The proc-macro interpreter manipulates the same AST the compiler uses internally.

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

Shared lineage on the C backend

Zig's most famous feature outside the language itself is the bundled C/C++ toolchain — zig cc is genuinely useful as a cross-compiler. Glide uses the same Zig-based toolchain under the hood to compile its C output, so cross-compilation, libc selection (glibc/musl), and target triples work the same way. --target=x86_64-linux-musl works on both, with the same toolchain underneath.

When to pick which

Two languages with similar goals and different opinions about safety.

Pick Zig if…

You want absolute control over allocation — every byte, every call site. You're replacing C in an existing codebase and need seamless C interop. You enjoy explicit allocator passing and prefer it to a borrow checker. You don't need built-in concurrency primitives.

Pick Glide if…

You want compile-time memory safety without passing allocators around. You need M:N coroutines and channels in the language, not the OS layer. You want traits + procedural macros, not comptime duck typing. You like Zig's toolchain ergonomics and want the same on a higher-level surface.

Try Glide

Linux / macOS

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

Windows (PowerShell)

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