HN 日本語サマリー

← 一覧へ戻る
プログラミング

Zig – SPIR-V バックエンドの進捗状況

Zig – SPIR-V Backend Progress (ziglang.org)

82 pointsby Retro_Dev45 コメント

要約

Zig言語のSPIR-Vバックエンドが大幅に改善されました。新しい`@SpirvType`組み込み関数が導入され、`callconv`による実行モードの指定が可能になり、CPU機能に基づくCapabilityとExtensionの管理が強化されています。さらに、マルチスレッドでのコード生成やオブジェクトファイルのリンクがサポートされるようになり、シェーダーやコンピュートカーネルでのZigの利用がより実用的になりました。

全文翻訳

Devlog

このページには、メインブランチのZigに対する最近の変更点がまとめられています。

このページには2026年のエントリが含まれています。他の年のログはDevlogアーカイブページで確認できます。

2026年8月27日

ArrayListのポインタ安定性

著者: Robbie Lyman

ポインタ安定性ロックは、2024年にstdのハッシュマップコンテナに追加されました。2025年にLeo Emar-Karによって最初に開かれたプルリクエストが、このメモリ安全性を確保する技術をstd.ArrayListにもたらしました。

コードでこれを利用するには、ArrayListがバックする要素または要素のスライスへのポインタを最初に格納する際にlockPointers()を呼び出し、それらのポインタが不要になったらunlockPointers()を呼び出します。

ややこじつけの例ですが、考えてみましょう。2つのArrayListを管理しているとします。一方は入力の内容をメモリに保持し、もう一方は興味のあるチャンク(例えば各行)を格納しているとします。このプロセスをバグのあるバージョンで示します。見つけられますか?

const std = @import("std");

const Context = struct {
    history: std.ArrayList(u8),
    lines: std.ArrayList([]const u8),

    fn parse(ctx: *Context, allocator: std.mem.Allocator, input: []const u8) !void {
        const slice = try ctx.history.addManyAsSlice(allocator, input.len);
        @memcpy(slice, input);
        var it = std.mem.tokenizeScalar(u8, slice, '\n');
        while (it.next()) |line| {
            try ctx.lines.append(allocator, line);
        }
    }
};

バグを見つけましたか?問題は、Context.lines.itemsの要素がContext.history.itemsの位置に依存していることです。しかし、Context.historyが現在の容量を超えて成長する必要がある場合、この位置は変更される可能性があります。以下にバグの再現例を示します。

test "Context.parse" {
    const input = "I'm first!\n";
    const input_two =
        \But this text
        \is juuuuuuuuuuuuuuuuuuuuuuuuust long enough that it
        \causes a problem!
        \And the problem could be that we segfault!
        \Which is no fun to run into.
    ;
    var ctx: Context = .{ .history = .empty, .lines = .empty };
    const gpa = std.testing.allocator;
    defer ctx.history.deinit(gpa);
    defer ctx.lines.deinit(gpa);
    try ctx.parse(gpa, input);
    try ctx.parse(gpa, input_two);
    try std.testing.expectEqualStrings("I'm first!", ctx.lines.items[0]);
}

zig testでこのコードを実行すると、次のような出力が得られます(その他にも少しあります)。

====== expected this output: =========
I'm first!␃

======== instead found this: =========
UUUUUUUUUU␃

======================================
First difference occurs on line 1:
expected:
I'm first!
^ ('\x49')
found:
UUUUUUUUUU
^ ('\x55')
1/1 blah.test.Context.parse...FAIL (TestExpectedEqual)

良くないですよね?これはバグがあることを示していますが、メモリデバッグの経験(およびアロケータの選択、バグの現れ方が変わる可能性があります!)によっては、修正を見つけるのにかなりの時間がかかるかもしれません。

最初のparse呼び出し後にポインタを格納したので、この変更を加えるとどうなるでしょうか?

    try ctx.parse(gpa, input);
+   ctx.history.lockPointers();
+   defer ctx.history.unlockPointers();
    try ctx.parse(gpa, input_two);
    try std.testing.expectEqualStrings("I'm first!", ctx.lines.items[0]);

ポインタ安定性に関する仮定が侵害された場所を示すスタックトレースとともにパニックが発生します!

thread 3023222 panic: reached unreachable code
/Users/robbie/bin/lib/std/debug.zig:442:14: 0x102d2506f in assert (test)
    if (!ok) unreachable; // assertion failure
             ^
/Users/robbie/bin/lib/std/debug.zig:1880:15: 0x102d31ef7 in assertUnlocked (test)
        assert(l.state == .unlocked);
              ^
/Users/robbie/bin/lib/std/array_list.zig:1348:50: 0x102e3ced7 in ensureTotalCapacityPrecise (test)
            self.pointer_stability.assertUnlocked();
                                                 ^
/Users/robbie/bin/lib/std/array_list.zig:1341:51: 0x102e3cdff in ensureTotalCapacity (test)
            return self.ensureTotalCapacityPrecise(gpa, growCapacity(new_capacity));
                                                  ^
/Users/robbie/bin/lib/std/array_list.zig:1237:41: 0x102e4e5c3 in resize (test)
            try self.ensureTotalCapacity(gpa, new_len);
                                        ^
/Users/robbie/bin/lib/std/array_list.zig:1461:28: 0x102e4e40f in addManyAsSlice (test)
            try self.resize(gpa, try addOrOom(self.items.len, n));
                           ^
/Users/robbie/src/advent-of-code/2024/blah.zig:8:51: 0x102e4dc1f in parse (test)
        const ptr = try ctx.history.addManyAsSlice(allocator, input.len);
                                                  ^
/Users/robbie/src/advent-of-code/2024/blah.zig:35:18: 0x102e4e167 in test.Context.parse (test)
    try ctx.parse(gpa, input_two);

素晴らしい、これはすでに大きな助けになります。テストの失敗の原因をロジックの問題だけでなく、メモリ安全性の問題として考慮すべきであることがわかります。もちろん、この例はややこじつけでしたが、私は実際にコードでこの種のバックエンドストレージとしてstd.ArrayListを使用することがよくありますので、皆さんも実際のユースケースを想像できることを願っています。

最後に、微妙な点に触れておきたいのですが、HashMapとその仲間とは異なり、ArrayListは順序付けられているため、リスト全体でメモリを移動、リサイズ、または解放することなく、リストに対する操作が要素を移動させる可能性があります。例えば、addManyAsSlice(gpa, n)によって返されるポインタ(スライス)は、orderedRemove()やpop()を呼び出した場合に、リストの最後のn個の要素を指さない可能性があります。このため、orderedRemove()とpop()はメモリを割り当てることはありませんが、lockPointers()の呼び出し後には上記の同じアサーションがトリガーされます。

