Zig Memory Layout is Better Than C

Summary

The video argues that Zig’s support for integers of nearly any bit width is useful because it lets programmers describe data precisely, especially when working with packed memory layouts.

Integer widths and storage

Zig provides unsigned integer types from u0 through u65535 and signed types from i1 through i65535, for a total of 131,071 fixed-width types. u0 can hold only the value zero and uses no storage.

An integer’s declared bit width does not necessarily determine its size as a regular field in memory. For example, a standalone u7 occupies a byte, and a u24 may occupy four bytes because ordinary alignment rules still apply.

Narrow types also constrain the values they can represent. A u4, for instance, can hold values from 0 to 15. The video says Zig catches invalid values at compile time where possible and can panic on overflow in debug and safe-release modes. These checks are disabled in fast-release mode.

Packed structs and exact layouts

Unlike regular structs, Zig packed structs give fields their specified bit widths without extra padding. In the presenter’s example, fields of 24, 1, and 7 bits occupy exactly 32 bits, or four bytes.

The video demonstrates this with an IPv4 header byte, which contains two 4-bit values: the version and header length. A Zig packed struct can represent these fields and reinterpret the raw byte without manual shifts or masks. Field order matters: Zig lays out packed fields starting from the least significant bit, so fields must be declared in the appropriate order to match the packet.

Comparison with C

The video highlights several limitations of C bit-fields:

1. Implementation-defined layout: Bit-field layout, including bit order and storage size, can vary by implementation. The presenter demonstrates that field types can affect struct size and notes that the Linux kernel defines IPv4 header fields in different orders for different endianness.
2. No pointers to bit-fields: C does not allow taking a pointer to a bit-field. Zig supports pointers to packed fields that retain their bit offsets.
3. Integer promotions: C promotes bit-field arithmetic to int, which can produce surprising results when assigning back to a narrow field. Zig retains the narrow type and can detect overflow in safe modes.

The video also discusses C23’s _BitInt, a standardized way to declare integers of arbitrary width, with a maximum width that depends on the compiler. However, ordinary struct fields still use byte-based storage, so _BitInt alone does not provide Zig’s packed-struct layout guarantees.

Why support so many widths?

The stated upper bound comes from storing the width in a 16-bit value. The narrator argues against choosing a smaller arbitrary limit, noting real uses for widths such as 521 bits in elliptic-curve cryptography and 2,048- or 4,096-bit RSA keys.

The point is not that every width is commonly needed, but that programmers can specify the shape of their data without choosing from a predefined menu of sizes.

Guides and demonstrations

The video:

• Explains Zig’s integer-width options and how width differs from ordinary memory allocation.
• Demonstrates range checking and overflow behavior.
• Shows how to model and parse an IPv4 header byte with a Zig packed struct.
• Compares Zig packed structs with C bit-fields and C23 _BitInt.

Main speaker and sources

• Main speaker: Code Guild narrator; the video is presented as a single-speaker explanation.
• Sources discussed or referenced: Zig language documentation, C standards material on bit-fields and _BitInt, and the Linux kernel’s IPv4 header definitions.

Sponsor segment

The video includes a sponsor segment describing SerpApi as a service for retrieving structured, real-time web-search data through an API, including tools for AI workflows.