Odin, Zig and Jai: Three Bets on What Replaces C in Games and Embedded

C has powered games and firmware for five decades. Yet a new wave of “C, but survivable” languages now asks a fair question: what would we keep, and what would we finally fix?

Why C Still Needs a Successor

C is fast, small and understood everywhere. However, it also leaves memory safety, build systems and tooling entirely to you. Game studios and firmware teams feel that pain daily, especially in large codebases.

Three projects answer with very different philosophies. Zig improves the toolchain, Odin simplifies the language, and Jai chases raw programmer speed. Let’s look at each one in turn.

Meet the Contenders

Zig: The Toolchain Play

Zig, created by Andrew Kelley, first appeared in 2016 as a general-purpose improvement to C. Its signature ideas are explicit allocators, compile-time code execution and a build system written in Zig itself. Moreover, its compiler can act as a drop-in C compiler through zig cc, which is a huge help when you must live alongside existing C code.

The project is also moving fast. Zig 0.16.0 arrived on April 14, 2026, after eight months of work by 244 contributors, and it introduced “I/O as an Interface”. Notably, the project migrated from GitHub to Codeberg in November 2025. Zig is still pre-1.0, but production projects such as Bun and TigerBeetle already rely on it.

Odin: The Pragmatic Game Tool

Odin, designed by Bill Hall (better known as Ginger Bill), began in July 2016 as an alternative to C built around data-oriented design. It skips classes and inheritance, and it adds built-in SOA data types, array programming and a handy “context” system for passing things like allocators. In addition, its “vendor” libraries bundle bindings for popular tools such as raylib, SDL3 and Vulkan.

Odin already ships real products. According to the official site, JangaFX builds EmberGen, GeoGen and LiquiGen entirely in Odin. The release rhythm is steady too: dev-2026-09 landed on September 1. For embedded work, recent releases added Playdate support through a freestanding ARM target and a restricted -bedrock subset mode.

Jai: The Long-Awaited Outsider

Jai comes from Jonathan Blow, the designer behind Braid and The Witness. Development started in 2014, and the compiler is still in a closed, invite-only beta. Unlike the other two, it targets C++ more than C, and it stresses compile-time metaprogramming and very fast builds.

The proof point is close. Blow’s puzzle game Order of the Sinking Star was built in Jai and is scheduled for October 8, 2026. Reports say its roughly 80,000-line codebase compiles in under a second, although that figure comes from demos and secondary write-ups, so treat it as a claim rather than a benchmark. Thekla has also said the engine will be released as open source after launch.

Side by Side

The table below condenses the key facts. Please note that Jai’s details rely on public statements, because outsiders cannot yet download the compiler.

A Quick Look at the Code

Let’s compare how Zig and Odin handle the same small job: allocate four numbers, fill them with squares and free the memory. Both snippets were compiled and run on Linux x86-64 with Zig 0.16.0 and Odin dev-2026-09. I left Jai out, since I cannot run its compiler.

Here is the Zig version. The allocator is passed in by hand, so every allocation is visible.

const std = @import("std");

pub fn main() !void {
    var gpa: std.heap.DebugAllocator(.{}) = .init;
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    const numbers = try allocator.alloc(u32, 4);
    defer allocator.free(numbers);

    for (numbers, 0..) |*n, i| n.* = @intCast(i * i);
    std.debug.print("squares: {any}\n", .{numbers});
}

Run it with the command below. It prints squares: { 0, 1, 4, 9 } to standard error.

zig run squares.zig

Now the Odin version. Here the default allocator comes from the implicit context, so the code stays shorter.

package main

import "core:fmt"

main :: proc() {
	numbers := make([]u32, 4)
	defer delete(numbers)

	for &n, i in numbers {
		n = u32(i * i)
	}
	fmt.println("squares:", numbers)
}

Run it like this. It prints squares: [0, 1, 4, 9]. On Linux, Odin also needs clang on your PATH, because it uses it to link the final program.

odin run squares.odin -file

The contrast is telling. Zig makes you say where memory comes from, while Odin hides that detail behind a sensible default you can still override.

What the Numbers Say

To add some real data, I built the same program in C, Zig and Odin, then stripped every binary. The chart shows the results in kilobytes for a speed-tuned and a size-tuned build.

Therefore, size alone will not crown a winner. Still, one point stands out: Zig’s size-tuned build is the smallest of the two new languages, and it carries its runtime inside the binary.

Community sentiment tells a second story. In the 2025 Stack Overflow Developer Survey, Zig was admired by 64.2% of the developers who had used it, according to a summary of the results. Odin barely registers in that survey and Jai is absent, so the chart below covers Zig only.

Which One Should You Pick?

If you need to ship something today, Zig and Odin are your realistic options. Choose Zig when cross-compiling, embedded targets or mixing with existing C matter most. Pick Odin when you want a small, readable language with game-friendly libraries built in.

Jai deserves a watch rather than a download. After October 8, we will finally see how its claims hold up outside one studio.

What We Have Learned

Zig, Odin and Jai share one goal but pursue it differently. Zig bets on a stronger toolchain and explicit control, and it is public, pre-1.0 and used by projects like Bun and TigerBeetle. Odin bets on simplicity and data-oriented design, and it ships monthly releases while powering JangaFX’s tools. Jai bets on programmer speed and fast builds, yet it remains in closed beta until Order of the Sinking Star launches. In our small test, both Zig and Odin produced working programs, but their binaries differed widely in size depending on runtime choices. In short, pick Zig or Odin now, and keep an eye on Jai.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.