Blockchain in Zig

2026-11-03T00:00:00+00:00

A blockchain is a sequence of data blocks. The integrity of an individual data Block is established by signing it with a hash. The integrity of the complete sequence of blocks is established by ensuring the hash of each Block includes the hash of the previous block.

Each block is signed by hashing its contents along with the hash from the previous block.

Consider this simple Block:

pub const Block = struct {
    pub const hash_length = 32;

    data: []const u8,
    when: i96,
    hash: [hash_length]u8,
}

Zig convention is to avoid defining magic numbers as global or top level variabes, the Block hash_length is declared inside the Block struct.

Bitcoin is signed with sha256 and Ethereum is signed with a slightly more modern and secure¹ keccak256:

fn calculateHash(
    data: []const u8,
    now: i96,
    previous_hash: []const u8,
) [hash_length]u8 {
    //var h = std.crypto.hash.sha2.Sha256.init(.{});
    var h = std.crypto.hash.sha3.Keccak256.init(.{});
    h.update(previous_hash); // Add previous hash to the hash
    h.update(data);          // Add `data` to the hash
    var buffer: [@bitSizeOf(i96) / @bitSizeOf(u8)]u8 = undefined;
    std.mem.writeInt(i96, &buffer, now, .little);
    h.update(&buffer);       // Add `now` timestamp to the hash
    return h.finalResult();
}

A basic Blockchain holds an array collection of Block entries, and provides a way to append new blocks to the chain.

In zig, the Block struct would commonly be nested in the Blockchain struct so that it nested into the Blockchain namespace.

pub const Blockchain = struct {

    pub const Block = struct { ... };

    blocks: std.ArrayList(Block) = .empty,

    pub fn append(
        self: *Blockchain,
        allocator: Allocator,
        io: std.Io,
        data: []const u8,
    ) Allocator.Error!void {
        const now = std.Io.Clock.now(.real, io).toNanoseconds();
        if (self.blocks.lastPtr()) |block| {
            try self.blocks.append(allocator, .{
                .data = try allocator.dupe(u8, data),
                .when = now,
                .hash = calculateHash(data, now, previous_hash),
            });
        } else {
            const zero: [Block.hash_length]u8 = @splat(0);
            try self.blocks.append(allocator, .{
                .data = try allocator.dupe(u8, data),
                .when = now,
                .hash = calculateHash(data, now, &zero),
            });
        }
    }
};

The append function does not simply hash the data and the when timestamp. It includes the hash of the previous block, or a zero filled hash for the first block.

Tying it all together, with appropriate init and deinit functions, here is a complete working example of a minimal Blockchain in zig:

pub const Blockchain = struct {
    blocks: std.ArrayList(Block),

    pub const empty: Blockchain = .{
        .blocks = .empty,
    };

    pub fn deinit(self: *Blockchain, allocator: Allocator) void {
        for (self.blocks.items) |*block| {
            block.deinit(allocator);
        }
        self.blocks.deinit(allocator);
        self.* = undefined;
    }

    /// A block contains both an aribrary `data` byte sequence,
    /// and the `previous_hash` of the previous block.
    pub const Block = struct {
        pub const hash_length = 32;
        pub const zero: [hash_length]u8 = @splat(0);

        data: []const u8,
        when: i96,
        hash: [hash_length]u8,

        pub fn init(
            allocator: std.mem.Allocator,
            io: std.Io,
            data: []const u8,
            previous_hash: ?*const [hash_length]u8,
        ) Allocator.Error!Block {
            const now = std.Io.Clock.now(.real, io).toNanoseconds();
            return .{
                .data = try allocator.dupe(u8, data),
                .when = now,
                .hash = calculateHash(data, now, previous_hash orelse &zero),
            };
        }

        pub fn deinit(self: *Block, allocator: Allocator) void {
            allocator.free(self.data);
            self.* = undefined;
        }

        fn calculateHash(
            data: []const u8,
            now: i96,
            previous_hash: []const u8,
        ) [hash_length]u8 {
            var h = std.crypto.hash.sha3.Keccak256.init(.{});
            //var h = std.crypto.hash.sha2.Sha256.init(.{});
            h.update(data);
            var buffer: [@bitSizeOf(i96) / @bitSizeOf(u8)]u8 = undefined;
            std.mem.writeInt(i96, &buffer, now, .little);
            h.update(&buffer);
            h.update(previous_hash);
            return h.finalResult();
        }
    };

    pub fn append(
        self: *Blockchain,
        allocator: Allocator,
        io: std.Io,
        data: []const u8,
    ) Allocator.Error!void {
        if (self.blocks.lastPtr()) |block| {
            try self.blocks.append(allocator, try .init(allocator, io, data, &block.hash));
        } else {
            try self.blocks.append(allocator, try .init(allocator, io, data, null));
        }
    }
};

Finally, we need a validate function to check the contents of the Blockchain. This is achieved by starting at the first block, and recalculating the hash of each block:

pub fn validate(self: *Blockchain) bool {
    var previous: ?*Block = null;
    for (self.blocks.items) |*block| {
        const hash = Block.calculateHash(
            block.data,
            block.when,
            if (previous) |p| &p.hash else &Block.zero,
        );
        if (!std.mem.eql(u8, &hash, &block.hash)) return false;
        previous = block;
    }
    return true;
}

Added — November 2026

A complete working zig example, including addtional blockchain load and save example functions is available on github.

Ethereum's keccak256 vs Bitcoin's SHA-256

How to reliably save game state

2020-01-09T00:00:00+00:00

How to reliably save game state?

How do you safely and reliably save your game state? Create a function that serializes all game state into a text or binary format. This may include player scores, achievements, backpack contents, map location. Create another function to deserialize from this text or binary format back into your game memory.

pub const GameState = struct {
    pub const save_filename = "game.dat";

    score: u64,
    achievements: ArrayList(Achievement),

    // Convert the game state to a data string.
    pub fn serialize(state: *GameState) []const u8 { ... }

    // Convert save file data back into game state.
    pub fn deserialize(state: *GameState) []const u8 { ... }

    // Save the data string to disk
    pub fn save(state: *const GameState) !void { ... }
}

The mistake people commonly make, is to overwrite the existing game file with the new data. The problem with this, if the write fails, you may end up with an empty or incomplete game state file.

First write the game state to a temporary file such as game.json.202302050150 and after writing succeeds, rename/move the temporary file into the place of the game.json file.

/// Save the game state
pub fn save(state: *const GameState, gpa: std.mem.Allocator) !void {
    // Add the current time to the save filename
    const temp_name = try std.fmt.allocPrint(gpa, "{s}.{d}", .{
        save_filename,
        std.time.milliTimestamp(),
    });
    defer gpa.free(temp_name);

    // Step 1: Write the game state to a temporary file.
    const data = state.serialize();
    var file = try std.fs.cwd().createFile(temp_name, .{});
    defer file.close();
    _ = file.write(data) catch {
        return;
    };

    // Step 2: move the temporary file onto the real file.
    try std.fs.cwd().rename(temp_name, save_filename);
}

loftafi

Blockchain in Zig

How to reliably save game state

How to reliably save game state?