build: update to Zig 0.11.0

2023-10-16 16:18:36 +02:00
parent 7f30c655c7
commit 2e586c7061
54 changed files with 333 additions and 363 deletions
--- a/.builds/alpine.yml
+++ b/.builds/alpine.yml
@ -39,11 +39,11 @@ tasks:
      sudo ninja -C build/ install
      cd ..

-      wget -nv https://ziglang.org/download/0.10.0/zig-linux-x86_64-0.10.0.tar.xz
+      wget -nv https://ziglang.org/download/0.11.0/zig-linux-x86_64-0.11.0.tar.xz
      # Remove a lot of useless lines from tar output.
-      tar -xvf zig-linux-x86_64-0.10.0.tar.xz 1>/dev/null
-      sudo mv zig-linux-x86_64-0.10.0/zig /usr/bin/
-      sudo mv zig-linux-x86_64-0.10.0/lib /usr/lib/zig
+      tar -xvf zig-linux-x86_64-0.11.0.tar.xz 1>/dev/null
+      sudo mv zig-linux-x86_64-0.11.0/zig /usr/bin/
+      sudo mv zig-linux-x86_64-0.11.0/lib /usr/lib/zig
  - build: |
      cd river
      zig build
--- a/.builds/archlinux.yml
+++ b/.builds/archlinux.yml
@ -37,11 +37,11 @@ tasks:
      sudo ninja -C build/ install
      cd ..

-      wget -nv https://ziglang.org/download/0.10.0/zig-linux-x86_64-0.10.0.tar.xz
+      wget -nv https://ziglang.org/download/0.11.0/zig-linux-x86_64-0.11.0.tar.xz
      # Remove a lot of useless lines from tar output.
-      tar -xvf zig-linux-x86_64-0.10.0.tar.xz 1>/dev/null
-      sudo mv zig-linux-x86_64-0.10.0/zig /usr/bin/
-      sudo mv zig-linux-x86_64-0.10.0/lib /usr/lib/zig
+      tar -xvf zig-linux-x86_64-0.11.0.tar.xz 1>/dev/null
+      sudo mv zig-linux-x86_64-0.11.0/zig /usr/bin/
+      sudo mv zig-linux-x86_64-0.11.0/lib /usr/lib/zig
  - build: |
      cd river
      zig build
--- a/.builds/freebsd.yml
+++ b/.builds/freebsd.yml
@ -41,11 +41,11 @@ tasks:
      sudo ninja -C build/ install
      cd ..

-      wget -nv https://ziglang.org/download/0.10.0/zig-freebsd-x86_64-0.10.0.tar.xz
+      wget -nv https://ziglang.org/download/0.11.0/zig-freebsd-x86_64-0.11.0.tar.xz
      # Remove a lot of useless lines from tar output.
-      tar -xvf zig-freebsd-x86_64-0.10.0.tar.xz 1>/dev/null
-      sudo mv zig-freebsd-x86_64-0.10.0/zig /usr/bin/
-      sudo mv zig-freebsd-x86_64-0.10.0/lib /usr/lib/zig
+      tar -xvf zig-freebsd-x86_64-0.11.0.tar.xz 1>/dev/null
+      sudo mv zig-freebsd-x86_64-0.11.0/zig /usr/bin/
+      sudo mv zig-freebsd-x86_64-0.11.0/lib /usr/lib/zig
  - build: |
      cd river
      zig build
--- a/.gitignore
+++ b/.gitignore
@ -1,3 +1,2 @@
 zig-cache/
 zig-out/