2026年6月30日

パッケージ管理機能のすべてがコンパイラからビルドシステムへ移行

著者: Andrew Kelley

ユーザーのbuild.zigスクリプトとビルドシステム自体のための別個のプロセスができた今、パッケージ管理ロジックが存在する場所としてそれが適切です。

これらのサブコマンドをmakerプロセスに移動しました。

  • zig build
  • zig fetch
  • zig init
  • zig libc

これは、以前はコンパイラ実行可能ファイルに含まれていた機能の大部分が、ソース形式で出荷されるようになったことを意味します。これには以下が含まれます。

  • パッケージ取得ロジック
  • HTTPクライアントとネットワーキング
  • TLS(トランスポート層セキュリティ)および関連暗号
  • Gitプロトコル
  • xz、gzip、zstd、flate、zip
  • build.zig.zonファイルの解析、検証、およびその他の処理

その結果、この機能はコンパイラを再ビルドせずにパッチを適用できるようになり、ユーザーや貢献者がいじりやすくなりました。

さらに、zigでのパッケージ管理はネットワーク通信時に安全チェックが有効になることを意味します。maker実行可能ファイルはReleaseSafeモードでコンパイルされるためです。さらに、ネットワークやファイルハッシュに使用されるすべての暗号は、ソフトウェア配布時に通常依存するにはまれすぎるCPU命令であっても、ホストで利用可能な特別なCPU命令を利用できるようになります。AOTのケーキを食べながらJITも食べることができます!

これを行った当初の動機は、ZLSをブロック解除するためにビルドサーバープロトコルを公開することに関連していました。これは、maker/configurerプロセスの分離が--build-runnerオーバーライドフラグに破壊的な変更を加えた後に発生しました。

当初、プロセスツリーは次のようになっていました。

