Quantization, performance, and why Rust keeps AI from corroding

Lawrence Freeman returns to Rust Leeds on Wednesday 17 June to give a 90-minute hands-on tutorial on numeric representation, quantization, and what all of this means for AI inference performance.

The talk starts from first principles: how floating-point numbers are stored in memory, where precision breaks down, and how rounding and overflow introduce subtle errors that compound in production systems. From there, Freeman walks through quantization — the technique of trading some numeric accuracy for meaningful gains in speed and efficiency — and builds a small quantization framework in Rust, step by step. The session ends with Post-Training Quantization (PTQ) applied to AI inference: how it shrinks model size, cuts power use, and speeds up inference without retraining.

Rust is the thread running through all of it. The language's explicitness around types and memory makes numeric behaviour visible in a way that Python or C++ often obscures. Freeman's argument, in short, is that Rust's safety guarantees are not just a correctness story — they're a performance story too, particularly when you're pushing numbers through a model at scale.

The format is tutorial-style rather than lecture: expect live code, not slides. Freeman runs Fledgio, where he does Rust training and consultancy, so this is material he teaches professionally. The audience tends to be working engineers with some Rust exposure, but the session builds from fundamentals so prior AI experience is not assumed.

Rust Leeds meets monthly at venues around Leeds city centre. The group is hosted by Tim L. and two other organisers, and has built a consistent programme of practical, code-first talks from practitioners rather than vendors.

Why attend

Quantization is one of those topics that matters a lot in production AI but rarely gets explained from the ground up. This session does exactly that, in working Rust code, with someone who teaches this material for a living.

You'll leave with a concrete understanding of how numeric representation affects model performance, a mental model for when and how to apply PTQ, and a small framework you can adapt. Pizza and drinks are provided from 18:00, and there's an optional pub trip afterwards — a reasonable way to spend a Wednesday evening in Leeds.

Agenda

• 18:00 — Arrivals, networking, pizza and drinks
• 18:30 — Event starts, introductions
• 18:35 — Talk: Quantization, Performance, and Why Rust Keeps AI from Corroding
• 20:00 — Event finishes; optional move to a nearby pub

Speakers

• Lawrence Freeman — Rust practitioner and founder of Fledgio, where he delivers Rust training and consultancy. Has spoken at Rust Leeds previously.