Primitive Scalars: Go vs Rust

Why it exists

Processors only understand fixed register widths, but programmers want portable code. Go hides this by providing int and uint that match the native word size, reducing decision fatigue. Rust exposes the hardware truth by making every scalar width explicit, preventing assumptions about memory layout from leaking across platforms.

The mental model

Think of Go's scalars as defaults that just work on whatever machine compiles them. int is big enough to count memory on the local CPU, and conversions between numeric types are explicit but constants are flexible. Rust's scalars are precision tools: i32 is exactly four bytes everywhere, and the compiler treats mixing a u16 with an i32 as a type error rather than a silent conversion.

How it works

Go offers bool, int, uint, uintptr, and explicit widths like int8 through int64, uint8 through uint64, plus float32, float64, and complex numbers. int and uint are either 32 or 64 bits depending on the architecture. Rust offers bool, char, i8 through i128, u8 through u128, isize, usize, f32, and f64. isize and usize match the pointer width, but idiomatic Rust avoids them for general math. Go allows untyped constants to morph into whatever width fits, while Rust demands every literal have a known type or a suffix like 42u32.

When to use it

Use Go's int for indexing, counters, and slice lengths where the platform word is natural. Use Go's fixed-width types only when you need guaranteed layout for wire formats or C interop. In Rust, use i32 as the default integer, u8 for raw bytes, and usize exclusively for indexing and collection lengths. Use f64 in both languages unless you are optimizing for memory or GPU bandwidth.

When not to use it

Do not store Go's int in a database column or binary protocol if the width must be stable across 32-bit and 64-bit builds, because its size changes silently. Do not use Rust's as keyword for numeric conversions when correctness matters, because it truncates and wraps without panic; prefer TryFrom or checked arithmetic instead. Avoid Rust's isize for file sizes or network counts, because it can be 32 bits on some targets.

One canonical example

Imagine writing a binary file header that starts with a 32-bit magic number and a 16-bit version. In Go, you must use uint32 and uint16 fields in your struct; if you used int, a 64-bit build would write eight bytes for the first field and corrupt the format. In Rust, you naturally define the struct with u32 and u16 fields, and the compiler guarantees the layout matches your intent on every target without hidden platform variation.