zig build  (the zig compiler + package manager)
└─ builder (the user's build.zig logic + build system implementation)

プロセスの分離変更により、次のようになりました。

zig build     (the zig compiler + package manager)
├─ configurer (the user's build.zig logic)
└─ maker      (build system)

この時点で、長時間実行されるzig build --watchプロセスを考えてみましょう。これはファイルを監視し、ソースコードの変更時に再ビルドします。build.zigの変更が検出された場合、またはそのロジックの実行中に観察されたファイルの場合、configurerを再実行する必要があることを意味します。これは、zig buildがパッケージ管理ロジックを繰り返す機会を与えるためにmakerプロセスが終了する必要があることを意味します。

この開発ログエントリの変更後、次のようになります。

zig build        (the zig compiler)
└─ maker         (build system + package manager)
   └─ configurer (the user's build.zig logic)

したがって、設定を再実行する必要がある場合、makerプロセスはそれよりも親プロセスであるため、存続できます。今後のビルドサーバーに関しては、サーバーが終了しクライアントが再接続する必要があるという厄介な状況を回避できることを意味します。単にクライアントに設定変更を通知するのではなく。

これはほぼ完全に非破壊的な変更ですが、いくつかの観測可能な違いがあります。

  • Zig実行可能バイナリサイズ:14.1 MiBから13.5 MiBに4%縮小(LLVMなし、ReleaseSmall)
  • --maker-optフラグはZIG_DEBUG_MAKER環境変数に置き換えられました
  • --zig-lib-dirフラグはZIG_LIB_DIR環境変数に置き換えられました

この変更セットのフォローアップ課題は、Zig 0.17.0をタグ付けするまでの主なブロッカーです。

7月に2つのカンファレンスがあり、講演の準備をする必要があるため、現実的に考えると、8月初旬までこれらを完了する時間はなさそうです。もちろん、貢献は大歓迎です。

ZLSチームのTechatrix氏には、ビルドサーバープロトコルについて私と協力してくれたことに感謝します。彼らはスポンサーを募集しています。

2026年6月26日

SPIR-Vバックエンドの進捗

著者: Ali Cheraghi

カバーすべき点はかなりあります。最近のコンパイラ変更の後、SPIR-Vバックエンドは多くの場所でビットが腐敗していたため、過去数週間かけてより良い状態に引き上げました。

@SpirvType

SPIR-Vには、Zigの型システムで表現できなかったいくつかの型があります。新しい@SpirvType組み込み関数が、シェーダー作成における最も古いブロッカーに対処するために導入されました。背景を追跡するには、#20550、#23326、および#35461を参照してください。

const Sampler = @SpirvType(.sampler);
const Image = @SpirvType(.{ .image = .{ .usage = .{ .sampled = u32 }, .format = .unknown, .dim = ."2d", .depth = .unknown, .arrayed = false, .multisampled = false, .access = .unknown } });
const SampledImage = @SpirvType(.{ .sampled_image = Image });
const RuntimeArray = @SpirvType(.{ .runtime_array = u32 });
const sampled_image = @extern(*addrspace(.constant) const SampledImage, .{ .name = "sampled_image", .decoration = .{ .descriptor = .{ .set = 0, .binding = 1 } } });

呼び出し規約における実行モード

実行モード情報(ワークグループサイズ、フラグメントの原点など)は、インラインアセンブリOpExecutionModeを介して発行されるのではなく、呼び出し規約によって伝達されるようになりました。古いstd.gpu.executionMode()ヘルパーは削除され、SPIR-Vアセンブラは手動のOpExecutionMode命令を拒否するようになりました。メッシュシェーディングパイプラインのために、spirv_taskとspirv_meshという2つの新しい呼び出し規約も追加されました。

export fn vert() callconv(.spirv_vertex) void {}
export fn frag() callconv(.{ .spirv_fragment = .{ .depth_assumption = .greater } }) void {}
export fn comp() callconv(.{ .spirv_kernel = .{ .x = 8, .y = 8, .z = 1 } }) void {}
export fn task() callconv(.{ .spirv_task = .{ .x = 1, .y = 1, .z = 1 } }) void {}
export fn mesh() callconv(.{ .spirv_mesh = .{ .stage_output = .output_lines, .max_primitives = 1, .max_vertices = 2 } }) void {}

CPU機能からの機能と拡張

機能と拡張は、以前はコード生成またはインラインアセンブリによってアドホックに発行されていました。これらは現在、他のターゲットと同様にCPU機能セットによって完全に駆動されており、依存関係チェーンはSPIRV-Headers(外部ベンダーを除く)から抽出され、アセンブラは現在OpCapabilityまたはOpExtensionを直接発行する試みを拒否します。

マルチスレッドコード生成

初日から、SPIR-Vバックエンドはリンカースレッド内でコード生成をシングルスレッドで実行していました。各コード生成ジョブは、他のすべての自己ホスト型バックエンドと同様にMir値を生成し、コンパイラのスレッドプールにスケジュールされるようになりました。

同じ変更により、以前のリファクタリング中に削除されていた2つのISelパスが復活しました。dedup_types(同等の型命令をマージする)とprune_unused(最終モジュールからデッドコードを削除する)です。これらは、コード生成がシングルスレッドだった頃に削除されていました。

オブジェクトファイルリンク

.spvファイルはオブジェクトファイルとして認識されるようになりました。複数の.zigファイル(または外部.spvオブジェクト)をコンパイルし、SPIR-Vリンカにそれらを単一モジュールに結合させることができます。

この過程で数十のバグが修正され、spirv64-vulkanターゲットでの合計合格動作テスト(現在49%)が約10%増加しました。std.gpuはstd.spirvにリネームされ、SPIR-Vバックエンドは1ヶ月前よりも実質的に有用になりましたが、まだ道のりは長いです。SPIR-Vでは多くの動作テストがスキップされたままです。とはいえ、シェーダーやコンピュートカーネルのためにZigを試すことを検討していたのであれば、今が試すのに良い時期です。バグレポートはCodebergで大歓迎です。ハッピーハッキング!

2026年6月25日

新しい@bitCastセマンティクスとLLVMバックエンドの改善

著者: Matthew Lugg

(かなり長い開発ログになります、ごめんなさい—今回は少しやりすぎました!)

数週間前、長年計画されていたLLVMバックエンドの改善を実装するブランチに取り掛かりました。これが、興味を引く可能性のあるいくつかの言語提案を実装する、より大きな変更へと雪だるま式に発展しました。

LLVMバックエンドの整数低下

Zigは常に任意のビット幅整数型(例: u4、i13、u40)をLLVM IRのビット整数型(i4、i13、i40)に直接低下させてきました。しかし、この低下は最適ではないことを長い間知っていました。なぜなら、LLVMのメモリでのこれらの型の表現に関する文書化されたセマンティクスは、オプティマイザにとって不必要に制限的だからです。さらに重要なのは、ClangはこのようなLLVM IRを生成しないため、LLVMのこれらのコードパスは適切にテストされておらず、実際にはサポートが不十分であるということです。過去数年間、単純な最適化が見逃されたり、さらには誤ったコンパイルさえ発生した多くの事例を観察してきました。

そのため、PRの元の目標は、これらのビット整数型をSSA形式で値を操作する場合にのみ使用し、メモリに格納する際にはABIサイズの型(i8、i16、i32など)にゼロ拡張または符号拡張することでした。これは、ClangがCの_BitInt(N)を低下させる方法と一致するため、適切にサポートされるはずです!

その変更は実際にはかなり簡単でしたが、ある問題に遭遇し、それが深みにはまりました。

@bitCastの問題

@bitCastは興味深い組み込み関数です。過去には、以下の操作シーケンスと同等であると定義されていました。

  • オペランド値へのポインタを取得する
  • それを宛先型へのポインタにキャストする
  • そのポインタからロードする

つまり、本質的にはメモリバイトを再解釈するための構文糖衣でした。しかし、時間の経過とともに、この定義から逸脱しました。例えば、@sizeOf(u24)が@sizeOf([3]u8)よりも大きいターゲットが多い場合でも、[3]u8をu24に再解釈するために@bitCastを使用することが許可されるようになりました。上記の定義では不正な動作が呼び出されます。

これまでは、LLVMバックエンドは@bitCast組み込み関数のこれらの不明確なセマンティクスを実装していました。しかし、その定義にはメモリの再解釈が含まれていたため、整数型をメモリに格納する方法を変更したことは@bitCastの実装に影響を与え、コンパイラテストスイートでのクラッシュにつながる不正な動作を引き起こしました。

これに対する最も簡単な解決策は、LLVMバックエンドに古い動作を近似的に一致させるロジックを実装することだったでしょう。私は代わりに、より良い解決策を選択しました。新しい@bitCastの定義を実装することです。

@bitCastの再定義

2024年に、Jacob Youngは@bitCastの問題を解決するために、新しいセマンティクスを正確に指定する言語提案#19755を作成しました。この提案は提出後すぐに承認され、実際、それが詳述するセマンティクスはすでに自己ホスト型x86_64バックエンドによって実装されています!そのため、LLVMバックエンドの問題を解決するために、古い@bitCastセマンティクスに合わせる必要はありませんでした。代わりに、新しいセマンティクスをすべてに実装する良い機会だと思われました。

ちなみに、これを行うもう一つの利点は、コンパイラのLegalizeパスを利用できることです。これは、低下が難しい操作をより単純な操作の観点から書き直すため、コンパイラバックエンドはそれらの単純な操作のみをサポートすればよくなります。Legalizeはすでに、自己ホスト型x86_64バックエンドによって使用される機能を持っており、複雑な@bitCast操作をより単純なものに変換していました。そして、他のコンパイラバックエンド(主にLLVMおよびCバックエンド)を支援するために簡単に適応させることができました。ただし、それらが新しいセマンティクスを実装している場合に限ります。

いずれにせよ、私が取り組んだのは、コンパイラ全体にこれらの新しいセマンティクスを実装することでした(これは元のクエストよりも困難になりました)。これには、LLVMおよびCバックエンドだけでなく、comptime実行も含まれます。結局のところ、Zigは@bitCastを含め、ほとんどの操作をcomptimeで実行できます!新しいセマンティクスは古いものとは実質的に異なるため(後述)、標準ライブラリ、コンパイラ、およびサポートライブラリ(例: compiler_rt)の@bitCastの多くの使用例を監査する必要もありました。しかし、CIの失敗に対する数回の比較的簡単な修正の後、ついに私のPRをグリーンにし、昨日マスターにマージすることができました(その過程でかなりの数の問題を閉じました!)。

新しい@bitCastセマンティクス

背景はすべて済んだので、ついに新しい@bitCastの動作を実際に説明する時が来ました。以前のようにメモリバイトの再解釈に基づいていたのではなく、組み込み関数は現在、型を論理的に表すビットの観点から定義されています。

@bitCastをサポートするすべての型には、「論理ビットレイアウト」があります。これは、型をビットの順序付けられたシーケンスとして表現したものです。例えば、u5は5つの論理ビットで構成され、それらを最下位ビットから最上位ビットへと順序付けます。[2]u5は10個の論理ビットで構成されます。最初の要素の5ビット、それに続く2番目の要素の5ビットです。新しい@bitCastの定義は、ある型の論理ビットを別の型の論理ビットとして再解釈することです。

最も単純な例は、符号なし整数(例えばu8)を取り、同じサイズの符号付き整数(この場合はi8)に変換することです。この操作は期待どおりに機能します。ビットは変更されず、最上位ビットを符号ビットとして再解釈するだけです。整数型とpacked struct/packed union型間の@bitCastのセマンティクスも変更されません。

新しいセマンティクスが古いものと異なるのは、集約型(配列とベクトル)が関わる場合です。

例えば、[2]u8をu16にビットキャストすることを考えてみましょう。古いセマンティクスでは、この操作の結果はターゲットエンディアンに依存しました。ビッグエンディアンターゲットでは、最初の配列要素は最上位8ビットになり、リトルエンディアンターゲットでは、最初の配列要素は最下位8ビットになりました。新しいセマンティクスでは、論理ビット表現(エンディアンに依存しない)のみを考慮するため、操作はすべてのターゲットで同一に動作します。最初の配列要素は最下位8ビットになります。一般的に、新しいセマンティクスはリトルエンディアンターゲットでの古いセマンティクスの動作に一致する傾向があります。

この定義により、[2]u3を@Vector(3, u2)に変換するような、より奇妙な操作も可能になります。

test "bitcast [2]u3 to @Vector(3, u2)" {
    const arr: [2]u3 = .{ 0b001, 0b011 };
    const vec: @Vector(3, u2) = @bitCast(arr);

    // `arr`のすべてのビットを、`arr[0]`の最下位ビットから始めて連結し、
    // 論理ビットシーケンスを見つけ、そこから2ビットチャンクを読み取って
    // 結果のベクトル値`vec`の要素を取得します。
    //
    //     arr[0]         arr[1]
    //     0b001          0b011
    // -------------"  -------------"
    //  1    0    0    1    1    0
    // --------  --------  --------
    //   0b01      0b10      0b01
    //  vec[0]    vec[1]    vec[2]

    try expect(vec[0] == 0b01);
    try expect(vec[1] == 0b10);
    try expect(vec[2] == 0b01);
}
const expect = @import("std").testing.expect;

この種の操作はほとんどの場合あまり役に立ちませんが、必要であれば利用できます!例えば、整数を個々のビットのベクトルに分解して操作したい場合、それは@bitCastから@Vector(n, u1)への変換で可能になりました。

これらすべての作業中、私はまた、いくつかの小さな承認された提案を実装しました。ここでは詳しく説明しませんが、興味があれば問題を確認できます。

  • ベクトルポインタへの/からの@bitCastを禁止(#18936)
  • 列挙型での@bitCastを許可(#35602の一部)

もちろん、これらのセマンティクスの変更はすべて0.17.0リリースノートで説明されます(おそらくここで管理できたよりも簡潔に!)。移行手順も概説されます。

LLVMバックエンドのパフォーマンス

最後に、このブランチの元の動機である、LLVMバックエンドが非ABI整数型を低下させる方法の変更が、見逃されていた最適化を回復させる上で実証的に成功したことを言及しておきたいだけです。実際、Zigコンパイラ自体(内部で任意のビット幅整数を多用していませんが!)は、より良い最適化により約5%のパフォーマンス向上が見られました。これは、0.17.0でマイナーなランタイムパフォーマンスの向上が期待できることを意味します!

読んでくれてありがとう、これがいくつかの方にとって興味深いものであったことを願っています。ハッピーハッキング!

2026年5月30日

ELFリンカの改善

著者: Matthew Lugg

過去数週間、Zig 0.16.0でデビューした新しいELFリンカに取り組んできました。0.16.0リリース時点では、このリンカ実装はかなり初期段階にあり、libcさえも含まないZigのみのコードのリンクしかサポートしていませんでした。そのため、デフォルトでは無効になっていました(-fnew-linkerで有効にできます)。しかし、最初のリリース以降、かなりの進歩がありました!

これは良いマイルストーンです。私の最新のPRにより、新しいELFリンカは、LLVMおよびLLDライブラリを有効にして自己ホスト型Zigコンパイラをビルドできるようになりました。このタスクは、多くの内部機能が必要です。

[mlugg@nebula master]$ # 新しいリンカを使用してZigコンパイラをビルド:
[mlugg@nebula master]$ zig build -Dno-lib -Dnew-linker -Denable-llvm
[mlugg@nebula master]$ # そのコンパイラを使用してLLVMとLLDで何かをビルド:
[mlugg@nebula master]$ ./zig-out/bin/zig build-exe ~/hello.zig -fllvm -flld
[mlugg@nebula master]$ ./hello
Hello, World!
[mlugg@nebula master]$

もちろん、ELFリンカは必ずしも最もエキサイティングなものではありません。そのため、この新しいリンカのヘッドライン機能は、高速な増分コンパイルのサポートです。最近の強化により、(x86_64 Linux上で)外部ライブラリ、Cソースなどをリンクしながら増分リビルドを実行することが可能になりました。追加のパフォーマンスオーバーヘッドなしで!Andrewのテトリスクローンでのテストのクリップを以下に示します。

[動画]

Andrewのテトリスクローンを約30ミリ秒ごとにビルドする、いくつかのちょっとした変更。

ああ、そして高速な増分リビルドはZigコンパイラ自体でもうまく機能します。

[mlugg@nebula master]$ zig build -Dno-lib -Denable-llvm -fincremental --watch
Build Summary: 4/4 steps succeeded
install success
└─ install zig success
   └─ compile exe zig Debug native success 36s

Build Summary: 4/4 steps succeeded
install success
└─ install zig success
   └─ compile exe zig Debug native success 244ms

Build Summary: 4/4 steps succeeded
install success
└─ install zig success
   └─ compile exe zig Debug native success 228ms

Build Summary: 4/4 steps succeeded
install success
└─ install zig success
   └─ compile exe zig Debug native success 288ms

Build Summary: 4/4 steps succeeded
install success
└─ install zig success
   └─ compile exe zig Debug native success 283ms

このリンカ実装の現在最も欠けている機能は、Zigコード用のDWARFデバッグ情報をまだ生成できないことです。それは間違いなく私の次の優先事項です。しかし、そのサポートがなくても、インスタントリビルドがいかに役立つかは驚くべきことです。例えば、多くのプリントデバッグを行っている状況では特にそうです。

Zigのマスターブランチを使用しており、x86_64 Linuxを使用している場合は、以前プロジェクトで動作しなかった場合でも、新しいELFリンカで増分コンパイルを試してみてください!多くのコードベースがすでにうまく動作し、プロジェクトをミリ秒単位でリビルドできる能力を解き放つことができると予想しています。もちろん、バグに遭遇した場合は、問題を報告してください。

そして、Zigのタグ付きリリースに留まっている場合は、心配しないでください。Andrewが前回の開発ログで言及したように、Zig 0.17.0がもうすぐリリースされるので、これも試せるようになるまでそう長くはかかりません!

2026年5月26日

ビルドシステム再構築

著者: Andrew Kelley

大きなブランチがマージされました:makerプロセスとconfigurerプロセスの分離

この開発ログエントリは、実質的に今後のリリースノートのプレビューですが、新しい機能をテストし、Zigプロジェクトの方向性を導くフィードバックを提供したい人への事前通知として機能します。

以前は、build.zigファイルとビルドシステム実装はすべて1つの肥大化したプロセスにコンパイルされていました(Debugモード)。build.zigロジックがメモリ内にビルドグラフを構築し終えた後、「ビルドランナー」コードがそれを実行していました。

現在、build.zigファイルは小さなプロセス(「configurer」)にコンパイルされます(debugモード)。このロジックがメモリ内にビルドグラフを構築し終えると、バイナリ設定ファイルにシリアライズされます。親のzig buildプロセスはこのファイルを認識し、次回のためにキャッシュします。その間、非同期にビルドグラフ実行プロセス(「maker」)をreleaseモードでコンパイルします。設定ファイルが利用可能になり、makerプロセスがコンパイルを完了すると、makerプロセスが実行され、設定ファイルが渡されます。makerプロセスは、グローバルキャッシュのおかげで、zig versionごとに一度だけコンパイルされれば済みます。makerプロセスは、シリアライズされた設定ファイルに含まれるビルドグラフを実行します。

この変更の主な動機は、zig buildを3つの方法で高速化することでした。

  1. ビルドシステム全体を一緒にコンパイルするのではなく、変更ごとにユーザーのbuild.zigロジックのみがコンパイルされます。これは、--watch、--fuzz、--webuiが導入された今、より価値が高まっています。ビルドシステムは、zig buildの時間が長くなることなく、より多くの機能を追加できます。

  2. ビルドシステムは、何も変更されないことがわかっている場合、build.zigロジックの実行を完全にスキップできるようになりました。例えば、zig buildコマンドラインに-freference-traceを追加した場合、前回と同じ設定を使用して、build.zigロジックの冗長な再実行を回避できるようになりました。

  3. ビルドグラフを実際に実行するプロセスが、最適化を有効にしてコンパイルされるようになりました。

ポイント2と3を実証するために、zig build --helpを実行する前後の違いを示します。

Benchmark 1 (34 runs): master/zig build -h
  measurement          mean ± σ            min … max           outliers         delta
  wall_time           150ms ± 5.52ms     145ms …  165ms          4 (12%)        0%
  peak_rss           84.8MB ±  275KB    84.2MB … 85.1MB          0 ( 0%)        0%
  cpu_cycles          593M  ± 4.01M      588M  …  608M           2 ( 6%)        0%
  instructions        995M  ± 52.5K      995M  …  995M           0 ( 0%)        0%
  cache_references   25.8M  ±  165K     25.4M  … 26.1M           0 ( 0%)        0%
  cache_misses        651K  ± 20.1K      619K  …  697K           0 ( 0%)        0%
  branch_misses       918K  ± 7.44K      906K  …  935K           0 ( 0%)        0%
Benchmark 2 (348 runs): branch/zig build -h
  measurement          mean ± σ            min … max           outliers         delta
  wall_time          14.3ms ±  744us    13.2ms … 23.3ms          8 ( 2%)        ⚡- 90.4% ±  0.4%
  peak_rss           78.5MB ±  562KB    77.1MB … 81.4MB          7 ( 2%)        ⚡-  7.4% ±  0.2%
  cpu_cycles         24.1M  ±  821K     22.8M  … 27.1M           3 ( 1%)        ⚡- 95.9% ±  0.1%
  instructions       43.7M  ± 23.8K     43.7M  … 43.8M          56 (16%)        ⚡- 95.6% ±  0.0%
  cache_references   1.46M  ± 14.6K     1.40M  … 1.50M          19 ( 5%)        ⚡- 94.3% ±  0.1%
  cache_misses        142K  ± 4.87K      127K  …  157K           2 ( 1%)        ⚡- 78.1% ±  0.4%
  branch_misses       126K  ± 1.37K      120K  …  129K          12 ( 3%)        ⚡- 86.3% ±  0.1%

これは劇的です。なぜなら、以前はbuild.zigロジックが各zig buildコマンドで実行されていましたが、今ではビルドシステムがキャッシュされたシリアライズされた設定を使用するからです。

パフォーマンス以外では、ZLSのようなサードパーティ製ツールが、ビルドランナーのフォークを維持するのではなく、シリアライズされた設定ファイルを消費することから恩恵を受けると予想しています。

この変更はzigビルドシステムの内部メカニズムを大幅に再構築しますが、APIの観点からはほとんど非破壊的です。リンクされたPRで言及されている例外を除きます。

ほとんどの人にとって、これはおそらく彼らが最初に遭遇する破壊的な変更でしょう。

if (b.args) |args| {
    run_cmd.addArgs(args);
}

⬇️

run_cmd.addPassthruArgs();

これにより、ビルドスクリプトはその引数を観察できなくなるため、ビルドスクリプトから機能が削除されます。その見返りに、これらの引数を変更したときに、ビルドスクリプトをソースから再ビルドする必要がなくなることを意味します。

Zigの方向性に影響を与えたい人は、今がプロジェクトを開発バージョンにアップグレードしてこれらの変更を試す良い時期です。数週間以内に0.17.0をリリースします。しかし、時間がない場合、そして0.17.0がビルドを壊したことに気づいた場合は、心配しないでください。0.17.1タグの修正を入れる機会はたくさんあります。

2026年4月8日

LLVMでの増分コンパイル

著者: Matthew Lugg

先月、型解決の変更をマージした後、個人的なプロジェクトに時間を費やしていましたが、最近LLVMコード生成バックエンドのいくつかの改善を行う時間を見つけました。これには、さまざまな目標を持ついくつかの異なる強化が含まれていましたが、ユーザーにとって便利な変更の1つは、LLVMバックエンドで増分コンパイルを機能させることができたことです。

残念ながら、これは恐ろしいLLVM Emit Objectの時間を短縮することはできません。その時間は完全にLLVMに依存します。しかし、増分コンパイルが役立つのは、実際のZigコンパイラコードでの時間を最小限に抑えることです。これは、コードにコンパイルエラーがある場合(そのため「LLVM Emit Object」がスキップされる)、通常は非常に迅速にエラーが得られることを意味します。(もちろん、ビルドが成功した場合でもわずかに高速化されます。)

このサポートは現在マスターブランチのビルドで利用可能であり、0.16.0リリース(まもなくタグ付けされます)に含まれます。

まだ試していない方、特にZigのマスターブランチを使用している方は、zig buildに-fincremental --watchを渡して増分コンパイルを試してみてください!Zigコアチームは、1年近くワークフローで増分コンパイルの恩恵を受けており、ユーザーからも良いフィードバックを聞いています。この機能は現在比較的安定しており、人々は数秒ではなくミリ秒で最新のコンパイルエラーを得るだけで、どれだけ時間を節約できるかに驚くことがよくあります。

私は個人的にはLLVMバックエンドで増分コンパイルをあまり使用していませんが、CIのすべての増分テストカバレッジがLLVMバックエンドで有効になっており、ユーザーから肯定的なフィードバックを得ているため、試す価値は間違いなくあります。いつものように、増分コンパイルでバグに遭遇した場合は、可能であれば報告してください!

ありがとうございます。この機能がお役に立つことを願っています :)

2026年3月10日

型解決の再設計、好みに合わせた言語変更

著者: Matthew Lugg

本日、30,000行のPRをマージしました。2(あるいは3)ヶ月の作業を経てです。このブランチの目標は、Zigコンパイラの内部型解決ロジックを、より論理的で分かりやすい設計に再設計することでした。これは私個人にとっては非常にエキサイティングな変更です。なぜなら、コンパイラの内部を整理することができたからです。しかし、ユーザー向けの便利な変更もいくつかあり、興味を引くかもしれません!

まず、Zigコンパイラは型のフィールドの分析に怠惰になりました。型が初期化されない場合、Zigはその型が「どのように見えるか」を気にする必要はありません。これは、型が名前空間としても機能する場合に重要です。これは現代のZigでは一般的なパターンです。例えば、std.Io.Writerを使用する場合、コンパイラにstd.Ioのコードを大量に引き込ませたくないでしょう!以下に簡単な例を示します。

const Foo = struct {
    bad_field: @compileError("i am an evil field, muahaha"),
    const something = 123;
};
comptime {
    _ = Foo.something; // `Foo`は名前空間としてのみ使用
}

以前は、このコードはコンパイルエラーを発生させていました。しかし今では、Zigは@compileError呼び出しを実際に参照しないため、問題なくコンパイルされます。

もう一つの改善点は、「依存関係ループ」のエクスペリエンスです。Zigで依存関係ループのコンパイルエラーに遭遇したことがある人なら誰でも、エラーメッセージが全く役に立たないことを知っています。しかし、それは変わりました!もし(以前よりも発生しにくくなりましたが)遭遇した場合、依存関係ループがどこから来るのかを正確に伝える詳細なエラーメッセージが表示されます。見てみましょう。

const Foo = struct { inner: Bar };
const Bar = struct { x: u32 align(@alignOf(Foo)) };
comptime {
    _ = @as(Foo, undefined);
}
$ zig build-obj repro.zig
error: dependency loop with length 2
    repro.zig:1:29: note: type 'repro.Foo' depends on type 'repro.Bar' for field declared here
    const Foo = struct { inner: Bar };
                                ^~~
    repro.zig:2:44: note: type 'repro.Bar' depends on type 'repro.Foo' for alignment query here
    const Bar = struct { x: u32 align(@alignOf(Foo)) };
                                               ^~~
    note: eliminate any one of these dependencies to break the loop

もちろん、依存関係ループはこれよりもはるかに複雑になる可能性がありますが、テストしたすべてのケースで、エラーメッセージには何が起こっているのかを簡単に把握できる十分な情報が含まれていました。

さらに、このPRはZigコンパイラの「増分コンパイル」機能に大きな改善をもたらしました。要するに、多くの既知のバグを修正しましたが、特に「過剰分析」の問題(増分更新が必要以上に多くの作業を行い、時には大幅に多く行う場合)は、ほぼ完全に排除されるはずです。これにより、多くの場合、増分コンパイルが大幅に高速化されます!まだ試していない場合は、増分コンパイルを試すことを検討してください。それは本当に素晴らしい開発体験です。これは間違いなく私を最も興奮させる改善であり、この変更の主な動機の一部でした。

このPRにはさらに多くの変更が含まれています。数十のバグ修正、いくつかの小さな言語変更(ほとんどはかなりニッチなもの)、およびコンパイラパフォーマンスの向上です。ここにすべてをリストするには多すぎますが、詳細を知りたい場合は、CodebergのPRを確認してください。もちろん、バグに遭遇した場合は、問題を報告してください。ハッピーハッキング!

2026年2月13日

io_uringとGrand Central Dispatchのstd.Io実装が登場

著者: Andrew Kelley

0.16.0リリースサイクルの終盤に近づくにつれて、Jacobはstd.Io.Eventedを最新のAPI変更に追いつかせるために精力的に取り組んでいます。

これらはいずれも、ユーザー空間スタックスイッチングに基づいています。これは「ファイバー」、「スタックフルコルーチン」、または「グリーン スレッド」と呼ばれることもあります。

これらは現在、std.Io.Eventedを使用してアプリケーションを構築することで試すことができます。ただし、信頼性高く堅牢に使用できるようになる前に重要なフォローアップ作業が必要なため、実験的と見なされるべきです。

これらの注意点を念頭に置くと、ZigコードでI/O実装を簡単に切り替えられる「約束の地」に確かに到達しているようです。

const std = @import("std");

pub fn main(init: std.process.Init.Minimal) !void {
    var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
    const gpa = debug_allocator.allocator();

    var threaded: std.Io.Threaded = .init(gpa, .{
        .argv0 = .init(init.args),
        .environ = init.environ,
    });
    defer threaded.deinit();
    const io = threaded.io();

    return app(io);
}

fn app(io: std.Io) !void {
    try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
}
$ strace ./hello_threaded
execve("./hello_threaded", ["./hello_threaded"], 0x7ffc1da88b20 /* 98 vars */) = 0
mmap(NULL, 262207, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f583f338000
arch_prctl(ARCH_SET_FS, 0x7f583f378018) = 0
prlimit64(0, RLIMIT_STACK, NULL, {rlim_cur=8192*1024, rlim_max=RLIM64_INFINITY}) = 0
prlimit64(0, RLIMIT_STACK, {rlim_cur=16384*1024, rlim_max=RLIM64_INFINITY}, NULL) = 0
sigaltstack({ss_sp=0x7f583f338000, ss_flags=0, ss_size=262144}, NULL) = 0
sched_getaffinity(0, 128, [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31]) = 8
rt_sigaction(SIGIO, {sa_handler=0x1019d90, sa_mask=[], sa_flags=SA_RESTORER, sa_restorer=0x10328c0}, {sa_handler=SIG_DFL, sa_mask=[], sa_flags=0}, 8) = 0
rt_sigaction(SIGPIPE, {sa_handler=0x1019d90, sa_mask=[], sa_flags=SA_RESTORER, sa_restorer=0x10328c0}, {sa_handler=SIG_DFL, sa_mask=[], sa_flags=0}, 8) = 0
writev(1, [{iov_base="Hello, World!\n", iov_len=14}], 1) = 14Hello, World!

rt_sigaction(SIGIO, {sa_handler=SIG_DFL, sa_mask=[], sa_flags=SA_RESTORER, sa_restorer=0x10328c0}, NULL, 8) = 0
rt_sigaction(SIGPIPE, {sa_handler=SIG_DFL, sa_mask=[], sa_flags=SA_RESTORER, sa_restorer=0x10328c0}, NULL, 8) = 0
exit_group(0)                           = ?
+++ exited with 0 +++

I/O実装のみを切り替える:

const std = @import("std");

pub fn main(init: std.process.Init.Minimal) !void {
    var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
    const gpa = debug_allocator.allocator();

    var evented: std.Io.Evented = undefined;
    try evented.init(gpa, .{
        .argv0 = .init(init.args),
        .environ = init.environ,
        .backing_allocator_needs_mutex = false,
    });
    defer evented.deinit();
    const io = evented.io();

    return app(io);
}

fn app(io: std.Io) !void {
    try std.Io.File.stdout().writeStreamingAll(io, "Hello, World!\n");
}
execve("./hello_evented", ["./hello_evented"], 0x7fff368894f0 /* 98 vars */) = 0
mmap(NULL, 262215, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f70a4c28000
arch_prctl(ARCH_SET_FS, 0x7f70a4c68020) = 0
prlimit64(0, RLIMIT_STACK, NULL, {rlim_cur=8192*1024, rlim_max=RLIM64_INFINITY}) = 0
prlimit64(0, RLIMIT_STACK, {rlim_cur=16384*1024, rlim_max=RLIM64_INFINITY}, NULL) = 0
sigaltstack({ss_sp=0x7f70a4c28008, ss_flags=0, ss_size=262144}, NULL) = 0
sched_getaffinity(0, 128, [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31]) = 8
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f70a4c27000
mmap(0x7f70a4c28000, 548864, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f70a4ba1000
io_uring_setup(64, {flags=IORING_SETUP_COOP_TASKRUN|IORING_SETUP_SINGLE_ISSUER, sq_thread_cpu=0, sq_thread_idle=1000, sq_entries=64, cq_entries=128, features=IORING_FEAT_SINGLE_MMAP|IORING_FEAT_NODROP|IORING_FEAT_SUBMIT_STABLE|IORING_FEAT_RW_CUR_POS|IORING_FEAT_CUR_PERSONALITY|IORING_FEAT_FAST_POLL|IORING_FEAT_POLL_32BITS|IORING_FEAT_SQPOLL_NONFIXED|IORING_FEAT_EXT_ARG|IORING_FEAT_NATIVE_WORKERS|IORING_FEAT_RSRC_TAGS|IORING_FEAT_CQE_SKIP|IORING_FEAT_LINKED_FILE|IORING_FEAT_REG_REG_RING|IORING_FEAT_RECVSEND_BUNDLE|IORING_FEAT_MIN_TIMEOUT|IORING_FEAT_RW_ATTR|IORING_FEAT_NO_IOWAIT, sq_off={head=0, tail=4, ring_mask=16, ring_entries=24, flags=36, dropped=32, array=2112, user_addr=0}, cq_off={head=8, tail=12, ring_mask=20, ring_entries=28, overflow=44, cqes=64, flags=40, user_addr=0}}) = 3
mmap(NULL, 2368, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_POPULATE, 3, 0) = 0x7f70a4ba0000
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_POPULATE, 3, 0x10000000) = 0x7f70a4b9f000
io_uring_enter(3, 1, 1, IORING_ENTER_GETEVENTS, NULL, 8) = 1
io_uring_enter(3, 1, 1, IORING_ENTER_GETEVENTS, NULL, 8) = 1
munmap(0x7f70a4b9f000, 4096)            = 0
munmap(0x7f70a4ba0000, 2368)            = 0
close(3)                                = 0
munmap(0x7f70a4ba1000, 548864)          = 0
exit_group(0)                           = ?
+++ exited with 0 +++

ここで重要なのは、これらのスニペット間のapp関数が同一であることです。

「Hello World」を超えて、Zigコンパイラ自体もstd.Io.Eventedを使用して正常に動作します(io_uringとGCDの両方で)。ただし、前述のように、そうした場合に診断されていないパフォーマンス低下があります。

ハッピーハッキング、

Andrew

2026年2月6日

パッケージ管理ワークフローの2つの強化

著者: Andrew Kelley

依存関係を持つZigプロジェクトをお持ちの場合、興味を引くと思われる2つの大きな変更が加えられました。

取得されたパッケージは、プロジェクトルートのzig-pkgディレクトリ(build.zigファイルの隣)にローカルに格納されるようになりました。

例えば、zig buildを実行した後のaweboからの結果をいくつか示します。

$ du -sh zig-pkg/*
13M    freetype-2.14.1-alzUkTyBqgBwke4Jsot997WYSpl207Ij9oO-2QOvGrOi
20K    opus-0.0.2-vuF-cMAkAADVsm707MYCtPmqmRs0gzg84Sz0qGbb5E3w
4.3M   pulseaudio-16.1.1-9-mk_62MZkNwBaFwiZ7ZVrYRIf_3dTqqJR5PbMRCJzSuLw
5.2M   uucode-0.1.0-ZZjBPvtWUACf5dqD_f9I37VGFsN24436CuceC5pTJ25n
728K   vaxis-0.5.1-BWNV_AxECQCj3p4Hcv4U3Yo1WMUJ7Z2FUj0UkpuJGxQQ

このディレクトリをプロジェクトローカルのソース管理無視ファイル(例: .gitignore)に追加することを強くお勧めします。ただし、.zig-cacheの外にあるため、依存関係すべてを含む自己完結型のソースtarballを配布する可能性があり、オフラインビルドやアーカイブ目的で使用できます。

一方、依存関係の追加コピーがグローバルにキャッシュされます。pathsフィルターに基づいて未使用のファイルをすべてフィルタリングした後、コンテンツは再圧縮されます。

$ du -sh ~/.cache/zig/p/*
2.4M    freetype-2.14.1-alzUkTyBqgBwke4Jsot997WYSpl207Ij9oO-2QOvGrOi.tar.gz
4.0K    opus-0.0.2-vuF-cMAkAADVsm707MYCtPmqmRs0gzg84Sz0qGbb5E3w.tar.gz
636K    pulseaudio-16.1.1-9-mk_62MZkNwBaFwiZ7ZVrYRIf_3dTqqJR5PbMRCJzSuLw.tar.gz
880K    uucode-0.1.0-ZZjBPvtWUACf5dqD_f9I37VGFsN24436CuceC5pTJ25n.tar.gz
120K    vaxis-0.5.1-BWNV_BFECQBbXeTeFd48uTJRjD5a-KD6kPuKanzzVB01.tar.gz

この変更の動機は、いじりやすくすることです。これらのファイルを編集して、何が起こるか見てみてください。パッケージディレクトリをgit cloneと入れ替えてみてください。依存関係全体をまとめてgrepしてみてください。IDEをzig-pkgディレクトリに基づいてオートコンプリートするように設定してください。依存関係ツリーにbaobabを実行してください。さらに、グローバルキャッシュに圧縮ファイルがあることで、コンピュータ間でそのキャッシュデータを共有しやすくなります。将来的には、ピアツーピアのトレントによる依存関係ツリーのサポートが計画されています。パッケージを正規形式に再圧縮することで、ピアは最小限の帯域幅でZigパッケージを共有できるようになります。このアイデアは、ネットワーク障害に対する回復力と人気投票を同時に提供するため、気に入っています。シード数に基づいてどのオープンソースパッケージが人気があるかを見つけてください!

2番目の変更は、zig buildフラグに--forkが追加されたことです。

振り返ってみると、それは非常に明白で、最初からなぜ思いつかなかったのかわかりません。次のように表示されます。

zig build --fork=[path]

これはプロジェクトオーバーライドオプションです。ソースチェックアウトへのパスを指定すると、依存関係ツリー全体でそのプロジェクトに一致するすべてのパッケージがオーバーライドされます。

パッケージコンテンツハッシュには名前とフィンガープリントが含まれているという事実のおかげで、これはパッケージが取得される前に解決されます。

これは、完全に別のディレクトリにある1つ以上のフォークを一時的に使用する簡単な方法です。すべてが機能するまで依存関係ツリー全体を反復処理でき、同時に依存関係プロジェクトの快適な開発環境とソース管理を使用できます。

CLIフラグであるという事実は、それを適切に一時的なものにします。フラグを削除すると、すぐにクリーンな取得済み依存関係ツリーに戻ります。

プロジェクトが一致しない場合、混乱を防ぐためにエラーが発生します。

$ zig build --fork=/home/andy/dev/mime
error: fork /home/andy/dev/mime matched no mime packages
$

プロジェクトが一致する場合、混乱を防ぐためにフォークを使用しているというリマインダーが表示されます。

$ zig build --fork=/home/andy/dev/dvui
info: fork /home/andy/dev/dvui matched 1 (dvui) packages
...

この機能は、エコシステムの破損に対処するワークフローを強化することを目的としています。すでに少し試してみて、非常に使いやすいと感じました。新しいワークフローは次のようになります。

  1. エコシステムの破損により、ソースからのビルドが失敗する。
  2. --forkを使用してプロジェクトが再び機能するまでいじる。この間、実際のアップストリームソース管理、テストスイート、zig build test --watch -fincrementalなどを利用できます。
  3. これで新しいオプションがあります。利己的になり、自分のものを作り続けるか、パッチをアップストリームに送信してマージする作業に進むかです。

…そして、アップストリームが修正のマージに時間がかかると予想しない限り、build.zig.zonをフォークに変更するステップをスキップできるかもしれません。

2026年2月3日

Kernel32.dllを迂回する(楽しみと非営利目的で)

著者: Andrew Kelley

Windowsオペレーティングシステムは、カーネルで何かを行うための広範なABIサーフェスを提供しています。しかし、すべてのABIが同等に作られているわけではありません。Casey Muratoriが彼の講義The Only Unbreakable Lawで指摘しているように、ソフトウェア開発チームの組織構造は、彼らが作成するソフトウェアの構造に直接影響を与えます。

Windows上のDLLは階層に組織化されており、APIの一部は低レベルAPIのハイレベルラッパーです。例えば、kernel32.dllの関数を呼び出すたびに、最終的には実際の作業はntdll.dllによって行われます。ProcMon.exeを使用してスタックトレースを調べると、これを直接確認できます。

経験的に学んだことは、ntdll APIは一般的にうまく設計されており、合理的で強力ですが、kernel32ラッパーは不要なヒープ割り当て、追加の障害モード、意図しないCPU使用率、および肥大化をもたらすということです。

これが、Zig標準ライブラリの方針がWin32よりもネイティブAPIを優先する理由です。まだ完全ではありませんが、カーネル32への呼び出しはまだ残っていますが、最近大きな進歩を遂げました。2つの例を挙げます。

例1:エントロピー

公式ドキュメントによると、Windowsにはランダムバイトを取得するための簡単な方法がありません。

Chromium、boringssl、Firefox、Rustを含む多くのプロジェクトは、Windows 8より前のバージョンで動作したため、advapi32.dllからSystemFunction036を呼び出します。

残念ながら、Windows 8以降では、この関数を最初に呼び出すと、bcryptprimitives.dllが動的にロードされ、ProcessPrngが呼び出されます。DLLのロードに失敗した場合(例えば、Zig CIで何度も観察されたシステム負荷過多のため)、void戻り値を持つ関数からエラー38が返されます(ドキュメントでは失敗しないとされています)。

ProcessPrngが最初に行うことは、少量の固定バイト数をヒープ割り当てることです。これが失敗した場合、BOOLでNO_MEMORYを返します(ドキュメントでは失敗しないとされており、常にTRUEを返すとされています)。

bcryptprimitives.dllは、ロードするたびにテストスイートを実行するようです。

ProcessPrngが実際に行っていることは、NtOpenFileを`