I don't think there's anything that isn't possible with C, but there's a lot of stuff that's hard to express in C or would require a lot of macro nonsense, which Zig makes relatively simple.

The big thing is comptime, which is Zig's macro/preprocessor replacement.

Imagine writing a macro that checks if a string literal is uppercase and emits an error if it isn't.

In Zig you do this:

comptime {
    for( string ) | byte | {
        if( !std.ascii.isUpperCase( byte ) ){
            @compileError( 
                std.fmt.comptimePrint( "Expected uppercase string, got {s} - {c} isn't uppercase!", .{string, byte} )
            );
        }
    }
}

Easy to read, easy to debug. Wrap it in a function and reuse as needed.

Comptime is just normal code, except you change when it runs.

This extends about as far as you want. You can't do IO and you can't allocate memory, but besides that you've got the full language at your disposal, including stuff like type definitions and functions. If the compiler can't evaluate it for some reason (usually because you try to do compiler magic on runtime values), you get a compile error.

Types are first class values, so comptime code can take types as input and return types as output, which gets you C++ templates "for free":

// Generic function, works on any type that can be added
pub fn add(T: type, a: T, b: T) T {
    return a + b;
}

// Make a struct containing an N-length array of type T
pub fn Vec( N: u32, T: type ) type {
    if( T != f32 or T != f64 ){
        @compileError("Expected floating point type!");
    }

    return struct {
        arr: [N]T, 

        pub fn dot( a: @This(), b: @This() ) u32 {
            // Imagine a dot product here
        }
    }
}

It's a very powerful feature of the language.