What’s the most cursed Zig you can write? I’d like to see some code that makes your skin scrawl, or mutter to yourself “wtf is this?”.
Some ideas to get you started:
setjump and longjumpI am guilty for both: zig-recover/src/recover.zig at main · dimdin/zig-recover · GitHub
Not really cursed, more just unintuitive and non-obvious, but it was recently pointed out to me that there’s nothing stopping you from adding a main function to your build.zig and using it as the root source file for your executable:
const std = @import("std");
pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
const exe = b.addExecutable(.{
.name = "foo",
.root_module = b.createModule(.{
.root_source_file = b.path("build.zig"),
.target = target,
.optimize = optimize,
}),
});
b.installArtifact(exe);
const run_exe = b.addRunArtifact(exe);
run_exe.addArgs(b.args orelse &.{});
run_exe.step.dependOn(b.getInstallStep());
const run = b.step("run", "Run the app");
run.dependOn(&run_exe.step);
}
pub fn main() void {
std.debug.print("Hello, World!\n", .{});
}
This can actually be a useful way to organize code if you need to run small snippets of auxiliary Zig code (code generation, etc.) as part of your build but don’t want to put the code in its own source file.
The incantation which removes the safety tag from a bare union in all modes is fairly cursed.
pub const CursedUnion: type = cursed: {
@setRuntimeSafety(false);
break :cursed union {
a: u64,
b: i32,
c: [8]u8,
};
};
Cursed enough that posting it summoned Andrew Kelly to decry this scurrilous behavior, and demand that the answer be unmarked as correct, when I posted it to answer the question “how do I remove the hidden tag from bare unions in safe modes”.
It does do that.
I hereby nominate Auguste’s global thermonuclear comptime state as the most cursed Zig ever
I tried to write a grid/matrix that uses @Vector as the data. I gave it functions like rotate that generates a @shuffle mask at comptime. It does work for smaller grids but there is a limit before the compiler seg faults.
I’ve no idea if this is cursed or not!
pub fn Matrix(comptime T: type, comptime width: usize, comptime height: usize) type {
return struct {
const Self = @This();
data: @Vector(width * height, T) = @splat(0),
/// Rotate 90deg clockwise
pub fn rotate(self: *Self) void {
const mask: @Vector(width * height, i32) = comptime calc: {
var array = [_]i32{0} ** (width * height);
for (0..height) |y| for (0..width) |x| {
array[width * y + width - x - 1] = width * x + y;
};
break :calc array;
};
self.data = @shuffle(T, self.data, undefined, mask);
}
};
}
For your consideration:
// in build.zig
module.addAnonymousImport("something", .{
.root_source_file = dependency.artifact("something").getEmittedBin(),
});
// in root.zig
pub fn runEmbeddedExe(arena: std.mem.Allocator, comptime exe_name: []const u8) !std.process.Child.RunResult {
const compiled_program = @embedFile(exe_name);
const exe_file = try std.fs.cwd().createFile(exe_name, .{ .mode = 0o700 });
defer std.fs.cwd().deleteFile(exe_name) catch |err| std.debug.panic("Failed to delete exe: {s}, Error: {!}\n", .{ exe_name, err });
try exe_file.writeAll(compiled_program);
exe_file.close();
return try std.process.Child.run(.{
.allocator = arena,
.argv = &[_][]const u8{
"./" ++ exe_name,
},
});
}
// in main.zig
const result = try runEmbeddedExe(arena, "something");
I don’t know if this is cursed, but once, I wanted to have a CLI in my GUI, so I needed a function lookup table that could store functions with different signatures. But, I didn’t want to bother with parsing string arguments for every function. I just wanted to define a function, put it into a hash map with a name, retrieve it from the map, and call it. That’s it.
So, I created a function that takes and then returns another function containing the parsing logic. I don’t know if this approach is good, but the name is too good to not use.
pub const FuncType = *const fn ([]const Token) CommandRunError!void;
pub fn beholdMyFunctionInator(comptime function: anytype) FuncType {
const fn_info = @typeInfo(@TypeOf(function)).@"fn";
return struct {
pub fn inator(tokens: []const Token) CommandRunError!void {
if (fn_info.params.len == 0) {
function();
return;
}
if (tokens.len < fn_info.params.len) {
return CommandRunError.MissingArgs;
} else if (tokens.len > fn_info.params.len) {
return CommandRunError.ExtraArgs;
}
const Tuple = std.meta.ArgsTuple(@TypeOf(function));
var args_tuple: Tuple = undefined;
inline for (args_tuple, 0..) |_, index| {
const TupleElement = @TypeOf(args_tuple[index]);
switch (@typeInfo(TupleElement)) {
.int => {
args_tuple[index] = switch (tokens[index]) {
inline else => |v| try toInt(TupleElement, v),
};
},
.float => {
args_tuple[index] = switch (tokens[index]) {
inline else => |v| try toFloat(TupleElement, v),
};
},
.pointer => {
if (TupleElement != []const u8)
@compileError("`[]const u8` is the only pointer and slice type allowed but you have provided " ++
"`" ++ @typeName(TupleElement) ++ "`");
args_tuple[index] = switch (tokens[index]) {
.string => |string| string,
else => return CommandRunError.FunctionCommandMismatchedTypes,
};
},
.bool => {
args_tuple[index] = switch (tokens[index]) {
.bool => |b| b,
else => return CommandRunError.FunctionCommandMismatchedTypes,
};
},
else => @compileError("Only types allowed are `[]const u8`, `bool`, signed and unsigned ints and floats"),
}
}
@call(.auto, function, args_tuple);
}
}.inator;
}
fn toInt(comptime Int: type, value: anytype) !Int {
if (@typeInfo(Int) != .int) @compileError("`Int` must be an integer type");
return switch (@typeInfo(@TypeOf(value))) {
.int => @intCast(value),
.float => @intFromFloat(value),
else => return CommandRunError.FunctionCommandMismatchedTypes,
};
}
fn toFloat(comptime Float: type, value: anytype) !Float {
if (@typeInfo(Float) != .float) @compileError("`Float` must be an integer type");
return switch (@typeInfo(@TypeOf(value))) {
.int => @floatFromInt(value),
.float => @floatCast(value),
else => return CommandRunError.FunctionCommandMismatchedTypes,
};
}
From TigerBeetle’s new module for random numbers:
test "no floating point please" {
const file_text = try std.fs.cwd().readFileAlloc(std.testing.allocator, @src().file, 64 * 1024);
defer std.testing.allocator.free(file_text);
assert(std.mem.indexOf(u8, file_text, "f" ++ "32") == null);
assert(std.mem.indexOf(u8, file_text, "f" ++ "64") == null);
}
From TigerBeetle’s build script:
// Use 'zig fetch' to download and unpack the specified URL, optionally verifying the checksum.
fn fetch(b: *std.Build, options: struct {
url: []const u8,
file_name: []const u8,
hash: ?[]const u8,
}) std.Build.LazyPath {
const copy_from_cache = b.addRunArtifact(b.addExecutable(.{
.name = "copy-from-cache",
.root_source_file = b.addWriteFiles().add("main.zig",
\\const builtin = @import("builtin");
\\const std = @import("std");
\\const assert = std.debug.assert;
\\
\\pub fn main() !void {
\\ var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
\\ const allocator = arena.allocator();
\\ const args = try std.process.argsAlloc(allocator);
\\ assert(args.len == 5 or args.len == 6);
\\
\\ const hash_and_newline = try std.fs.cwd().readFileAlloc(allocator, args[2], 128);
\\ assert(hash_and_newline[hash_and_newline.len - 1] == '\n');
\\ const hash = hash_and_newline[0 .. hash_and_newline.len - 1];
\\ if (args.len == 6 and !std.mem.eql(u8, args[5], hash)) {
\\ std.debug.panic(
\\ \\bad hash
\\ \\specified: {s}
\\ \\downloaded: {s}
\\ \\
\\ , .{ args[5], hash });
\\ }
\\
\\ const source_path = try std.fs.path.join(allocator, &.{ args[1], hash, args[3] });
\\ try std.fs.cwd().copyFile(
\\ source_path,
\\ std.fs.cwd(),
\\ args[4],
\\ // TODO(Zig): https://github.com/ziglang/zig/pull/21555
\\ .{ .override_mode = if (builtin.target.os.tag == .macos) 0o777 else null },
\\ );
\\}
),
.target = b.graph.host,
}));
copy_from_cache.addArg(
b.graph.global_cache_root.join(b.allocator, &.{"p"}) catch @panic("OOM"),
);
copy_from_cache.addFileArg(
b.addSystemCommand(&.{ b.graph.zig_exe, "fetch", options.url }).captureStdOut(),
);
copy_from_cache.addArg(options.file_name);
const result = copy_from_cache.addOutputFileArg(options.file_name);
if (options.hash) |hash| {
copy_from_cache.addArg(hash);
}
return result;
}
Based on What's the most cursed Zig you can write? - #13 by castholm and making it more cursed, so it becomes a “self-extracting” single-file raylib example:
const std = @import("std");
pub fn build(b: *std.Build) !void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
if (std.fs.cwd().createFile("build.zig.zon", .{ .exclusive = true })) |file| {
defer file.close();
std.debug.print("extracting build.zig.zon\n", .{});
const hash = "raylib-5.5.0-whq8uGZGzQDi3_L7tJzgEINoZN-HwmOs0zkkc2g7ysIZ";
// zig fmt: off
try file.writeAll(
\\.{
\\ .name = .foo,
\\ .fingerprint = 0x8c73652187ca3158,
\\ .version = "0.0.0",
\\ .minimum_zig_version = "0.14.0",
\\ .dependencies = .{
\\ .raylib = .{
\\ .url = "git+https://github.com/raysan5/raylib#bbeade636cd8c90e18b7e9e841c20b5f8bd15d94",
++ " .hash = \"" ++ hash ++ "\",\n" ++
\\ },
\\ },
\\ .paths = .{
\\ "build.zig",
\\ "build.zig.zon",
\\ },
\\}
);
// zig fmt: on
// trigger download of dependency and rebuild
b.graph.needed_lazy_dependencies.put(b.graph.arena, hash, {}) catch @panic("OOM");
return;
} else |err| {
if (err != error.PathAlreadyExists) return err;
}
const root = b.createModule(.{
.root_source_file = b.path("build.zig"),
.target = target,
.optimize = optimize,
});
const exe = b.addExecutable(.{
.name = "foo",
.root_module = root,
});
exe.linkLibC();
if (b.available_deps.len > 0) {
const raylib_dep = b.dependency("raylib", .{
.target = target,
.optimize = optimize,
.rmodels = false,
});
const files = b.addWriteFiles();
const translate_header = files.add("rayheaders.h",
\\#include <raylib.h>
\\#include <raymath.h>
\\#include <rlgl.h>
);
const raylib_translate = b.addTranslateC(.{
.link_libc = true,
.target = target,
.optimize = optimize,
.root_source_file = translate_header,
});
raylib_translate.addIncludePath(raylib_dep.path("src"));
root.addImport("ray", raylib_translate.createModule());
exe.linkLibrary(raylib_dep.artifact("raylib"));
}
b.installArtifact(exe);
const run_exe = b.addRunArtifact(exe);
run_exe.addArgs(b.args orelse &.{});
run_exe.step.dependOn(b.getInstallStep());
const run = b.step("run", "Run the app");
run.dependOn(&run_exe.step);
}
pub fn main() !void {
const ray = @import("ray");
const width = 800;
const height = 450;
ray.SetConfigFlags(ray.FLAG_MSAA_4X_HINT | ray.FLAG_VSYNC_HINT);
ray.InitWindow(width, height, "zig raylib example");
defer ray.CloseWindow();
while (!ray.WindowShouldClose()) {
ray.BeginDrawing();
defer ray.EndDrawing();
ray.ClearBackground(ray.WHITE);
ray.DrawText("Hello World!", 40, 40, 20, ray.BLACK);
ray.DrawFPS(width - 100, 10);
}
}
A bit late but if think its pretty cursed.
Generaly in zig you can’t have declarations on generated types but I bypass it by checking if there is existing type with needed combination of fields and if so return it instead of creating new type.
it burnses us
pub fn emit(s: []const u8) !void {
if (builtin.os.tag == .windows) {
var sz: win32.DWORD = 0;
const rv = win32.WriteConsoleA(g_tty_win, s.ptr, @intCast(s.len), &sz, undefined);
if (rv == 0) {
return;
}
return;
} else {
const sz = try stdout.write(s);
if (sz == 0) {
return;
}
return;
}
}
i learned how to skip tests today
even though it’s not a “project” but a built in feature i’d say this would make the list
test "hi hello" {
if (true) return error.SkipZigTest;
// test
}
A list of dynamically typed items during compile time. Does it count?
My most horrible zig code. A sort of anti “zig fmt”
Cursed as in fragile and I’m afraid to touch it!
pub fn methods(comptime Self: type, comptime RawPtr: type) type {
return struct {
const type_name = @typeName(RawPtr);
const ptr_name = type_name[(std.mem.indexOf(u8, type_name, "struct_Fl_") orelse 0) + 7 .. type_name.len];
pub inline fn call(self: *Self, comptime method: []const u8, args: anytype) @TypeOf(@call(.auto, @field(c, ptr_name ++ "_" ++ method), .{self.raw()} ++ args)) {
return @call(.auto, @field(c, ptr_name ++ "_" ++ method), .{self.raw()} ++ args);
}
pub inline fn fromDynWidget(other: anytype) ?*Self {
if (@field(c, ptr_name ++ "_from_dyn_ptr")(@ptrCast(@alignCast(other)))) |o| {
return Self.fromRaw(o);
}
return null;
}
pub inline fn show(self: *Self) void {
@field(c, ptr_name ++ "_show")(self.raw());
}
pub inline fn hide(self: *Self) void {
@field(c, ptr_name ++ "_hide")(self.raw());
}
pub inline fn resize(self: *Self, _x: i32, _y: i32, _w: u31, _h: u31) void {
@field(c, ptr_name ++ "_resize")(self.raw(), _x, _y, _w, _h);
}
// rest of methods
const std = @import("std");
pub fn Result(comptime T: type, comptime E: type) type {
return union(enum) {
const Self = @This();
ok: T,
err: E,
pub fn wrap(res: E!T) Self {
if (res) |v| {
return .{ .ok = v };
} else |e| {
return .{ .err = e };
}
}
pub fn unwrap(self: Self) T {
std.debug.assert(std.meta.activeTag(self) == .ok);
return self.ok;
}
pub fn unwrapOrErr(self: Self) E!T {
return if (std.meta.activeTag(self) == .ok) self.ok else return self.err;
}
pub fn unwrapOrNull(self: Self) ?T {
return if (std.meta.activeTag(self) == .ok) self.ok else return null;
}
};
}
pub const FooError = error{
wrong,
};
pub fn foo(x: u32) Result(@TypeOf(x), FooError) {
if (x == 4) {
return .{ .ok = x };
} else {
return .{ .err = error.wrong };
}
}
pub fn failingFoo(x: u32) FooError!u32 {
return if (x == 4) x else error.wrong;
}
test "b" {
const r = foo(4);
switch (r) {
.ok => |v| std.debug.print("{d}", .{v}),
.err => |e| std.debug.print("{!}", .{e}),
}
}
This is the most cursed code that I use from time to time but kinda useful at least for the aesthetic 
I like the match statement kind of feeling.