HN 日本語サマリー

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

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

Zig: All Package Management Functionality Moved from Compiler to Build System (ziglang.org)

161 pointsby tosh33 コメント

要約

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命令を活用できるようになりました。これは、ソフトウェア配布時に通常依存しないようなものでも可能です。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実行可能バイナリサイズ:4%減(14.1 MiBから13.5 MiBへ)(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 ターゲットでの合計合格動作テストの割合が約10%増加しました(現在は49%)。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 は興味深いビルトインです。過去には、以下の操作シーケンスと同等であると定義されていました。

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

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

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

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

@bitCast の再定義

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

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

いずれにせよ、私はコンパイラ全体にこれらの新しいセマンティクスを実装するというサイドクエスト(結局、元のクエストよりも困難でした)に着手しました。これには、LLVMおよびCバックエンドだけでなく、comptime 実行も含まれます。結局のところ、Zigは @bitCast を含め、ほとんどの操作をコンパイル時に実行できます!新しいセマンティクスは古いものとは実質的に異なるため(後述)、標準ライブラリ、コンパイラ、およびサポートライブラリ(例: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]` の最下位ビットから始めて連結し、
    // 結果のベクトル値 `vec` の要素を取得するために、そこから2ビットチャンクを読み取ります。
    //
    //     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#35533 の時点で、新しい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のテトリスクローンhttps://github.com/andrewrk/tetris で試している様子をクリップで紹介します。

[動画]

Andrewのテトリスクローンの数個の些細な変更が、それぞれ約30msでビルドされています。

また、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つの肥大化したプロセスにコンパイルされていました。build.zig ロジックがメモリ内でビルドグラフの構築を完了した後、「ビルドランナー」コードがそれを実行していました。

現在、build.zig ファイルは小さなプロセス(「configurer」)にデバッグモードでコンパイルされます。このロジックがメモリ内でビルドグラフを構築し終えると、バイナリ設定ファイルにシリアライズされます。親の zig build プロセスはこのファイルを知っており、次回のためにキャッシュします。その間、リリースモードでビルドグラフ実行プロセス(「maker」)を非同期にコンパイルします。設定ファイルが利用可能になり、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}], 1Hello, World!
) = 14
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, 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, 8Hello, World!
) = 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 フラグが追加されたことです。

retrospect で考えると、それは非常に明白で、最初からなぜ思いつかなかったのかわかりません。これは次のようになります。

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日

カーネル32.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を優先する理由です。まだそこには到達していませんが、最近大きな進歩を遂げました。2つの例を挙げます。

例1:エントロピー

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

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

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

ProcessPrng が最初に行うことは、少量の定数バイトをヒープに割り当てることです。これが失敗した場合、BOOL で NO_MEMORY を返します(文書化された動作は失敗せず、常に TRUE を返すことです)。

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

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