-doc/*.[1-9]
--- a/README.md
+++ b/README.md
@ -35,7 +35,7 @@ To compile river first ensure that you have the following dependencies
 installed. The "development" versions are required if applicable to your
 distribution.

- [zig](https://ziglang.org/download/) 0.10
+- [zig](https://ziglang.org/download/) 0.11
 - wayland
 - wayland-protocols
 - [wlroots](https://gitlab.freedesktop.org/wlroots/wlroots) 0.16
@ -47,7 +47,7 @@ distribution.

 Then run, for example:
 ```
-zig build -Drelease-safe --prefix ~/.local install
+zig build -Doptimize=ReleaseSafe --prefix ~/.local install
 ```
 To enable experimental Xwayland support pass the `-Dxwayland` option as well.

--- a/build.zig
+++ b/build.zig
@ -1,10 +1,10 @@
 const std = @import("std");
 const assert = std.debug.assert;
+const Build = std.Build;
 const fs = std.fs;
 const mem = std.mem;
-const zbs = std.build;

-const ScanProtocolsStep = @import("deps/zig-wayland/build.zig").ScanProtocolsStep;
+const Scanner = @import("deps/zig-wayland/build.zig").Scanner;

 /// While a river release is in development, this string should contain the version in development
 /// with the "-dev" suffix.
@ -12,9 +12,9 @@ const ScanProtocolsStep = @import("deps/zig-wayland/build.zig").ScanProtocolsSte
 /// Directly after the tagged commit, the version should be bumped and the "-dev" suffix added.
 const version = "0.3.0-dev";

-pub fn build(b: *zbs.Builder) !void {
+pub fn build(b: *Build) !void {
    const target = b.standardTargetOptions(.{});
-    const mode = b.standardReleaseOptions();
+    const optimize = b.standardOptimizeOption(.{});

    const strip = b.option(bool, "strip", "Omit debug information") orelse false;
    const pie = b.option(bool, "pie", "Build a Position Independent Executable") orelse false;
@ -24,7 +24,7 @@ pub fn build(b: *zbs.Builder) !void {
        "man-pages",
        "Set to true to build man pages. Requires scdoc. Defaults to true if scdoc is found.",
    ) orelse scdoc_found: {
-        _ = b.findProgram(&[_][]const u8{"scdoc"}, &[_][]const u8{}) catch |err| switch (err) {
+        _ = b.findProgram(&.{"scdoc"}, &.{}) catch |err| switch (err) {
            error.FileNotFound => break :scdoc_found false,
            else => return err,
        };
@ -60,12 +60,12 @@ pub fn build(b: *zbs.Builder) !void {
            var ret: u8 = undefined;

            const git_describe_long = b.execAllowFail(
-                &[_][]const u8{ "git", "-C", b.build_root, "describe", "--long" },
+                &.{ "git", "-C", b.build_root.path orelse ".", "describe", "--long" },
                &ret,
                .Inherit,
            ) catch break :blk version;

-            var it = mem.split(u8, mem.trim(u8, git_describe_long, &std.ascii.spaces), "-");
+            var it = mem.split(u8, mem.trim(u8, git_describe_long, &std.ascii.whitespace), "-");
            _ = it.next().?; // previous tag
            const commit_count = it.next().?;
            const commit_hash = it.next().?;
@ -73,10 +73,7 @@ pub fn build(b: *zbs.Builder) !void {
            assert(commit_hash[0] == 'g');

            // Follow semantic versioning, e.g. 0.2.0-dev.42+d1cf95b
-            break :blk try std.fmt.allocPrintZ(b.allocator, version ++ ".{s}+{s}", .{
-                commit_count,
-                commit_hash[1..],
-            });
+            break :blk b.fmt(version ++ ".{s}+{s}", .{ commit_count, commit_hash[1..] });
        } else {
            break :blk version;
        }
@ -86,17 +83,19 @@ pub fn build(b: *zbs.Builder) !void {
    options.addOption(bool, "xwayland", xwayland);
    options.addOption([]const u8, "version", full_version);

-    const scanner = ScanProtocolsStep.create(b);
+    const scanner = Scanner.create(b, .{});
+
    scanner.addSystemProtocol("stable/xdg-shell/xdg-shell.xml");
    scanner.addSystemProtocol("staging/ext-session-lock/ext-session-lock-v1.xml");
    scanner.addSystemProtocol("unstable/pointer-gestures/pointer-gestures-unstable-v1.xml");
    scanner.addSystemProtocol("unstable/pointer-constraints/pointer-constraints-unstable-v1.xml");
    scanner.addSystemProtocol("unstable/xdg-decoration/xdg-decoration-unstable-v1.xml");
-    scanner.addProtocolPath("protocol/river-control-unstable-v1.xml");
-    scanner.addProtocolPath("protocol/river-status-unstable-v1.xml");
-    scanner.addProtocolPath("protocol/river-layout-v3.xml");
-    scanner.addProtocolPath("protocol/wlr-layer-shell-unstable-v1.xml");
-    scanner.addProtocolPath("protocol/wlr-output-power-management-unstable-v1.xml");
+
+    scanner.addCustomProtocol("protocol/river-control-unstable-v1.xml");
+    scanner.addCustomProtocol("protocol/river-status-unstable-v1.xml");
+    scanner.addCustomProtocol("protocol/river-layout-v3.xml");
+    scanner.addCustomProtocol("protocol/wlr-layer-shell-unstable-v1.xml");
+    scanner.addCustomProtocol("protocol/wlr-output-power-management-unstable-v1.xml");

    // These must be manually kept in sync with the versions wlroots supports
    // until wlroots gives the option to request a specific version.
@ -120,72 +119,77 @@ pub fn build(b: *zbs.Builder) !void {
    scanner.generate("zwlr_layer_shell_v1", 4);
    scanner.generate("zwlr_output_power_manager_v1", 1);

+    const wayland = b.createModule(.{ .source_file = scanner.result });
+    const xkbcommon = b.createModule(.{
+        .source_file = .{ .path = "deps/zig-xkbcommon/src/xkbcommon.zig" },
+    });
+    const pixman = b.createModule(.{
+        .source_file = .{ .path = "deps/zig-pixman/pixman.zig" },
+    });
+    const wlroots = b.createModule(.{
+        .source_file = .{ .path = "deps/zig-wlroots/src/wlroots.zig" },
+        .dependencies = &.{
+            .{ .name = "wayland", .module = wayland },
+            .{ .name = "xkbcommon", .module = xkbcommon },
+            .{ .name = "pixman", .module = pixman },
+        },
+    });
+
+    const flags = b.createModule(.{ .source_file = .{ .path = "common/flags.zig" } });
+    const globber = b.createModule(.{ .source_file = .{ .path = "common/globber.zig" } });
+
    {
-        const river = b.addExecutable("river", "river/main.zig");
-        river.setTarget(target);
-        river.setBuildMode(mode);
+        const river = b.addExecutable(.{
+            .name = "river",
+            .root_source_file = .{ .path = "river/main.zig" },
+            .target = target,
+            .optimize = optimize,
+        });
        river.addOptions("build_options", options);

-        const wayland = zbs.Pkg{
-            .name = "wayland",
-            .source = .{ .generated = &scanner.result },
-        };
-        const xkbcommon = zbs.Pkg{
-            .name = "xkbcommon",
-            .source = .{ .path = "deps/zig-xkbcommon/src/xkbcommon.zig" },
-        };
-        const pixman = zbs.Pkg{
-            .name = "pixman",
-            .source = .{ .path = "deps/zig-pixman/pixman.zig" },
-        };
-        const wlroots = zbs.Pkg{
-            .name = "wlroots",
-            .source = .{ .path = "deps/zig-wlroots/src/wlroots.zig" },
-            .dependencies = &[_]zbs.Pkg{ wayland, xkbcommon, pixman },
-        };
-
-        river.step.dependOn(&scanner.step);
-
        river.linkLibC();
        river.linkSystemLibrary("libevdev");
        river.linkSystemLibrary("libinput");

-        river.addPackage(wayland);
+        river.addModule("wayland", wayland);
        river.linkSystemLibrary("wayland-server");

-        river.addPackage(xkbcommon);
+        river.addModule("xkbcommon", xkbcommon);
        river.linkSystemLibrary("xkbcommon");

-        river.addPackage(pixman);
+        river.addModule("pixman", pixman);
        river.linkSystemLibrary("pixman-1");

-        river.addPackage(wlroots);
+        river.addModule("wlroots", wlroots);
        river.linkSystemLibrary("wlroots");

-        river.addPackagePath("flags", "common/flags.zig");
-        river.addPackagePath("globber", "common/globber.zig");
-        river.addCSourceFile("river/wlroots_log_wrapper.c", &[_][]const u8{ "-std=c99", "-O2" });
+        river.addModule("flags", flags);
+        river.addModule("globber", globber);
+        river.addCSourceFile(.{
+            .file = .{ .path = "river/wlroots_log_wrapper.c" },
+            .flags = &.{ "-std=c99", "-O2" },
+        });

        // TODO: remove when zig issue #131 is implemented
        scanner.addCSource(river);

        river.strip = strip;
        river.pie = pie;
-        river.install();
+
+        b.installArtifact(river);
    }

    {
-        const riverctl = b.addExecutable("riverctl", "riverctl/main.zig");
-        riverctl.setTarget(target);
-        riverctl.setBuildMode(mode);
+        const riverctl = b.addExecutable(.{
+            .name = "riverctl",
+            .root_source_file = .{ .path = "riverctl/main.zig" },
+            .target = target,
+            .optimize = optimize,
+        });
        riverctl.addOptions("build_options", options);

-        riverctl.step.dependOn(&scanner.step);
-        riverctl.addPackagePath("flags", "common/flags.zig");
-        riverctl.addPackage(.{
-            .name = "wayland",
-            .source = .{ .generated = &scanner.result },
-        });
+        riverctl.addModule("flags", flags);
+        riverctl.addModule("wayland", wayland);
        riverctl.linkLibC();
        riverctl.linkSystemLibrary("wayland-client");

@ -193,21 +197,21 @@ pub fn build(b: *zbs.Builder) !void {

        riverctl.strip = strip;
        riverctl.pie = pie;
-        riverctl.install();
+
+        b.installArtifact(riverctl);
    }

    {
-        const rivertile = b.addExecutable("rivertile", "rivertile/main.zig");
-        rivertile.setTarget(target);
-        rivertile.setBuildMode(mode);
+        const rivertile = b.addExecutable(.{
+            .name = "rivertile",
+            .root_source_file = .{ .path = "rivertile/main.zig" },
+            .target = target,
+            .optimize = optimize,
+        });
        rivertile.addOptions("build_options", options);

-        rivertile.step.dependOn(&scanner.step);
-        rivertile.addPackagePath("flags", "common/flags.zig");
-        rivertile.addPackage(.{
-            .name = "wayland",
-            .source = .{ .generated = &scanner.result },
-        });
+        rivertile.addModule("flags", flags);
+        rivertile.addModule("wayland", wayland);
        rivertile.linkLibC();
        rivertile.linkSystemLibrary("wayland-client");

@ -215,15 +219,13 @@ pub fn build(b: *zbs.Builder) !void {

        rivertile.strip = strip;
        rivertile.pie = pie;
-        rivertile.install();
+
+        b.installArtifact(rivertile);
    }

    {
-        const file = try fs.path.join(b.allocator, &[_][]const u8{ b.cache_root, "river-protocols.pc" });
-        const pkgconfig_file = try fs.cwd().createFile(file, .{});
-
-        const writer = pkgconfig_file.writer();
-        try writer.print(
+        const wf = Build.Step.WriteFile.create(b);
+        const pc_file = wf.add("river-protocols.pc", b.fmt(
            \\prefix={s}
            \\datadir=${{prefix}}/share
            \\pkgdatadir=${{datadir}}/river-protocols
@ -232,16 +234,23 @@ pub fn build(b: *zbs.Builder) !void {
            \\URL: https://github.com/riverwm/river
            \\Description: protocol files for the river wayland compositor
            \\Version: {s}
-        , .{ b.install_prefix, full_version });
-        defer pkgconfig_file.close();
+        , .{ b.install_prefix, full_version }));

        b.installFile("protocol/river-layout-v3.xml", "share/river-protocols/river-layout-v3.xml");
-        b.installFile(file, "share/pkgconfig/river-protocols.pc");
+        b.getInstallStep().dependOn(&b.addInstallFile(pc_file, "share/pkgconfig/river-protocols.pc").step);
    }

    if (man_pages) {
-        const scdoc_step = ScdocStep.create(b);
-        try scdoc_step.install();
+        inline for (.{ "river", "riverctl", "rivertile" }) |page| {
+            // Workaround for https://github.com/ziglang/zig/issues/16369
+            // Even passing a buffer to std.Build.Step.Run appears to be racy and occasionally deadlocks.
+            const scdoc = b.addSystemCommand(&.{ "/bin/sh", "-c", "scdoc < doc/" ++ page ++ ".1.scd" });
+            // This makes the caching work for the Workaround, and the extra argument is ignored by /bin/sh.
+            scdoc.addFileArg(.{ .path = "doc/" ++ page ++ ".1.scd" });
+
+            const stdout = scdoc.captureStdOut();
+            b.getInstallStep().dependOn(&b.addInstallFile(stdout, "share/man/man1/" ++ page ++ ".1").step);
+        }
    }

    if (bash_completion) {
@ -257,65 +266,14 @@ pub fn build(b: *zbs.Builder) !void {
    }

    {
-        const globber_test = b.addTest("common/globber.zig");
-        globber_test.setTarget(target);
-        globber_test.setBuildMode(mode);
+        const globber_test = b.addTest(.{
+            .root_source_file = .{ .path = "common/globber.zig" },
+            .target = target,
+            .optimize = optimize,
+        });
+        const run_globber_test = b.addRunArtifact(globber_test);

        const test_step = b.step("test", "Run the tests");
-        test_step.dependOn(&globber_test.step);
+        test_step.dependOn(&run_globber_test.step);
    }
 }
-
-const ScdocStep = struct {
-    const scd_paths = [_][]const u8{
-        "doc/river.1.scd",
-        "doc/riverctl.1.scd",
-        "doc/rivertile.1.scd",
-    };
-
-    builder: *zbs.Builder,
-    step: zbs.Step,
-
-    fn create(builder: *zbs.Builder) *ScdocStep {
-        const self = builder.allocator.create(ScdocStep) catch @panic("out of memory");
-        self.* = init(builder);
-        return self;
-    }
-
-    fn init(builder: *zbs.Builder) ScdocStep {
-        return ScdocStep{
-            .builder = builder,
-            .step = zbs.Step.init(.custom, "Generate man pages", builder.allocator, make),
-        };
-    }
-
-    fn make(step: *zbs.Step) !void {
-        const self = @fieldParentPtr(ScdocStep, "step", step);
-        for (scd_paths) |path| {
-            const command = try std.fmt.allocPrint(
-                self.builder.allocator,
-                "scdoc < {s} > {s}",
-                .{ path, path[0..(path.len - 4)] },
-            );
-            _ = try self.builder.exec(&[_][]const u8{ "sh", "-c", command });
-        }
-    }
-
-    fn install(self: *ScdocStep) !void {
-        self.builder.getInstallStep().dependOn(&self.step);
-
-        for (scd_paths) |path| {
-            const path_no_ext = path[0..(path.len - 4)];
-            const basename_no_ext = fs.path.basename(path_no_ext);
-            const section = path_no_ext[(path_no_ext.len - 1)..];
-
-            const output = try std.fmt.allocPrint(
-                self.builder.allocator,
-                "share/man/man{s}/{s}",
-                .{ section, basename_no_ext },
-            );
-
-            self.builder.installFile(path_no_ext, output);
-        }
-    }
-};
--- a/common/flags.zig
+++ b/common/flags.zig
@ -41,14 +41,14 @@ pub fn parser(comptime Arg: type, comptime flags: []const Flag) type {
                    const field: std.builtin.Type.StructField = switch (flag.kind) {
                        .boolean => .{
                            .name = flag.name,
-                            .field_type = bool,
+                            .type = bool,
                            .default_value = &false,
                            .is_comptime = false,
                            .alignment = @alignOf(bool),
                        },
                        .arg => .{
                            .name = flag.name,
-                            .field_type = ?[:0]const u8,
+                            .type = ?[:0]const u8,
                            .default_value = &@as(?[:0]const u8, null),
                            .is_comptime = false,
                            .alignment = @alignOf(?[:0]const u8),
@ -70,8 +70,13 @@ pub fn parser(comptime Arg: type, comptime flags: []const Flag) type {

            var i: usize = 0;
            outer: while (i < args.len) : (i += 1) {
+                const arg = switch (Arg) {
+                    [*:0]const u8 => mem.sliceTo(args[i], 0),
+                    [:0]const u8 => args[i],
+                    else => unreachable,
+                };
                inline for (flags) |flag| {
-                    if (mem.eql(u8, "-" ++ flag.name, mem.span(args[i]))) {
+                    if (mem.eql(u8, "-" ++ flag.name, arg)) {
                        switch (flag.kind) {
                            .boolean => @field(result_flags, flag.name) = true,
                            .arg => {
@ -81,7 +86,11 @@ pub fn parser(comptime Arg: type, comptime flags: []const Flag) type {
                                        "' requires an argument but none was provided!", .{});
                                    return error.MissingFlagArgument;
                                }
-                                @field(result_flags, flag.name) = mem.span(args[i]);
+                                @field(result_flags, flag.name) = switch (Arg) {
+                                    [*:0]const u8 => mem.sliceTo(args[i], 0),
+                                    [:0]const u8 => args[i],
+                                    else => unreachable,
+                                };
                            },
                        }
                        continue :outer;
--- a/common/globber.zig
+++ b/common/globber.zig
@ -34,19 +34,19 @@ pub fn validate(glob: []const u8) error{InvalidGlob}!void {
 test validate {
    const testing = std.testing;

-    _ = try validate("*");
-    _ = try validate("a");
-    _ = try validate("*a");
-    _ = try validate("a*");
-    _ = try validate("*a*");
-    _ = try validate("ab");
-    _ = try validate("*ab");
-    _ = try validate("ab*");
-    _ = try validate("*ab*");
-    _ = try validate("abc");
-    _ = try validate("*abc");
-    _ = try validate("abc*");
-    _ = try validate("*abc*");
+    try validate("*");
+    try validate("a");
+    try validate("*a");
+    try validate("a*");
+    try validate("*a*");
+    try validate("ab");
+    try validate("*ab");
+    try validate("ab*");
+    try validate("*ab*");
+    try validate("abc");
+    try validate("*abc");
+    try validate("abc*");
+    try validate("*abc*");

    try testing.expectError(error.InvalidGlob, validate(""));
    try testing.expectError(error.InvalidGlob, validate("**"));
@ -165,8 +165,8 @@ pub fn order(a: []const u8, b: []const u8) std.math.Order {
        return .lt;
    }

-    const count_a = @as(u2, @boolToInt(a[0] == '*')) + @boolToInt(a[a.len - 1] == '*');
-    const count_b = @as(u2, @boolToInt(b[0] == '*')) + @boolToInt(b[b.len - 1] == '*');
+    const count_a = @as(u2, @intFromBool(a[0] == '*')) + @intFromBool(a[a.len - 1] == '*');
+    const count_b = @as(u2, @intFromBool(b[0] == '*')) + @intFromBool(b[b.len - 1] == '*');

    if (count_a == 0 and count_b == 0) {
        return .eq;
@ -206,7 +206,7 @@ test order {
        "a",
    };

-    for (descending) |a, i| {
+    for (descending, 0..) |a, i| {
        for (descending[i..]) |b| {
            try testing.expect(order(a, b) != .lt);
        }
@ -215,7 +215,7 @@ test order {
    var ascending = descending;
    mem.reverse([]const u8, &ascending);

-    for (ascending) |a, i| {
+    for (ascending, 0..) |a, i| {
        for (ascending[i..]) |b| {
            try testing.expect(order(a, b) != .gt);
        }
--- a/deps/zig-pixman
+++ b/deps/zig-pixman
--- a/deps/zig-wayland
+++ b/deps/zig-wayland
--- a/deps/zig-wlroots
+++ b/deps/zig-wlroots
--- a/deps/zig-xkbcommon
+++ b/deps/zig-xkbcommon
--- a/river/Control.zig
+++ b/river/Control.zig
@ -71,7 +71,7 @@ fn handleRequest(control: *zriver.ControlV1, request: zriver.ControlV1.Request,
    switch (request) {
        .destroy => control.destroy(),
        .add_argument => |add_argument| {
-            const owned_slice = util.gpa.dupeZ(u8, mem.span(add_argument.argument)) catch {
+            const owned_slice = util.gpa.dupeZ(u8, mem.sliceTo(add_argument.argument, 0)) catch {
                control.getClient().postNoMemory();
                return;
            };
@ -84,7 +84,7 @@ fn handleRequest(control: *zriver.ControlV1, request: zriver.ControlV1.Request,
            };
        },
        .run_command => |run_command| {
-            const seat = @intToPtr(*Seat, wlr.Seat.Client.fromWlSeat(run_command.seat).?.seat.data);
+            const seat: *Seat = @ptrFromInt(wlr.Seat.Client.fromWlSeat(run_command.seat).?.seat.data);

            const callback = zriver.CommandCallbackV1.create(
                control.getClient(),
@ -109,7 +109,7 @@ fn handleRequest(control: *zriver.ControlV1, request: zriver.ControlV1.Request,
                        callback.getClient().postNoMemory();
                        return;
                    },
-                    command.Error.Other => std.cstr.addNullByte(util.gpa, out.?) catch {
+                    command.Error.Other => util.gpa.dupeZ(u8, out.?) catch {
                        callback.getClient().postNoMemory();
                        return;
                    },
--- a/river/Cursor.zig
+++ b/river/Cursor.zig
@ -287,8 +287,8 @@ pub fn setTheme(self: *Self, theme: ?[*:0]const u8, _size: ?u32) !void {
                image.width * 4,
                image.width,
                image.height,
-                @intCast(i32, image.hotspot_x),
-                @intCast(i32, image.hotspot_y),
+                @intCast(image.hotspot_x),
+                @intCast(image.hotspot_y),
            );
        }

@ -427,7 +427,7 @@ fn updateKeyboardFocus(self: Self, result: Root.AtResult) void {
 /// Requires a call to Root.applyPending()
 fn updateOutputFocus(self: Self, lx: f64, ly: f64) void {
    if (server.root.output_layout.outputAt(lx, ly)) |wlr_output| {
-        const output = @intToPtr(*Output, wlr_output.data);
+        const output: *Output = @ptrFromInt(wlr_output.data);
        self.seat.focusOutput(output);
    }
 }
@ -712,8 +712,8 @@ pub fn startMove(cursor: *Self, view: *View) void {

    const new_mode: Mode = .{ .move = .{
        .view = view,
-        .offset_x = @floatToInt(i32, cursor.wlr_cursor.x) - view.current.box.x,
-        .offset_y = @floatToInt(i32, cursor.wlr_cursor.y) - view.current.box.y,
+        .offset_x = @as(i32, @intFromFloat(cursor.wlr_cursor.x)) - view.current.box.x,
+        .offset_y = @as(i32, @intFromFloat(cursor.wlr_cursor.y)) - view.current.box.y,
    } };
    cursor.enterMode(new_mode, view, .move);
 }
@ -733,8 +733,8 @@ pub fn startResize(cursor: *Self, view: *View, proposed_edges: ?wlr.Edges) void
    };

    const box = &view.current.box;
-    const lx = @floatToInt(i32, cursor.wlr_cursor.x);
-    const ly = @floatToInt(i32, cursor.wlr_cursor.y);
+    const lx: i32 = @intFromFloat(cursor.wlr_cursor.x);
+    const ly: i32 = @intFromFloat(cursor.wlr_cursor.y);
    const offset_x = if (edges.left) lx - box.x else box.x + box.width - lx;
    const offset_y = if (edges.top) ly - box.y else box.y + box.height - ly;

@ -756,13 +756,13 @@ fn computeEdges(cursor: *const Self, view: *const View) wlr.Edges {
    var output_box: wlr.Box = undefined;
    server.root.output_layout.getBox(view.current.output.?.wlr_output, &output_box);

-    const sx = @floatToInt(i32, cursor.wlr_cursor.x) - output_box.x - box.x;
-    const sy = @floatToInt(i32, cursor.wlr_cursor.y) - output_box.y - box.y;
+    const sx = @as(i32, @intFromFloat(cursor.wlr_cursor.x)) - output_box.x - box.x;
+    const sy = @as(i32, @intFromFloat(cursor.wlr_cursor.y)) - output_box.y - box.y;

    var edges: wlr.Edges = .{};

    if (box.width > min_handle_size * 2) {
-        const handle = math.max(min_handle_size, @divFloor(box.width, 5));
+        const handle = @max(min_handle_size, @divFloor(box.width, 5));
        if (sx < handle) {
            edges.left = true;
        } else if (sx > box.width - handle) {
@ -771,7 +771,7 @@ fn computeEdges(cursor: *const Self, view: *const View) wlr.Edges {
    }

    if (box.height > min_handle_size * 2) {
-        const handle = math.max(min_handle_size, @divFloor(box.height, 5));
+        const handle = @max(min_handle_size, @divFloor(box.height, 5));
        if (sy < handle) {
            edges.top = true;
        } else if (sy > box.height - handle) {
@ -863,7 +863,7 @@ fn processMotion(self: *Self, device: *wlr.InputDevice, time: u32, delta_x: f64,
            data.delta_y = dy - @trunc(dy);

            if (tag == .move) {
-                data.view.pending.move(@floatToInt(i32, dx), @floatToInt(i32, dy));
+                data.view.pending.move(@intFromFloat(dx), @intFromFloat(dy));
            } else {
                // Modify width/height of the pending box, taking constraints into account
                // The x/y coordinates of the view will be adjusted as needed in View.resizeCommit()
@ -880,31 +880,31 @@ fn processMotion(self: *Self, device: *wlr.InputDevice, time: u32, delta_x: f64,
                if (data.edges.left) {
                    var x1 = box.x;
                    const x2 = box.x + box.width;
-                    x1 += @floatToInt(i32, dx);
-                    x1 = math.max(x1, border_width);
-                    x1 = math.max(x1, x2 - constraints.max_width);
-                    x1 = math.min(x1, x2 - constraints.min_width);
+                    x1 += @intFromFloat(dx);
+                    x1 = @max(x1, border_width);
+                    x1 = @max(x1, x2 - constraints.max_width);
+                    x1 = @min(x1, x2 - constraints.min_width);
                    box.width = x2 - x1;
                } else if (data.edges.right) {
-                    box.width += @floatToInt(i32, dx);
-                    box.width = math.max(box.width, constraints.min_width);
-                    box.width = math.min(box.width, constraints.max_width);
-                    box.width = math.min(box.width, output_width - border_width - box.x);
+                    box.width += @intFromFloat(dx);
+                    box.width = @max(box.width, constraints.min_width);
+                    box.width = @min(box.width, constraints.max_width);
+                    box.width = @min(box.width, output_width - border_width - box.x);
                }

                if (data.edges.top) {
                    var y1 = box.y;
                    const y2 = box.y + box.height;
-                    y1 += @floatToInt(i32, dy);
-                    y1 = math.max(y1, border_width);
-                    y1 = math.max(y1, y2 - constraints.max_height);
-                    y1 = math.min(y1, y2 - constraints.min_height);
+                    y1 += @intFromFloat(dy);
+                    y1 = @max(y1, border_width);
+                    y1 = @max(y1, y2 - constraints.max_height);
+                    y1 = @min(y1, y2 - constraints.min_height);
                    box.height = y2 - y1;
                } else if (data.edges.bottom) {
-                    box.height += @floatToInt(i32, dy);
-                    box.height = math.max(box.height, constraints.min_height);
-                    box.height = math.min(box.height, constraints.max_height);
-                    box.height = math.min(box.height, output_height - border_width - box.y);
+                    box.height += @intFromFloat(dy);
+                    box.height = @max(box.height, constraints.min_height);
+                    box.height = @min(box.height, constraints.max_height);
+                    box.height = @min(box.height, output_height - border_width - box.y);
                }
            }

@ -943,8 +943,9 @@ fn updateFocusFollowsCursorTarget(self: *Self) void {
                // in order to avoid clashes with cursor warping on focus change.
                var output_layout_box: wlr.Box = undefined;
                server.root.output_layout.getBox(view.current.output.?.wlr_output, &output_layout_box);
-                const cursor_ox = self.wlr_cursor.x - @intToFloat(f64, output_layout_box.x);
-                const cursor_oy = self.wlr_cursor.y - @intToFloat(f64, output_layout_box.y);
+
+                const cursor_ox = self.wlr_cursor.x - @as(f64, @floatFromInt(output_layout_box.x));
+                const cursor_oy = self.wlr_cursor.y - @as(f64, @floatFromInt(output_layout_box.y));
                if (view.current.box.containsPoint(cursor_ox, cursor_oy)) {
                    self.focus_follows_cursor_target = view;
                }
@ -981,7 +982,7 @@ pub fn updateState(self: *Self) void {
            if (!self.hidden) {
                var now: os.timespec = undefined;
                os.clock_gettime(os.CLOCK.MONOTONIC, &now) catch @panic("CLOCK_MONOTONIC not supported");
-                const msec = @intCast(u32, now.tv_sec * std.time.ms_per_s +
+                const msec: u32 = @intCast(now.tv_sec * std.time.ms_per_s +
                    @divTrunc(now.tv_nsec, std.time.ns_per_ms));
                self.passthrough(msec);
            }
@ -998,20 +999,20 @@ pub fn updateState(self: *Self) void {

            // Keep the cursor locked to the original offset from the edges of the view.
            const box = &data.view.current.box;
-            const new_x = blk: {
+            const new_x: f64 = blk: {
                if (mode == .move or data.edges.left) {
-                    break :blk @intToFloat(f64, data.offset_x + box.x);
+                    break :blk @floatFromInt(data.offset_x + box.x);
                } else if (data.edges.right) {
-                    break :blk @intToFloat(f64, box.x + box.width - data.offset_x);
+                    break :blk @floatFromInt(box.x + box.width - data.offset_x);
                } else {
                    break :blk self.wlr_cursor.x;
                }
            };
-            const new_y = blk: {
+            const new_y: f64 = blk: {
                if (mode == .move or data.edges.top) {
-                    break :blk @intToFloat(f64, data.offset_y + box.y);
+                    break :blk @floatFromInt(data.offset_y + box.y);
                } else if (data.edges.bottom) {
-                    break :blk @intToFloat(f64, box.y + box.height - data.offset_y);
+                    break :blk @floatFromInt(box.y + box.height - data.offset_y);
                } else {
                    break :blk self.wlr_cursor.y;
                }
@ -1083,8 +1084,8 @@ fn warp(self: *Self) void {
        (usable_layout_box.containsPoint(self.wlr_cursor.x, self.wlr_cursor.y) and
        !target_box.containsPoint(self.wlr_cursor.x, self.wlr_cursor.y)))
    {
-        const lx = @intToFloat(f64, target_box.x + @divTrunc(target_box.width, 2));
-        const ly = @intToFloat(f64, target_box.y + @divTrunc(target_box.height, 2));
+        const lx: f64 = @floatFromInt(target_box.x + @divTrunc(target_box.width, 2));
+        const ly: f64 = @floatFromInt(target_box.y + @divTrunc(target_box.height, 2));
        if (!self.wlr_cursor.warp(null, lx, ly)) {
            log.err("failed to warp cursor on focus change", .{});
        }
@ -1094,7 +1095,7 @@ fn warp(self: *Self) void {
 fn updateDragIcons(self: *Self) void {
    var it = server.root.drag_icons.children.iterator(.forward);
    while (it.next()) |node| {
-        const icon = @intToPtr(*DragIcon, node.data);
+        const icon = @as(*DragIcon, @ptrFromInt(node.data));

        if (icon.wlr_drag_icon.drag.seat != self.seat.wlr_seat) continue;

@ -1102,16 +1103,16 @@ fn updateDragIcons(self: *Self) void {
            .keyboard => unreachable,
            .keyboard_pointer => {
                icon.tree.node.setPosition(
-                    @floatToInt(c_int, self.wlr_cursor.x),
-                    @floatToInt(c_int, self.wlr_cursor.y),
+                    @intFromFloat(self.wlr_cursor.x),
+                    @intFromFloat(self.wlr_cursor.y),
                );
            },
            .keyboard_touch => {
                const touch_id = icon.wlr_drag_icon.drag.touch_id;
                const point = self.touch_points.get(touch_id) orelse continue;
                icon.tree.node.setPosition(
-                    @floatToInt(c_int, point.lx),
-                    @floatToInt(c_int, point.ly),
+                    @intFromFloat(point.lx),
+                    @intFromFloat(point.ly),
                );
            },
        }
--- a/river/DragIcon.zig
+++ b/river/DragIcon.zig
@ -47,7 +47,7 @@ pub fn create(wlr_drag_icon: *wlr.Drag.Icon) error{OutOfMemory}!void {
        .tree = tree,
        .surface = try tree.createSceneSubsurfaceTree(wlr_drag_icon.surface),
    };
-    tree.node.data = @ptrToInt(drag_icon);
+    tree.node.data = @intFromPtr(drag_icon);

    tree.node.setEnabled(wlr_drag_icon.mapped);

--- a/river/ForeignToplevelHandle.zig
+++ b/river/ForeignToplevelHandle.zig
@ -89,7 +89,7 @@ fn handleForeignActivate(
 ) void {
    const handle = @fieldParentPtr(ForeignToplevelHandle, "foreign_activate", listener);
    const view = @fieldParentPtr(View, "foreign_toplevel_handle", handle);
-    const seat = @intToPtr(*Seat, event.seat.data);
+    const seat: *Seat = @ptrFromInt(event.seat.data);

    seat.focus(view);
    server.root.applyPending();
--- a/river/InputConfig.zig
+++ b/river/InputConfig.zig
@ -281,10 +281,7 @@ pub fn deinit(self: *Self) void {
 }

 pub fn apply(self: *Self, device: *InputDevice) void {
-    const libinput_device = @ptrCast(
-        *c.libinput_device,
-        device.wlr_device.getLibinputDevice() orelse return,
-    );
+    const libinput_device: *c.libinput_device = @ptrCast(device.wlr_device.getLibinputDevice() orelse return);
    log.debug("applying input configuration to device: {s}", .{device.identifier});
    if (self.event_state) |setting| setting.apply(libinput_device);
    if (self.accel_profile) |setting| setting.apply(libinput_device);
--- a/river/InputDevice.zig
+++ b/river/InputDevice.zig
@ -57,13 +57,13 @@ pub fn init(device: *InputDevice, seat: *Seat, wlr_device: *wlr.InputDevice) !vo
            device_type,
            wlr_device.vendor,
            wlr_device.product,
-            mem.trim(u8, mem.span(wlr_device.name), &ascii.spaces),
+            mem.trim(u8, mem.sliceTo(wlr_device.name, 0), &ascii.whitespace),
        },
    );
    errdefer util.gpa.free(identifier);

    for (identifier) |*char| {
-        if (!ascii.isGraph(char.*)) {
+        if (!ascii.isPrint(char.*) or ascii.isWhitespace(char.*)) {
            char.* = '_';
        }
    }
--- a/river/InputManager.zig
+++ b/river/InputManager.zig
@ -145,7 +145,7 @@ fn handleNewVirtualKeyboard(
    _: *wl.Listener(*wlr.VirtualKeyboardV1),
    virtual_keyboard: *wlr.VirtualKeyboardV1,
 ) void {
-    const seat = @intToPtr(*Seat, virtual_keyboard.seat.data);
+    const seat: *Seat = @ptrFromInt(virtual_keyboard.seat.data);
    seat.addDevice(&virtual_keyboard.keyboard.base);
 }

--- a/river/Keyboard.zig
+++ b/river/Keyboard.zig
@ -47,7 +47,7 @@ pub fn init(self: *Self, seat: *Seat, wlr_device: *wlr.InputDevice) !void {
    errdefer self.device.deinit();

    const wlr_keyboard = self.device.wlr_device.toKeyboard();
-    wlr_keyboard.data = @ptrToInt(self);
+    wlr_keyboard.data = @intFromPtr(self);

    // wlroots will log a more detailed error if this fails.
    if (!wlr_keyboard.setKeymap(server.config.keymap)) return error.OutOfMemory;
@ -127,7 +127,7 @@ fn handleKey(listener: *wl.Listener(*wlr.Keyboard.event.Key), event: *wlr.Keyboa
 }

 fn isModifier(keysym: xkb.Keysym) bool {
-    return @enumToInt(keysym) >= xkb.Keysym.Shift_L and @enumToInt(keysym) <= xkb.Keysym.Hyper_R;
+    return @intFromEnum(keysym) >= xkb.Keysym.Shift_L and @intFromEnum(keysym) <= xkb.Keysym.Hyper_R;
 }

 fn handleModifiers(listener: *wl.Listener(*wlr.Keyboard), _: *wlr.Keyboard) void {
@ -144,12 +144,12 @@ fn handleModifiers(listener: *wl.Listener(*wlr.Keyboard), _: *wlr.Keyboard) void
 /// Handle any builtin, harcoded compsitor mappings such as VT switching.
 /// Returns true if the keysym was handled.
 fn handleBuiltinMapping(keysym: xkb.Keysym) bool {
-    switch (@enumToInt(keysym)) {
+    switch (@intFromEnum(keysym)) {
        xkb.Keysym.XF86Switch_VT_1...xkb.Keysym.XF86Switch_VT_12 => {
            log.debug("switch VT keysym received", .{});
            if (server.backend.isMulti()) {
                if (server.backend.getSession()) |session| {
-                    const vt = @enumToInt(keysym) - xkb.Keysym.XF86Switch_VT_1 + 1;
+                    const vt = @intFromEnum(keysym) - xkb.Keysym.XF86Switch_VT_1 + 1;
                    const log_server = std.log.scoped(.server);
                    log_server.info("switching to VT {}", .{vt});
                    session.changeVt(vt) catch log_server.err("changing VT failed", .{});
--- a/river/KeycodeSet.zig
+++ b/river/KeycodeSet.zig
@ -28,8 +28,8 @@ len: usize = 0,
 pub fn add(self: *Self, new: u32) void {
    for (self.items[0..self.len]) |item| if (new == item) return;

-    comptime assert(@typeInfo(std.meta.fieldInfo(Self, .items).field_type).Array.len ==
-        @typeInfo(std.meta.fieldInfo(wlr.Keyboard, .keycodes).field_type).Array.len);
+    comptime assert(@typeInfo(std.meta.fieldInfo(Self, .items).type).Array.len ==
+        @typeInfo(std.meta.fieldInfo(wlr.Keyboard, .keycodes).type).Array.len);

    if (self.len == self.items.len) {
        log.err("KeycodeSet limit reached, code {d} omitted", .{new});
@ -41,7 +41,7 @@ pub fn add(self: *Self, new: u32) void {
 }

 pub fn remove(self: *Self, old: u32) bool {
-    for (self.items[0..self.len]) |item, idx| if (old == item) {
+    for (self.items[0..self.len], 0..) |item, idx| if (old == item) {
        self.len -= 1;
        if (self.len > 0) self.items[idx] = self.items[self.len];

--- a/river/LayerSurface.zig
+++ b/river/LayerSurface.zig
@ -43,7 +43,7 @@ commit: wl.Listener(*wlr.Surface) = wl.Listener(*wlr.Surface).init(handleCommit)
 new_popup: wl.Listener(*wlr.XdgPopup) = wl.Listener(*wlr.XdgPopup).init(handleNewPopup),

 pub fn create(wlr_layer_surface: *wlr.LayerSurfaceV1) error{OutOfMemory}!void {
-    const output = @intToPtr(*Output, wlr_layer_surface.output.?.data);
+    const output: *Output = @ptrFromInt(wlr_layer_surface.output.?.data);
    const layer_surface = try util.gpa.create(LayerSurface);
    errdefer util.gpa.destroy(layer_surface);

@ -55,12 +55,12 @@ pub fn create(wlr_layer_surface: *wlr.LayerSurfaceV1) error{OutOfMemory}!void {
        .scene_layer_surface = try layer_tree.createSceneLayerSurfaceV1(wlr_layer_surface),
        .popup_tree = try output.layers.popups.createSceneTree(),
    };
-    wlr_layer_surface.data = @ptrToInt(layer_surface);
+    wlr_layer_surface.data = @intFromPtr(layer_surface);

    try SceneNodeData.attach(&layer_surface.scene_layer_surface.tree.node, .{ .layer_surface = layer_surface });
    try SceneNodeData.attach(&layer_surface.popup_tree.node, .{ .layer_surface = layer_surface });

-    wlr_layer_surface.surface.data = @ptrToInt(&layer_surface.scene_layer_surface.tree.node);
+    wlr_layer_surface.surface.data = @intFromPtr(&layer_surface.scene_layer_surface.tree.node);

    wlr_layer_surface.events.destroy.add(&layer_surface.destroy);
    wlr_layer_surface.events.map.add(&layer_surface.map);
@ -131,7 +131,7 @@ fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
    // If a surface is committed while it is not mapped, we must send a configure.
    // TODO: this mapped check is not correct as it will be true in the commit
    // that triggers the unmap as well.
-    if (!wlr_layer_surface.mapped or @bitCast(u32, wlr_layer_surface.current.committed) != 0) {
+    if (!wlr_layer_surface.mapped or @as(u32, @bitCast(wlr_layer_surface.current.committed)) != 0) {
        layer_surface.output.arrangeLayers();
        handleKeyboardInteractiveExclusive(layer_surface.output);
        server.root.applyPending();
@ -150,7 +150,7 @@ fn handleKeyboardInteractiveExclusive(output: *Output) void {
        var it = tree.children.iterator(.reverse);
        while (it.next()) |node| {
            assert(node.type == .tree);
-            if (@intToPtr(?*SceneNodeData, node.data)) |node_data| {
+            if (@as(?*SceneNodeData, @ptrFromInt(node.data))) |node_data| {
                const layer_surface = node_data.data.layer_surface;
                const wlr_layer_surface = layer_surface.wlr_layer_surface;
                if (wlr_layer_surface.mapped and
--- a/river/Layout.zig
+++ b/river/Layout.zig
@ -109,8 +109,8 @@ pub fn startLayoutDemand(self: *Self, views: u32) void {

    self.layout.sendLayoutDemand(
        views,
-        @intCast(u32, self.output.usable_box.width),
-        @intCast(u32, self.output.usable_box.height),
+        @intCast(self.output.usable_box.width),
+        @intCast(self.output.usable_box.height),
        self.output.pending.tags,
        self.output.inflight.layout_demand.?.serial,
    );
@ -138,8 +138,8 @@ fn handleRequest(layout: *river.LayoutV3, request: river.LayoutV3.Request, self:
                layout_demand.pushViewDimensions(
                    req.x,
                    req.y,
-                    @intCast(u31, math.min(math.maxInt(u31), req.width)),
-                    @intCast(u31, math.min(math.maxInt(u31), req.height)),
+                    @min(math.maxInt(u31), req.width),
+                    @min(math.maxInt(u31), req.height),
                );
            }
        },
--- a/river/LayoutDemand.zig
+++ b/river/LayoutDemand.zig
@ -52,7 +52,7 @@ pub fn init(layout: *Layout, views: u32) !Self {

    return Self{
        .serial = server.wl_server.nextSerial(),
-        .views = @intCast(i32, views),
+        .views = @intCast(views),
        .view_boxen = try util.gpa.alloc(wlr.Box, views),
        .timeout_timer = timeout_timer,
    };
@ -86,7 +86,7 @@ pub fn pushViewDimensions(self: *Self, x: i32, y: i32, width: u31, height: u31)
        return;
    }

-    self.view_boxen[self.view_boxen.len - @intCast(usize, self.views)] = .{
+    self.view_boxen[self.view_boxen.len - @as(usize, @intCast(self.views))] = .{
        .x = x,
        .y = y,
        .width = width,
@ -114,7 +114,7 @@ pub fn apply(self: *Self, layout: *Layout) void {
    if (self.views != 0) {
        log.err(
            "proposed dimension count ({}) does not match view count ({}), aborting layout demand",
-            .{ -self.views + @intCast(i32, self.view_boxen.len), self.view_boxen.len },
+            .{ -self.views + @as(i32, @intCast(self.view_boxen.len)), self.view_boxen.len },
        );
        layout.layout.postError(
            .count_mismatch,
--- a/river/LayoutManager.zig
+++ b/river/LayoutManager.zig
@ -68,7 +68,7 @@ fn handleRequest(
        .get_layout => |req| {
            // Ignore if the output is inert
            const wlr_output = wlr.Output.fromWlOutput(req.output) orelse return;
-            const output = @intToPtr(*Output, wlr_output.data);
+            const output: *Output = @ptrFromInt(wlr_output.data);

            log.debug("bind layout '{s}' on output '{s}'", .{ req.namespace, output.wlr_output.name });

@ -77,7 +77,7 @@ fn handleRequest(
                layout_manager.getVersion(),
                req.id,
                output,
-                mem.span(req.namespace),
+                mem.sliceTo(req.namespace, 0),
            ) catch {
                layout_manager.getClient().postNoMemory();
                log.err("out of memory", .{});
--- a/river/LockSurface.zig
+++ b/river/LockSurface.zig
@ -43,7 +43,7 @@ pub fn create(wlr_lock_surface: *wlr.SessionLockSurfaceV1, lock: *wlr.SessionLoc
        .wlr_lock_surface = wlr_lock_surface,
        .lock = lock,
    };
-    wlr_lock_surface.data = @ptrToInt(lock_surface);
+    wlr_lock_surface.data = @intFromPtr(lock_surface);

    const output = lock_surface.getOutput();
    const tree = try output.locked_content.createSceneSubsurfaceTree(wlr_lock_surface.surface);
@ -51,7 +51,7 @@ pub fn create(wlr_lock_surface: *wlr.SessionLockSurfaceV1, lock: *wlr.SessionLoc

    try SceneNodeData.attach(&tree.node, .{ .lock_surface = lock_surface });

-    wlr_lock_surface.surface.data = @ptrToInt(&tree.node);
+    wlr_lock_surface.surface.data = @intFromPtr(&tree.node);

    wlr_lock_surface.output.events.mode.add(&lock_surface.output_mode);
    wlr_lock_surface.events.map.add(&lock_surface.map);
@ -65,7 +65,7 @@ pub fn destroy(lock_surface: *LockSurface) void {
        var surface_it = lock_surface.lock.surfaces.iterator(.forward);
        const new_focus: Seat.FocusTarget = while (surface_it.next()) |surface| {
            if (surface != lock_surface.wlr_lock_surface)
-                break .{ .lock_surface = @intToPtr(*LockSurface, surface.data) };
+                break .{ .lock_surface = @ptrFromInt(surface.data) };
        } else .none;

        var seat_it = server.input_manager.seats.first;
@ -86,7 +86,7 @@ pub fn destroy(lock_surface: *LockSurface) void {
 }

 fn getOutput(lock_surface: *LockSurface) *Output {
-    return @intToPtr(*Output, lock_surface.wlr_lock_surface.output.data);
+    return @ptrFromInt(lock_surface.wlr_lock_surface.output.data);
 }

 fn handleOutputMode(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
@ -95,7 +95,7 @@ fn handleOutputMode(listener: *wl.Listener(*wlr.Output), _: *wlr.Output) void {
    var output_width: i32 = undefined;
    var output_height: i32 = undefined;
    lock_surface.getOutput().wlr_output.effectiveResolution(&output_width, &output_height);
-    _ = lock_surface.wlr_lock_surface.configure(@intCast(u32, output_width), @intCast(u32, output_height));
+    _ = lock_surface.wlr_lock_surface.configure(@intCast(output_width), @intCast(output_height));
 }

 fn handleMap(listener: *wl.Listener(void)) void {
--- a/river/Mapping.zig
+++ b/river/Mapping.zig
@ -45,7 +45,7 @@ pub fn init(
 ) !Self {
    const owned_args = try util.gpa.alloc([:0]u8, command_args.len);
    errdefer util.gpa.free(owned_args);
-    for (command_args) |arg, i| {
+    for (command_args, 0..) |arg, i| {
        errdefer for (owned_args[0..i]) |a| util.gpa.free(a);
        owned_args[i] = try util.gpa.dupeZ(u8, arg);
    }
--- a/river/Output.zig
+++ b/river/Output.zig
@ -257,7 +257,7 @@ pub fn create(wlr_output: *wlr.Output) !void {
        },
        .status = undefined,
    };
-    wlr_output.data = @ptrToInt(output);
+    wlr_output.data = @intFromPtr(output);

    output.pending.focus_stack.init();
    output.pending.wm_stack.init();
@ -299,7 +299,7 @@ pub fn layerSurfaceTree(self: Self, layer: zwlr.LayerShellV1.Layer) *wlr.SceneTr
        self.layers.top,
        self.layers.overlay,
    };
-    return trees[@intCast(usize, @enumToInt(layer))];
+    return trees[@intCast(@intFromEnum(layer))];
 }

 /// Arrange all layer surfaces of this output and adjust the usable area.
@ -336,7 +336,7 @@ fn sendLayerConfigures(
        var it = tree.children.iterator(.forward);
        while (it.next()) |node| {
            assert(node.type == .tree);
-            if (@intToPtr(?*SceneNodeData, node.data)) |node_data| {
+            if (@as(?*SceneNodeData, @ptrFromInt(node.data))) |node_data| {
                const layer_surface = node_data.data.layer_surface;

                const exclusive = layer_surface.wlr_layer_surface.current.exclusive_zone > 0;
--- a/river/PointerConstraint.zig
+++ b/river/PointerConstraint.zig
@ -47,7 +47,7 @@ set_region: wl.Listener(void) = wl.Listener(void).init(handleSetRegion),
 node_destroy: wl.Listener(void) = wl.Listener(void).init(handleNodeDestroy),

 pub fn create(wlr_constraint: *wlr.PointerConstraintV1) error{OutOfMemory}!void {
-    const seat = @intToPtr(*Seat, wlr_constraint.seat.data);
+    const seat: *Seat = @ptrFromInt(wlr_constraint.seat.data);

    const constraint = try util.gpa.create(PointerConstraint);
    errdefer util.gpa.destroy(constraint);
@ -55,7 +55,7 @@ pub fn create(wlr_constraint: *wlr.PointerConstraintV1) error{OutOfMemory}!void
    constraint.* = .{
        .wlr_constraint = wlr_constraint,
    };
-    wlr_constraint.data = @ptrToInt(constraint);
+    wlr_constraint.data = @intFromPtr(constraint);

    wlr_constraint.events.destroy.add(&constraint.destroy);
    wlr_constraint.events.set_region.add(&constraint.set_region);
@ -70,7 +70,7 @@ pub fn create(wlr_constraint: *wlr.PointerConstraintV1) error{OutOfMemory}!void
 }

 pub fn maybeActivate(constraint: *PointerConstraint) void {
-    const seat = @intToPtr(*Seat, constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);

    assert(seat.cursor.constraint == constraint);
    assert(seat.wlr_seat.keyboard_state.focused_surface == constraint.wlr_constraint.surface);
@ -82,8 +82,8 @@ pub fn maybeActivate(constraint: *PointerConstraint) void {
    const result = server.root.at(seat.cursor.wlr_cursor.x, seat.cursor.wlr_cursor.y) orelse return;
    if (result.surface != constraint.wlr_constraint.surface) return;

-    const sx = @floatToInt(i32, result.sx);
-    const sy = @floatToInt(i32, result.sy);
+    const sx: i32 = @intFromFloat(result.sx);
+    const sy: i32 = @intFromFloat(result.sy);
    if (!constraint.wlr_constraint.region.containsPoint(sx, sy, null)) return;

    assert(constraint.state == .inactive);
@ -103,7 +103,7 @@ pub fn maybeActivate(constraint: *PointerConstraint) void {

 /// Called when the cursor position or content in the scene graph changes
 pub fn updateState(constraint: *PointerConstraint) void {
-    const seat = @intToPtr(*Seat, constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);

    assert(seat.wlr_seat.keyboard_state.focused_surface == constraint.wlr_constraint.surface);

@ -119,8 +119,8 @@ pub fn updateState(constraint: *PointerConstraint) void {
        return;
    }

-    const warp_lx = @intToFloat(f64, lx) + constraint.state.active.sx;
-    const warp_ly = @intToFloat(f64, ly) + constraint.state.active.sy;
+    const warp_lx = @as(f64, @floatFromInt(lx)) + constraint.state.active.sx;
+    const warp_ly = @as(f64, @floatFromInt(ly)) + constraint.state.active.sy;
    if (!seat.cursor.wlr_cursor.warp(null, warp_lx, warp_ly)) {
        log.info("deactivating pointer constraint, could not warp cursor", .{});
        constraint.deactivate();
@ -147,7 +147,7 @@ pub fn confine(constraint: *PointerConstraint, dx: *f64, dy: *f64) void {
 }

 pub fn deactivate(constraint: *PointerConstraint) void {
-    const seat = @intToPtr(*Seat, constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);

    assert(seat.cursor.constraint == constraint);
    assert(constraint.state == .active);
@ -160,7 +160,7 @@ pub fn deactivate(constraint: *PointerConstraint) void {
 }

 fn warpToHintIfSet(constraint: *PointerConstraint) void {
-    const seat = @intToPtr(*Seat, constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);

    if (constraint.wlr_constraint.current.committed.cursor_hint) {
        var lx: i32 = undefined;
@ -169,7 +169,7 @@ fn warpToHintIfSet(constraint: *PointerConstraint) void {

        const sx = constraint.wlr_constraint.current.cursor_hint.x;
        const sy = constraint.wlr_constraint.current.cursor_hint.y;
-        _ = seat.cursor.wlr_cursor.warp(null, @intToFloat(f64, lx) + sx, @intToFloat(f64, ly) + sy);
+        _ = seat.cursor.wlr_cursor.warp(null, @as(f64, @floatFromInt(lx)) + sx, @as(f64, @floatFromInt(ly)) + sy);
        _ = seat.wlr_seat.pointerWarp(sx, sy);
    }
 }
@ -183,7 +183,7 @@ fn handleNodeDestroy(listener: *wl.Listener(void)) void {

 fn handleDestroy(listener: *wl.Listener(*wlr.PointerConstraintV1), _: *wlr.PointerConstraintV1) void {
    const constraint = @fieldParentPtr(PointerConstraint, "destroy", listener);
-    const seat = @intToPtr(*Seat, constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);

    if (constraint.state == .active) {
        // We can't simply call deactivate() here as it calls sendDeactivated(),
@ -205,12 +205,12 @@ fn handleDestroy(listener: *wl.Listener(*wlr.PointerConstraintV1), _: *wlr.Point

 fn handleSetRegion(listener: *wl.Listener(void)) void {
    const constraint = @fieldParentPtr(PointerConstraint, "set_region", listener);
-    const seat = @intToPtr(*Seat, constraint.wlr_constraint.seat.data);
+    const seat: *Seat = @ptrFromInt(constraint.wlr_constraint.seat.data);

    switch (constraint.state) {
        .active => |state| {
-            const sx = @floatToInt(i32, state.sx);
-            const sy = @floatToInt(i32, state.sy);
+            const sx: i32 = @intFromFloat(state.sx);
+            const sy: i32 = @intFromFloat(state.sy);
            if (!constraint.wlr_constraint.region.containsPoint(sx, sy, null)) {
                log.info("deactivating pointer constraint, region change left pointer outside constraint", .{});
                constraint.deactivate();
--- a/river/PointerMapping.zig
+++ b/river/PointerMapping.zig
@ -52,7 +52,7 @@ pub fn init(
            const arena_allocator = arena.allocator();

            const owned_args = try arena_allocator.alloc([:0]const u8, command_args.len);
-            for (command_args) |arg, i| {
+            for (command_args, 0..) |arg, i| {
                owned_args[i] = try arena_allocator.dupeZ(u8, arg);
            }

--- a/river/Root.zig
+++ b/river/Root.zig
@ -312,7 +312,7 @@ pub fn deactivateOutput(root: *Self, output: *Output) void {
        var it = tree.children.safeIterator(.forward);
        while (it.next()) |scene_node| {
            assert(scene_node.type == .tree);
-            if (@intToPtr(?*SceneNodeData, scene_node.data)) |node_data| {
+            if (@as(?*SceneNodeData, @ptrFromInt(scene_node.data))) |node_data| {
                node_data.data.layer_surface.wlr_layer_surface.destroy();
            }
        }
@ -751,7 +751,7 @@ fn processOutputConfig(
    var it = config.heads.iterator(.forward);
    while (it.next()) |head| {
        const wlr_output = head.state.output;
-        const output = @intToPtr(*Output, wlr_output.data);
+        const output: *Output = @ptrFromInt(wlr_output.data);

        var proposed_state = wlr.Output.State.init();
        head.state.apply(&proposed_state);
--- a/river/SceneNodeData.zig
+++ b/river/SceneNodeData.zig
@ -45,7 +45,7 @@ pub fn attach(node: *wlr.SceneNode, data: Data) error{OutOfMemory}!void {
        .node = node,
        .data = data,
    };
-    node.data = @ptrToInt(scene_node_data);
+    node.data = @intFromPtr(scene_node_data);

    node.events.destroy.add(&scene_node_data.destroy);
 }
@ -53,7 +53,7 @@ pub fn attach(node: *wlr.SceneNode, data: Data) error{OutOfMemory}!void {
 pub fn fromNode(node: *wlr.SceneNode) ?*SceneNodeData {
    var it: ?*wlr.SceneNode = node;
    while (it) |n| : (it = n.parent) {
-        if (@intToPtr(?*SceneNodeData, n.data)) |scene_node_data| {
+        if (@as(?*SceneNodeData, @ptrFromInt(n.data))) |scene_node_data| {
            return scene_node_data;
        }
    }
@ -62,7 +62,7 @@ pub fn fromNode(node: *wlr.SceneNode) ?*SceneNodeData {

 pub fn fromSurface(surface: *wlr.Surface) ?*SceneNodeData {
    if (surface.getRootSurface()) |root_surface| {
-        if (@intToPtr(?*wlr.SceneNode, root_surface.data)) |node| {
+        if (@as(?*wlr.SceneNode, @ptrFromInt(root_surface.data))) |node| {
            return fromNode(node);
        }
    }
--- a/river/Seat.zig
+++ b/river/Seat.zig
@ -107,7 +107,7 @@ pub fn init(self: *Self, name: [*:0]const u8) !void {
        .wlr_seat = try wlr.Seat.create(server.wl_server, name),
        .mapping_repeat_timer = mapping_repeat_timer,
    };
-    self.wlr_seat.data = @ptrToInt(self);
+    self.wlr_seat.data = @intFromPtr(self);

    try self.cursor.init(self);

@ -267,7 +267,8 @@ pub fn setFocusRaw(self: *Self, new_focus: FocusTarget) void {
            if (self.cursor.constraint) |constraint| {
                assert(constraint.wlr_constraint == wlr_constraint);
            } else {
-                self.cursor.constraint = @intToPtr(*PointerConstraint, wlr_constraint.data);
+                self.cursor.constraint = @ptrFromInt(wlr_constraint.data);
+                assert(self.cursor.constraint != null);
            }
        }
    }
@ -299,7 +300,7 @@ fn keyboardNotifyEnter(self: *Self, wlr_surface: *wlr.Surface) void {
            .len = wlr_keyboard.num_keycodes,
        };

-        const keyboard = @intToPtr(*Keyboard, wlr_keyboard.data);
+        const keyboard: *Keyboard = @ptrFromInt(wlr_keyboard.data);
        keycodes.subtract(keyboard.eaten_keycodes);

        self.wlr_seat.keyboardNotifyEnter(
--- a/river/Server.zig
+++ b/river/Server.zig
@ -214,7 +214,7 @@ fn handleNewToplevelDecoration(
    _: *wl.Listener(*wlr.XdgToplevelDecorationV1),
    wlr_decoration: *wlr.XdgToplevelDecorationV1,
 ) void {
-    const xdg_toplevel = @intToPtr(*XdgToplevel, wlr_decoration.surface.data);
+    const xdg_toplevel: *XdgToplevel = @ptrFromInt(wlr_decoration.surface.data);

    // TODO(wlroots): The next wlroots version will handle this for us
    if (xdg_toplevel.decoration != null) {
@ -236,7 +236,7 @@ fn handleNewLayerSurface(listener: *wl.Listener(*wlr.LayerSurfaceV1), wlr_layer_
        .{
            wlr_layer_surface.namespace,
            @tagName(wlr_layer_surface.current.layer),
-            @bitCast(u32, wlr_layer_surface.current.anchor),
+            @as(u32, @bitCast(wlr_layer_surface.current.anchor)),
            wlr_layer_surface.current.desired_width,
            wlr_layer_surface.current.desired_height,
            wlr_layer_surface.current.margin.top,
--- a/river/StatusManager.zig
+++ b/river/StatusManager.zig
@ -69,7 +69,7 @@ fn handleRequest(
        .get_river_output_status => |req| {
            // ignore if the output is inert
            const wlr_output = wlr.Output.fromWlOutput(req.output) orelse return;
-            const output = @intToPtr(*Output, wlr_output.data);
+            const output: *Output = @ptrFromInt(wlr_output.data);

            const resource = zriver.OutputStatusV1.create(
                status_manager.getClient(),
@ -86,7 +86,7 @@ fn handleRequest(
        .get_river_seat_status => |req| {
            // ignore if the seat is inert
            const wlr_seat = wlr.Seat.Client.fromWlSeat(req.seat) orelse return;
-            const seat = @intToPtr(*Seat, wlr_seat.seat.data);
+            const seat: *Seat = @ptrFromInt(wlr_seat.seat.data);

            const node = util.gpa.create(std.SinglyLinkedList(SeatStatus).Node) catch {
                status_manager.getClient().postNoMemory();
--- a/river/SwitchMapping.zig
+++ b/river/SwitchMapping.zig
@ -30,7 +30,7 @@ pub fn init(
 ) !Self {
    const owned_args = try util.gpa.alloc([:0]u8, command_args.len);
    errdefer util.gpa.free(owned_args);
-    for (command_args) |arg, i| {
+    for (command_args, 0..) |arg, i| {
        errdefer for (owned_args[0..i]) |a| util.gpa.free(a);
        owned_args[i] = try util.gpa.dupeZ(u8, arg);
    }
--- a/river/Vector.zig
+++ b/river/Vector.zig
@ -54,5 +54,5 @@ pub fn direction(self: Vector) ?wlr.OutputLayout.Direction {

 /// Returns the length of the vector.
 pub fn length(self: Vector) u31 {
-    return math.sqrt(@intCast(u31, (self.x *| self.x) +| (self.y *| self.y)));
+    return math.sqrt(@as(u31, @intCast((self.x *| self.x) +| (self.y *| self.y))));
 }
--- a/river/View.zig
+++ b/river/View.zig
@ -88,15 +88,15 @@ pub const State = struct {

        const max_x = output_width - state.box.width - border_width;
        state.box.x += delta_x;
-        state.box.x = math.max(state.box.x, border_width);
-        state.box.x = math.min(state.box.x, max_x);
-        state.box.x = math.max(state.box.x, 0);
+        state.box.x = @max(state.box.x, border_width);
+        state.box.x = @min(state.box.x, max_x);
+        state.box.x = @max(state.box.x, 0);

        const max_y = output_height - state.box.height - border_width;
        state.box.y += delta_y;
-        state.box.y = math.max(state.box.y, border_width);
-        state.box.y = math.min(state.box.y, max_y);
-        state.box.y = math.max(state.box.y, 0);
+        state.box.y = @max(state.box.y, border_width);
+        state.box.y = @min(state.box.y, max_y);
+        state.box.y = @max(state.box.y, 0);
    }

    pub fn clampToOutput(state: *State) void {
@ -107,8 +107,8 @@ pub const State = struct {
        output.wlr_output.effectiveResolution(&output_width, &output_height);

        const border_width = if (state.ssd) server.config.border_width else 0;
-        state.box.width = math.min(state.box.width, output_width - (2 * border_width));
-        state.box.height = math.min(state.box.height, output_height - (2 * border_width));
+        state.box.width = @min(state.box.width, output_width - (2 * border_width));
+        state.box.height = @min(state.box.height, output_height - (2 * border_width));

        state.move(0, 0);
    }
@ -504,8 +504,8 @@ pub fn map(view: *Self) !void {

    if (server.input_manager.defaultSeat().focused_output) |output| {
        // Center the initial pending box on the output
-        view.pending.box.x = @divTrunc(math.max(0, output.usable_box.width - view.pending.box.width), 2);
-        view.pending.box.y = @divTrunc(math.max(0, output.usable_box.height - view.pending.box.height), 2);
+        view.pending.box.x = @divTrunc(@max(0, output.usable_box.width - view.pending.box.width), 2);
+        view.pending.box.y = @divTrunc(@max(0, output.usable_box.height - view.pending.box.height), 2);

        view.pending.tags = blk: {
            if (server.config.tag_rules.match(view)) |tags| break :blk tags;
--- a/river/XdgDecoration.zig
+++ b/river/XdgDecoration.zig
@ -34,7 +34,7 @@ request_mode: wl.Listener(*wlr.XdgToplevelDecorationV1) =
    wl.Listener(*wlr.XdgToplevelDecorationV1).init(handleRequestMode),

 pub fn init(wlr_decoration: *wlr.XdgToplevelDecorationV1) void {
-    const xdg_toplevel = @intToPtr(*XdgToplevel, wlr_decoration.surface.data);
+    const xdg_toplevel: *XdgToplevel = @ptrFromInt(wlr_decoration.surface.data);

    xdg_toplevel.decoration = .{ .wlr_decoration = wlr_decoration };
    const decoration = &xdg_toplevel.decoration.?;
@ -64,7 +64,7 @@ fn handleDestroy(
    _: *wlr.XdgToplevelDecorationV1,
 ) void {
    const decoration = @fieldParentPtr(XdgDecoration, "destroy", listener);
-    const xdg_toplevel = @intToPtr(*XdgToplevel, decoration.wlr_decoration.surface.data);
+    const xdg_toplevel: *XdgToplevel = @ptrFromInt(decoration.wlr_decoration.surface.data);

    decoration.deinit();

@ -78,7 +78,7 @@ fn handleRequestMode(
 ) void {
    const decoration = @fieldParentPtr(XdgDecoration, "request_mode", listener);

-    const xdg_toplevel = @intToPtr(*XdgToplevel, decoration.wlr_decoration.surface.data);
+    const xdg_toplevel: *XdgToplevel = @ptrFromInt(decoration.wlr_decoration.surface.data);
    const view = xdg_toplevel.view;

    const ssd = server.config.ssd_rules.match(xdg_toplevel.view) orelse
--- a/river/XdgToplevel.zig
+++ b/river/XdgToplevel.zig
@ -85,8 +85,8 @@ pub fn create(xdg_toplevel: *wlr.XdgToplevel) error{OutOfMemory}!void {

    self.view = view;

-    xdg_toplevel.base.data = @ptrToInt(self);
-    xdg_toplevel.base.surface.data = @ptrToInt(&view.tree.node);
+    xdg_toplevel.base.data = @intFromPtr(self);
+    xdg_toplevel.base.surface.data = @intFromPtr(&view.tree.node);

    // Add listeners that are active over the toplevel's entire lifetime
    xdg_toplevel.base.events.destroy.add(&self.destroy);
@ -307,10 +307,10 @@ fn handleCommit(listener: *wl.Listener(*wlr.Surface), _: *wlr.Surface) void {
    {
        const state = &self.xdg_toplevel.current;
        view.constraints = .{
-            .min_width = @intCast(u31, math.max(state.min_width, 1)),
-            .max_width = if (state.max_width > 0) @intCast(u31, state.max_width) else math.maxInt(u31),
-            .min_height = @intCast(u31, math.max(state.min_height, 1)),
-            .max_height = if (state.max_height > 0) @intCast(u31, state.max_height) else math.maxInt(u31),
+            .min_width = @max(state.min_width, 1),
+            .max_width = if (state.max_width > 0) @intCast(state.max_width) else math.maxInt(u31),
+            .min_height = @max(state.min_height, 1),
+            .max_height = if (state.max_height > 0) @intCast(state.max_height) else math.maxInt(u31),
        };
    }

@ -376,7 +376,7 @@ fn handleRequestMove(
    event: *wlr.XdgToplevel.event.Move,
 ) void {
    const self = @fieldParentPtr(Self, "request_move", listener);
-    const seat = @intToPtr(*Seat, event.seat.seat.data);
+    const seat: *Seat = @ptrFromInt(event.seat.seat.data);
    const view = self.view;

    if (view.current.output == null or view.pending.output == null) return;
@ -389,7 +389,7 @@ fn handleRequestMove(

 fn handleRequestResize(listener: *wl.Listener(*wlr.XdgToplevel.event.Resize), event: *wlr.XdgToplevel.event.Resize) void {
    const self = @fieldParentPtr(Self, "request_resize", listener);
-    const seat = @intToPtr(*Seat, event.seat.seat.data);
+    const seat: *Seat = @ptrFromInt(event.seat.seat.data);
    const view = self.view;

    {
--- a/river/XwaylandOverrideRedirect.zig
+++ b/river/XwaylandOverrideRedirect.zig
@ -93,7 +93,7 @@ fn mapImpl(self: *Self) error{OutOfMemory}!void {
    self.surface_tree = try server.root.layers.xwayland_override_redirect.createSceneSubsurfaceTree(surface);
    try SceneNodeData.attach(&self.surface_tree.?.node, .{ .xwayland_override_redirect = self });

-    surface.data = @ptrToInt(&self.surface_tree.?.node);
+    surface.data = @intFromPtr(&self.surface_tree.?.node);

    self.surface_tree.?.node.setPosition(self.xwayland_surface.x, self.xwayland_surface.y);

--- a/river/XwaylandView.zig
+++ b/river/XwaylandView.zig
@ -102,10 +102,10 @@ pub fn configure(self: Self) bool {
    }

    self.xwayland_surface.configure(
-        @intCast(i16, inflight.box.x + output_box.x),
-        @intCast(i16, inflight.box.y + output_box.y),
-        @intCast(u16, inflight.box.width),
-        @intCast(u16, inflight.box.height),
+        @intCast(inflight.box.x + output_box.x),
+        @intCast(inflight.box.y + output_box.y),
+        @intCast(inflight.box.width),
+        @intCast(inflight.box.height),
    );

    self.setActivated(inflight.focus != 0);
@ -165,7 +165,7 @@ pub fn handleMap(listener: *wl.Listener(*wlr.XwaylandSurface), xwayland_surface:
    const view = self.view;

    const surface = xwayland_surface.surface.?;
-    surface.data = @ptrToInt(&view.tree.node);
+    surface.data = @intFromPtr(&view.tree.node);

    // Add listeners that are only active while mapped
    xwayland_surface.events.set_title.add(&self.set_title);
--- a/river/command/config.zig
+++ b/river/command/config.zig
@ -108,12 +108,12 @@ fn parseRgba(string: []const u8) ![4]f32 {
    const b = try fmt.parseInt(u8, string[6..8], 16);
    const a = if (string.len == 10) try fmt.parseInt(u8, string[8..10], 16) else 255;

-    const alpha = @intToFloat(f32, a) / 255.0;
+    const alpha = @as(f32, @floatFromInt(a)) / 255.0;

    return [4]f32{
-        @intToFloat(f32, r) / 255.0 * alpha,
-        @intToFloat(f32, g) / 255.0 * alpha,
-        @intToFloat(f32, b) / 255.0 * alpha,
+        @as(f32, @floatFromInt(r)) / 255.0 * alpha,
+        @as(f32, @floatFromInt(g)) / 255.0 * alpha,
+        @as(f32, @floatFromInt(b)) / 255.0 * alpha,
        alpha,
    };
 }
--- a/river/command/declare_mode.zig
+++ b/river/command/declare_mode.zig
@ -43,7 +43,7 @@ pub fn declareMode(

    const owned_name = try util.gpa.dupeZ(u8, new_mode_name);

-    const id = @intCast(u32, config.modes.items.len);
+    const id: u32 = @intCast(config.modes.items.len);
    config.mode_to_id.putAssumeCapacityNoClobber(owned_name, id);
    config.modes.appendAssumeCapacity(.{ .name = owned_name });
 }
--- a/river/command/input.zig
+++ b/river/command/input.zig
@ -55,7 +55,7 @@ pub fn listInputs(
        });
    }

-    out.* = input_list.toOwnedSlice();
+    out.* = try input_list.toOwnedSlice();
 }

 pub fn listInputConfigs(
@ -68,7 +68,7 @@ pub fn listInputConfigs(
    var input_list = std.ArrayList(u8).init(util.gpa);
    const writer = input_list.writer();

-    for (server.input_manager.configs.items) |*input_config, i| {
+    for (server.input_manager.configs.items, 0..) |*input_config, i| {
        if (i > 0) try input_list.appendSlice("\n");

        try writer.print("{s}\n", .{input_config.identifier});
@ -119,7 +119,7 @@ pub fn listInputConfigs(
        }
    }

-    out.* = input_list.toOwnedSlice();
+    out.* = try input_list.toOwnedSlice();
 }

 pub fn input(
@ -197,7 +197,7 @@ pub fn input(
    } else if (mem.eql(u8, "scroll-button", args[2])) {
        const ret = c.libevdev_event_code_from_name(c.EV_KEY, args[3].ptr);
        if (ret < 1) return Error.InvalidButton;
-        input_config.scroll_button = InputConfig.ScrollButton{ .button = @intCast(u32, ret) };
+        input_config.scroll_button = InputConfig.ScrollButton{ .button = @intCast(ret) };
    } else {
        return Error.UnknownCommand;
    }
--- a/river/command/map.zig
+++ b/river/command/map.zig
@ -200,7 +200,7 @@ fn mappingExists(
    keysym: xkb.Keysym,
    release: bool,
 ) ?usize {
-    for (mappings.items) |mapping, i| {
+    for (mappings.items, 0..) |mapping, i| {
        if (meta.eql(mapping.modifiers, modifiers) and
            mapping.keysym == keysym and mapping.options.release == release)
        {
@ -217,7 +217,7 @@ fn switchMappingExists(
    switch_type: Switch.Type,
    switch_state: Switch.State,
 ) ?usize {
-    for (switch_mappings.items) |mapping, i| {
+    for (switch_mappings.items, 0..) |mapping, i| {
        if (mapping.switch_type == switch_type and meta.eql(mapping.switch_state, switch_state)) {
            return i;
        }
@ -232,7 +232,7 @@ fn pointerMappingExists(
    modifiers: wlr.Keyboard.ModifierMask,
    event_code: u32,
 ) ?usize {
-    for (pointer_mappings.items) |mapping, i| {
+    for (pointer_mappings.items, 0..) |mapping, i| {
        if (meta.eql(mapping.modifiers, modifiers) and mapping.event_code == event_code) {
            return i;
        }
@ -248,7 +248,7 @@ fn parseEventCode(name: [:0]const u8, out: *?[]const u8) !u32 {
        return Error.Other;
    }

-    return @intCast(u32, event_code);
+    return @intCast(event_code);
 }

 fn parseKeysym(name: [:0]const u8, out: *?[]const u8) !xkb.Keysym {
--- a/river/command/move.zig
+++ b/river/command/move.zig
@ -104,7 +104,7 @@ pub fn resize(
            // up against an output edge.
            const diff_width = prev_width - view.pending.box.width;
            // Do not grow bigger than the output
-            view.pending.box.width = math.min(
+            view.pending.box.width = @min(
                view.pending.box.width,
                output_width - 2 * server.config.border_width,
            );
@ -116,7 +116,7 @@ pub fn resize(
            view.applyConstraints(&view.pending.box);
            const diff_height = prev_height - view.pending.box.height;
            // Do not grow bigger than the output
-            view.pending.box.height = math.min(
+            view.pending.box.height = @min(
                view.pending.box.height,
                output_height - 2 * server.config.border_width,
            );
--- a/river/command/output.zig
+++ b/river/command/output.zig
@ -109,15 +109,15 @@ fn getOutput(seat: *Seat, str: []const u8) !?*Output {
        const wlr_output = server.root.output_layout.adjacentOutput(
            direction,
            seat.focused_output.?.wlr_output,
-            @intToFloat(f64, focus_box.x + @divTrunc(focus_box.width, 2)),
-            @intToFloat(f64, focus_box.y + @divTrunc(focus_box.height, 2)),
+            @floatFromInt(focus_box.x + @divTrunc(focus_box.width, 2)),
+            @floatFromInt(focus_box.y + @divTrunc(focus_box.height, 2)),
        ) orelse return null;
-        return @intToPtr(*Output, wlr_output.data);
+        return @as(*Output, @ptrFromInt(wlr_output.data));
    } else {
        // Check if an output matches by name
        var it = server.root.active_outputs.iterator(.forward);
        while (it.next()) |output| {
-            if (mem.eql(u8, mem.span(output.wlr_output.name), str)) {
+            if (mem.eql(u8, mem.sliceTo(output.wlr_output.name, 0), str)) {
                return output;
            }
        }
--- a/river/command/rule.zig
+++ b/river/command/rule.zig
@ -157,8 +157,8 @@ pub fn listRules(_: *Seat, args: []const [:0]const u8, out: *?[]const u8) Error!
    var buffer = std.ArrayList(u8).init(util.gpa);
    const writer = buffer.writer();

-    try fmt.formatBuf("title", .{ .width = title_column_max, .alignment = .Left }, writer);
-    try fmt.formatBuf("app-id", .{ .width = app_id_column_max, .alignment = .Left }, writer);
+    try fmt.formatBuf("title", .{ .width = title_column_max, .alignment = .left }, writer);
+    try fmt.formatBuf("app-id", .{ .width = app_id_column_max, .alignment = .left }, writer);
    try writer.writeAll("action\n");

    switch (list) {
@ -169,8 +169,8 @@ pub fn listRules(_: *Seat, args: []const [:0]const u8, out: *?[]const u8) Error!
                else => unreachable,
            };
            for (rules) |rule| {
-                try fmt.formatBuf(rule.title_glob, .{ .width = title_column_max, .alignment = .Left }, writer);
-                try fmt.formatBuf(rule.app_id_glob, .{ .width = app_id_column_max, .alignment = .Left }, writer);
+                try fmt.formatBuf(rule.title_glob, .{ .width = title_column_max, .alignment = .left }, writer);
+                try fmt.formatBuf(rule.app_id_glob, .{ .width = app_id_column_max, .alignment = .left }, writer);
                try writer.print("{s}\n", .{switch (list) {
                    .float => if (rule.value) "float" else "no-float",
                    .ssd => if (rule.value) "ssd" else "csd",
@ -181,12 +181,12 @@ pub fn listRules(_: *Seat, args: []const [:0]const u8, out: *?[]const u8) Error!
        .tag => {
            const rules = server.config.tag_rules.rules.items;
            for (rules) |rule| {
-                try fmt.formatBuf(rule.title_glob, .{ .width = title_column_max, .alignment = .Left }, writer);
-                try fmt.formatBuf(rule.app_id_glob, .{ .width = app_id_column_max, .alignment = .Left }, writer);
+                try fmt.formatBuf(rule.title_glob, .{ .width = title_column_max, .alignment = .left }, writer);
+                try fmt.formatBuf(rule.app_id_glob, .{ .width = app_id_column_max, .alignment = .left }, writer);
                try writer.print("{b}\n", .{rule.value});
            }
        },
    }

-    out.* = buffer.toOwnedSlice();
+    out.* = try buffer.toOwnedSlice();
 }
--- a/river/main.zig
+++ b/river/main.zig
@ -175,7 +175,7 @@ pub fn log(
    comptime format: []const u8,
    args: anytype,
 ) void {
-    if (@enumToInt(level) > @enumToInt(runtime_log_level)) return;
+    if (@intFromEnum(level) > @intFromEnum(runtime_log_level)) return;

    const scope_prefix = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";

--- a/river/rule_list.zig
+++ b/river/rule_list.zig
@ -50,7 +50,7 @@ pub fn RuleList(comptime T: type) type {
        }

        pub fn add(list: *Self, rule: Rule) error{OutOfMemory}!void {
-            const index = for (list.rules.items) |*existing, i| {
+            const index = for (list.rules.items, 0..) |*existing, i| {
                if (mem.eql(u8, rule.app_id_glob, existing.app_id_glob) and
                    mem.eql(u8, rule.title_glob, existing.title_glob))
                {
@ -83,7 +83,7 @@ pub fn RuleList(comptime T: type) type {
        }

        pub fn del(list: *Self, rule: struct { app_id_glob: []const u8, title_glob: []const u8 }) void {
-            for (list.rules.items) |existing, i| {
+            for (list.rules.items, 0..) |existing, i| {
                if (mem.eql(u8, rule.app_id_glob, existing.app_id_glob) and
                    mem.eql(u8, rule.title_glob, existing.title_glob))
                {
--- a/river/wlroots_log_wrapper.c
+++ b/river/wlroots_log_wrapper.c
@ -1,6 +1,7 @@
 #include <assert.h>
 #include <stdarg.h>
 #include <stdlib.h>
+#include <stdio.h>

 #include <wlr/util/log.h>

--- a/riverctl/main.zig
+++ b/riverctl/main.zig
@ -110,10 +110,10 @@ fn _main() !void {
 fn registryListener(registry: *wl.Registry, event: wl.Registry.Event, globals: *Globals) void {
    switch (event) {
        .global => |global| {
-            if (std.cstr.cmp(global.interface, wl.Seat.getInterface().name) == 0) {
+            if (mem.orderZ(u8, global.interface, wl.Seat.getInterface().name) == .eq) {
                assert(globals.seat == null); // TODO: support multiple seats
                globals.seat = registry.bind(global.name, wl.Seat, 1) catch @panic("out of memory");
-            } else if (std.cstr.cmp(global.interface, zriver.ControlV1.getInterface().name) == 0) {
+            } else if (mem.orderZ(u8, global.interface, zriver.ControlV1.getInterface().name) == .eq) {
                globals.control = registry.bind(global.name, zriver.ControlV1, 1) catch @panic("out of memory");
            }
        },
@ -132,7 +132,7 @@ fn callbackListener(_: *zriver.CommandCallbackV1, event: zriver.CommandCallbackV
        },
        .failure => |failure| {
            // A small hack to provide usage text when river reports an unknown command.
-            if (std.cstr.cmp(failure.failure_message, "unknown command") == 0) {
+            if (mem.orderZ(u8, failure.failure_message, "unknown command") == .eq) {
                std.log.err("unknown command", .{});
                io.getStdErr().writeAll(usage) catch {};
                os.exit(1);
--- a/rivertile/main.zig
+++ b/rivertile/main.zig
@ -170,13 +170,13 @@ const Output = struct {
                            return;
                        };
                        switch (raw_arg[0]) {
-                            '+' => output.main_count +|= @intCast(u31, arg),
+                            '+' => output.main_count +|= @intCast(arg),
                            '-' => {
                                const result = output.main_count +| arg;
-                                if (result >= 1) output.main_count = @intCast(u31, result);
+                                if (result >= 1) output.main_count = @intCast(result);
                            },
                            else => {
-                                if (arg >= 1) output.main_count = @intCast(u31, arg);
+                                if (arg >= 1) output.main_count = @intCast(arg);
                            },
                        }
                    },
@ -198,16 +198,16 @@ const Output = struct {
            .layout_demand => |ev| {
                assert(ev.view_count > 0);

-                const main_count = math.min(output.main_count, @truncate(u31, ev.view_count));
-                const secondary_count = @truncate(u31, ev.view_count) -| main_count;
+                const main_count = @min(output.main_count, ev.view_count);
+                const secondary_count = saturatingCast(u31, ev.view_count) -| main_count;

                const usable_width = switch (output.main_location) {
-                    .left, .right => @truncate(u31, ev.usable_width) -| (2 *| outer_padding),
-                    .top, .bottom => @truncate(u31, ev.usable_height) -| (2 *| outer_padding),
+                    .left, .right => saturatingCast(u31, ev.usable_width) -| (2 *| outer_padding),
+                    .top, .bottom => saturatingCast(u31, ev.usable_height) -| (2 *| outer_padding),
                };
                const usable_height = switch (output.main_location) {
-                    .left, .right => @truncate(u31, ev.usable_height) -| (2 *| outer_padding),
-                    .top, .bottom => @truncate(u31, ev.usable_width) -| (2 *| outer_padding),
+                    .left, .right => saturatingCast(u31, ev.usable_height) -| (2 *| outer_padding),
+                    .top, .bottom => saturatingCast(u31, ev.usable_width) -| (2 *| outer_padding),
                };

                // to make things pixel-perfect, we make the first main and first secondary
@ -221,7 +221,7 @@ const Output = struct {
                var secondary_height_rem: u31 = undefined;

                if (secondary_count > 0) {
-                    main_width = @floatToInt(u31, output.main_ratio * @intToFloat(f64, usable_width));
+                    main_width = @intFromFloat(output.main_ratio * @as(f64, @floatFromInt(usable_width)));
                    main_height = usable_height / main_count;
                    main_height_rem = usable_height % main_count;

@ -382,9 +382,9 @@ pub fn main() !void {
 fn registryListener(registry: *wl.Registry, event: wl.Registry.Event, context: *Context) void {
    switch (event) {
        .global => |global| {
-            if (std.cstr.cmp(global.interface, river.LayoutManagerV3.getInterface().name) == 0) {
+            if (mem.orderZ(u8, global.interface, river.LayoutManagerV3.getInterface().name) == .eq) {
                context.layout_manager = registry.bind(global.name, river.LayoutManagerV3, 1) catch return;
-            } else if (std.cstr.cmp(global.interface, wl.Output.getInterface().name) == 0) {
+            } else if (mem.orderZ(u8, global.interface, wl.Output.getInterface().name) == .eq) {
                context.addOutput(registry, global.name) catch |err| fatal("failed to bind output: {}", .{err});
            }
        },
@ -413,3 +413,7 @@ fn fatalPrintUsage(comptime format: []const u8, args: anytype) noreturn {
    std.io.getStdErr().writeAll(usage) catch {};
    os.exit(1);
 }
+
+fn saturatingCast(comptime T: type, x: anytype) T {
+    return @intCast(math.clamp(x, math.minInt(T), math.maxInt(T)));
+}