glide

Comparison

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

Both languages give you compile-time memory safety and zero-cost abstractions over native code. The Glide programming language by Murillo Deolino picks different defaults from Rust in five places that matter day-to-day: lifetimes, error handling, concurrency, build tooling, and surface complexity.

&T

Borrows without lifetime annotations

Rust enforces memory safety with a borrow checker plus explicit lifetime parameters ('a, 'static) once references cross function boundaries. Glide enforces the same use-after-free and aliased-mutation rules, but the lifetimes are inferred from scope alone — you never write 'a. The mental cost of "fighting the borrow checker" is significantly lower, at the price of slightly less expressive borrow patterns (no self-referential structs without an arena).

glide.glide 
fn first_word(s: &string) -> &string {
    return s.split(" ").get(0);
}                              // no lifetime params
rust.rs 
fn first_word<'a>(s: &'a str) -> &'a str {
    s.split(' ').next().unwrap()
}                              // explicit 'a
!T

Errors are values, no Result<T, E> import

Rust's Result<T, E> is in std::result; the error type is a generic parameter, and idiomatic crates wrap everything in Result<T, Box<dyn Error>> or a custom error enum. Glide's !T is built into the language — the error channel is always a string (with optional structured payload), the ? postfix operator is the same, but you never import an error trait or define a 30-variant enum just to propagate failures.

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

Concurrency in the language, not a crate

Rust's async story is split across std, tokio, async-std, smol, and the Future trait — each with its own runtime, executor flavour, and colouring rules. Glide ships M:N coroutines and channels in the compiler itself: spawn fn(args) kicks off a green thread, chan<T> is a typed channel, select! multiplexes them. There's nothing to choose, nothing to import, no async fn colouring.

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

Procedural macros without a separate crate

Rust's proc_macro requires a dedicated crate type (proc-macro = true), syn + quote, and a separate compilation unit that targets the host. Glide's procedural macros (@derive(Name), @attr(...)) run inside the compiler at expansion time via an embedded interpreter — they manipulate the same AST nodes the compiler uses internally, in the same module, no separate toolchain.

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

One binary, no rustup + cargo + rust-analyzer

Rust's ergonomics live in cargo (build), rustup (toolchain manager), rust-analyzer (LSP), rustfmt (formatter), and clippy (linter) — five separate binaries. Glide is one binary: glide build, glide run, glide test, glide bench, glide doc, glide install, glide lsp, glide fmt, all from the same executable. Smaller install, fewer version-skew bugs.

When to pick which

Both are good choices for native code; the right answer depends on what you value.

Pick Rust if…

You need the mature ecosystem (crates.io has ~150k crates). You're shipping to embedded targets with strict no_std constraints today. Your team already knows lifetimes and you want the tightest possible control over allocation and aliasing.

Pick Glide if…

You want Rust-grade memory safety without the lifetime tax. You want Go-grade concurrency built into the language, not a runtime crate. You value a small surface area and one-binary tooling. You're starting fresh and want errors-as-values without 30-line error enums.

Try Glide

Linux / macOS

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

Windows (PowerShell)

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