Zig 0.12.0 Release Notes

No the Ziguana Download & & Documentation Zig is a general-purpose programs language and toolchain for preserving robust 19459304, 19459303 optimum , and 19459303 recyclable software application. Zig advancement is moneyed through 19459305 Zig Software Foundation , a 501( c)( 3) non-profit company. Please think about a repeating contribution so that we can provide more billable hours to our core employee. This is the most uncomplicated method to speed up the task along the 19459306 Roadmap to 1.0. 19659005 This release includes 19459303 8 months of work 19459304: modifications from 19459303 268 various factors 19459304, spread amongst 19459303 3688 dedicates 19659006 In the past, these release notes have actually been very long, trying to bear in mind of all improvements that happened throughout the release cycle. In the interest of not frustrating the reader in addition to the maintainers developing these notes, this file is abridged. Lots of modifications, consisting of API breaking modifications, are not pointed out here. Tabulation 19659008 § 19659009 Tabulation Assistance Table 19659011 Tier System 19659012 Tier 1 Support Tier 2 Support 19659014 Tier 3 Support Tier 4 Support Revamp How Autodoc Works 19659017 Set Up Standard Library Documentation 19659018 Time to Generate Documentation New Autodoc Features Trustworthy Linkification Interactive Source Listings 19659022 Embedded Source Listings 19659023 Browse Includes Doc Comments 19659024 Mistake Set View 19659025 Right Type Detection Correct Implementation of Scroll History Language Changes 19659028 Unneeded Use of var 19659029 Outcome Location Semantics Aggregate Destructuring 19659031 Namespace Type Equivalence 19659032 Comptime Memory Changes 19659033 @fieldParentPtr 19659034 Prohibit positioning on function type @errorCast 19659036 @abs 19659037 Requirement Library 19659038 Windows Command Line Argument Parsing 19659039 Bring-Your-Own-OS API Layer Regressed std.os relabelled to std.posix 19659041 Ryu Floating-Point Formatting Revamped HTTP Elimination of std.http.Headers Rework Server Entirely deflate reimplemented from very first concepts 19659046 std.posix APIs Gain Type Safety 19659047 std.builtin Enum Fields Lowercased Worldwide Configuration Tip Stability Locks 19659050 Develop System Package Mode Capability to Declare Optional System Library Integration System Integration Help Section 19659054 Utilizing the System Integration Options New Release Option 19659056 Prevent Fetching in System Mode Lazy Dependencies 19659058 present b.path; deprecate LazyPath.relative 19659059 Header Installation dependencyFromBuildZig 19659061 Compiler x86 Backend 19659063 Windows Resources Linker Cache System Bug Fixes Comptime Pointer Access 19659068 This Release Contains Bugs 19659069 Toolchain LLVM 17 musl 1.2.4 19659072 glibc 2.38 mingw-w64 19659074 Roadmap Async/Await Feature Status Thank You Contributors! 19659077 Thank You Sponsors! Assistance Table 19659079 § Tier System § A green check mark (✅) suggests the target satisfies all the requirements for the assistance tier. The other icons suggest what is 19459391 avoiding the target from reaching the assistance tier 19459392 To put it simply, the icons are to-do products If you discover any incorrect information here please 19459393 send a pull demand 19659083 Tier 1 Support § 19659085 Not just can Zig create device code for these targets, however the Requirement Library cross-platform abstractions have applications for these targets. The CI server immediately evaluates these targets on every dedicate to master branch. The icon indicates this target does not yet have CI test protection. The CI server instantly produces pre-built binaries for these targets, on every devote to master, and updates 19459399 the download page with links. The icon implies the download page is missing this target. 19659088 These targets have actually debug information abilities and for that reason produce stack traces on stopped working assertions. 19659089 libc is readily available for this target even when cross assembling. All the habits tests and appropriate basic library tests pass for this target. All language functions are understood to work properly. Speculative functions do not count towards disqualifying an os or architecture from Tier 1. The icon indicates there are recognized bugs 19459302 avoiding this target from reaching Tier 1. zig cc, zig c++, and associated toolchain commands assistance this target. If the Operating System is exclusive then the target is not significant deprecated by the supplier. The icon indicates the OS is formally deprecated, 19459401 such as macos/x86 19459302 19659093 freestanding Linux 3.16+ 19659095 macOS 11+ Windows 10+ WASI 19659098 x86_64 19659099 ✅ ✅ 19659101 ✅ 19659102 ✅ N/A 19659104 x86 ✅ 19659106 # 1929 19659108 # 537 N/A aarch64 ✅ 19659112 # 2443 19459302 19659113 ✅ # 16665 19459302 19659115 N/A arm 19659117 ✅ 19659118 # 3174 19659119 N/A 19659122 mips 19659123 ✅ # 3345 19459302 N/A 19659126 N/A N/A riscv64 ✅ 19659130 # 4456 19659131 N/A N/A N/A 19659134 sparc64 19659135 ✅ # 4931 19459302 N/A N/A N/A powerpc64 19659141 ✅ 19659142 19659143 N/A 19659144 N/A N/A 19659146 powerpc ✅ 19659149 N/A 19659150 N/A 19659151 N/A wasm32 19659153 ✅ N/A 19659155 N/A N/A 19659157 ✅ 19659158 Tier 2 Support 19659159 § 19659160 The 19459398 Requirement Library 19459302 assistances this target, however it is possible that some APIs will offer an “Unsupported OS” put together mistake. One can relate to libc or other libraries to complete the spaces in the basic library. The icon implies the basic library is too insufficient to be thought about Tier 2 worthwhile. These targets are understood to work, however might not be immediately checked, so there are periodic regressions. methods that no one has actually truly checked out this target so whether it works is unidentified. 19659162 Some tests might be handicapped for these targets as we pursue Tier 1 Support complimentary standing Linux 3.16+ 19659165 macOS 11+ Windows 10+ FreeBSD 12.0+ 19659168 NetBSD 8.0+ Dragon FlyBSD 5.8+ 19659170 OpenBSD 7.3+ 19659171 UEFI 19659172 x86_64 Tier 1 Tier 1 19659175 Tier 1 19659176 Tier 1 19659177 ✅ 19659178 ✅ ✅ ✅ ✅ x86 Tier 1 ✅ 19659186 ✅ 19659187 19659188 19659189 N/A 19659190 ✅ 19659192 aarch64 19659193 Tier 1 19659194 ✅ 19659195 Tier 1 19659196 ✅ 19659197 19659198 N/A arm Tier 1 19659204 ✅ 19659205 19659206 19659207 19659208 N/A 19659211 mips64 19659213 ✅ ✅ 19659215 N/A 19659216 N/A 19659219 N/A 19659221 N/A 19659222 mips 19659223 Tier 1 ✅ 19659225 N/A 19659226 N/A 19659228 N/A 19659231 N/A 19659232 powerpc64 Tier 1 19659234 ✅ 19659236 N/A 19659239 N/A 19659240 N/A powerpc 19659243 Tier 1 ✅ N/A 19659248 N/A 19659250 19659251 N/A 19659252 riscv64 19659253 Tier 1 19659254 ✅ N/A 19659256 N/A 19659257 19659258 N/A 19659260 19659261 19659262 sparc64 Tier 1 19659264 ✅ 19659265 N/A N/A 19659267 19659269 N/A N/A Tier 3 Support 19659273 § 19659274 The basic library has little to no understanding of the presence of this target. 19659275 If this target is supplied by LLVM, LLVM has the target made it possible for by default. These targets are not regularly evaluated; one will likely require to add to Zig in order to construct for these targets. 19659277 The Zig compiler may require to be upgraded with a couple of things such as 19659278 what sizes are the C integer types 19659279 C ABI calling convention for this target begin code and default panic handler is ensured to include this target. 19659282 freestanding Linux 3.16+ 19659284 Windows 10+ FreeBSD 12.0+ NetBSD 8.0+ UEFI x86_64 Tier 1 Tier 1 Tier 1 19659292 Tier 2 19659293 Tier 2 19659294 Tier 2 19659295 x86 Tier 1 19659297 Tier 2 Tier 2 19659299 ✅ ✅ Tier 2 19659302 aarch64 19659303 Tier 1 Tier 2 19659305 Tier 2 19659306 ✅ 19659307 ✅ ✅ 19659309 arm 19659310 Tier 1 Tier 2 ✅ 19659313 ✅ 19659314 ✅ 19659315 ✅ mips64 Tier 2 Tier 2 N/A 19659320 ✅ 19659321 ✅ 19659322 N/A 19659323 mips Tier 1 19659325 Tier 2 19659326 N/A 19659327 ✅ ✅ 19659329 N/A 19659330 riscv64 19659331 Tier 1 Tier 2 19659333 N/A 19659334 ✅ ✅ ✅ powerpc32 Tier 2 19659339 Tier 2 N/A 19659341 ✅ 19659342 ✅ 19659343 N/A powerpc64 Tier 2 19659346 Tier 2 19659347 N/A ✅ 19659349 ✅ N/A 19659351 bpf ✅ 19659353 ✅ N/A ✅ ✅ N/A 19659358 hexagon 19659359 ✅ ✅ N/A 19659362 ✅ ✅ N/A 19659365 amdgcn ✅ ✅ 19659368 N/A 19659369 ✅ 19659370 ✅ 19659371 N/A sparc 19659373 ✅ 19659374 ✅ 19659375 N/A ✅ 19659377 ✅ 19659378 N/A s390x 19659380 ✅ ✅ N/A 19659383 ✅ 19659384 ✅ 19659385 N/A lanai ✅ 19659388 ✅ N/A 19659390 ✅ ✅ N/A 19659393 csky ✅ ✅ N/A ✅ ✅ N/A freestanding emscripten 19659402 wasm32 19659403 Tier 1 19659404 ✅ 19659405 Tier 4 Support 19659406 § 19659407 Assistance for these targets is totally speculative. If this target is supplied by LLVM, LLVM might have the target as a speculative target, which indicates that you require to utilize Zig-provided binaries for the target to be offered, or develop LLVM from source with unique configure flags. 19459082 will show the target if it is readily available. 19659409 This target might be thought about deprecated by a main celebration, in which case this target will stay permanently stuck in Tier 4. 19659410 This target might just support 19459084 and can not discharge things files, in which case is allowed by default and can not be bypassed. 19659411 Tier 4 targets: 19659412 avr riscv32 xcore nvptx msp430 19659417 r600 arc tce le 19659421 amdil 19659422 hsail 19659423 spir kalimba shave renderscript 32-bit x86 macOS, 32-bit ARM macOS, powerpc32 and powerpc64 macOS, due to the fact that 19459401 Apple has actually formally dropped assistance for them 19659428 Upgrade How Autodoc Works 19659429 § 19659430 Ziggy the Ziguana This release erases the previous (speculative) Autodoc application and changes it with a brand-new (not speculative!) one. The old execution appeared like this: 19659433 After collection (sizes are for basic library documents): 19659434 Overall output size: 47M (5.7 M gzipped) processed ZIR code, outputting JSON information for a web application to take in. This led to a great deal of code ineffectively attempting to rebuild the AST from no-longer-available information. 19659436 was a third-party markdown application that supported a lot of functions 19459392; for instance I do not desire it to be possible to have HTML tags in doc remarks, since that would make source code uglier. Just markdown that looks excellent both as source and rendered must be enabled. 19659437 was an application of Zig language tokenization in JavaScript, in spite of Zig currently exposing its own tokenizer in the basic library. When I saw this 19459438 contributed to the zig job , 19459439 a little part of me passed away inside 19459302 was a tool that converted.zig files to a syntax-highlighted however non-interactive. zig.html files. 19659439 The brand-new execution appears like this: After collection (sizes are for basic library paperwork): Overall output size: 12M (2.3 M gzipped) 19659442 As you can see, it is both significantly easier in regards to execution in addition to develop artifacts. Now there are precisely 4 files rather of lots of, with a 4x decrease in overall file size of the created web app. 19659443 Not just is it easier, it is really more effective than the old system, since rather of processing ZIR, this system processes the source submits straight, indicating it has 100% of the info and never ever requires to piece anything together in reverse. 19659444 This method utilizes a WebAssembly module composed in Zig. This permits it to recycle elements from the compiler, such as the tokenizer, parser, and other energies for running on Zig code. The sources.tar file, after being decompressed by the HTTP layer, is fed straight into the wasm module’s memory. The tar file is parsed utilizing std.tar and source files are parsed in location, with some extra calculations contributed to hash tables on the side. There is space for presenting employee threads to accelerate the parsing, although single-threaded it is currently so quick that it does not appear required. Set Up Standard Library Documentation § 19659449 In Zig 0.11.0, a Zig setup features a directory site which contains those 47M of output artifacts pointed out above. This reword eliminated those artifacts from Zig setups, rather using the 19459091 command, which hosts sexually transmitted disease lib autodocs and generates an internet browser window to see them. When this command is triggered, is put together from source to perform this operation. The HTTP server produces the asked for files on the fly, consisting of restoring if any of its source files altered, and building 19459094, indicating that any source modifications to the recorded files, 19459391 or to the autodoc system itself are instantly shown when seeing docs. Prefixing the URL with 19459095 lead to a debug construct of the WebAssembly module. 19659452 This indicates factors can evaluate modifications to Zig basic library paperwork, along with autodocs performance, by pushing refresh in their web browser window, utilizing a just binary circulation of Zig. 19659453 In overall, this decreased the Zig setup size from 317M to 268M (-15%). A ReleaseSmall develop of the compiler avoids 10M to 9.8 M (-1%). 19659455 Time to Generate Documentation 19659456 § 19659457 Autodocs generation is now done appropriately as part of the pipeline of the compiler instead of added at the end. It likewise no longer has any reliances on other parts of the pipeline. This is the length of time it now requires to produce basic library paperwork: It utilized to take upwards of 13 seconds. Now it takes 25ms. 19659460 New Autodoc Features 19659461 § Dependable Linkification 19659463 § 19659464 This comes from the reality that with complete source files we have all the info, and can compose more robust code to search for identifiers from the context they happen in. Interactive Source Listings § Press 19459096 to go to source code for any statement: interactive source listings”>

The links take you to the API page for that particular link by altering the area hash.

Embedded Source Listings §

Mistake Set View §

Merged mistake sets are discovered:

Mistakes that originate from other statements are connected:

Mistakes are likewise revealed on function view:

Proper Type Detection §

Previous execution guesses incorrect on the kind of options As DynLib

Correct Implementation of Scroll History §

The previous application carried out scroll history in JavaScript, which is difficult to do properly. The brand-new system makes mindful usage of the ‘popstate’ occasion integrated with the history API to scroll to the top of the window just when the user browses to a brand-new link – appreciating the web browser’s conserved scroll history in all other cases.

For more information see
the devote diff

Language Changes §

Unneeded Use of var §

Zig 0.12.0 presents a brand-new put together mistake which is given off when a regional variable is stated as a varhowever the compiler can presume that const would be adequate.

const expectEqual = @import("std").testing.expectEqual;
test "unnecessary use of var" {
    var x: u32 = 123;
    try expectEqual(123, x);
}

$ zig test unnecessary_var.zig
docgen_tmp/unnecessary_var.zig:3:9: error: local variable is never mutated
    var x: u32 = 123;
        ^
docgen_tmp/unnecessary_var.zig:3:9: note: consider using 'const'

As shown by the mistake message, the service is basic: utilize const rather where suitable.

Outcome Location Semantics §

Zig 0.12.0 includes numerous improvements to Result Location Semantics (RLS).

This release carries out forwarding of outcome types through the address-of operator (&. This enables syntactic constructs which depend on outcome types, such as confidential initializations .{ ... }
and casting builtins like @intCastto work properly in the existence of the address-of operator:

const S = struct { x: u32 };
const int: u64 = 123;
const val: *const S = &.{ .x = @intCast(int) };
comptime {
    _ = val;
}

$ zig test address_of_rls.zig
All 0 tests passed.

In addition, Zig 0.12.0 eliminates the capability for outcome places to propagate through @as
and explicitly-typed aggregate initializations T{ ... }This limitation remains in location to streamline the language style: previous releases included a number of bugs associating with inaccurate casting of outcome tips.

Aggregate Destructuring §

Zig 0.12.0 presents a brand-new syntax to permit destructuring indexable aggregates: that is, tuples, vectors, and ranges. Composing a series of lvalues or regional variable statements on the left-hand side of the project will try to destructure the worth defined on the right-hand side:

const std = @import("std");
const assert = std.debug.assert;
const expectEqual = std.testing.expectEqual;
test "destructure array" {
    var z: u32 = undefined;
    const x, var y, z = [3]u32{ 1, 2, 3 };
    y += 10;
    try expectEqual(1, x);
    try expectEqual(12, y);
    try expectEqual(3, z);
}
test "destructure vector" {
    // Comptime-known values are propagated as you would expect.
    const x, const y = @Vector(2, u32){ 1, 2 };
    comptime assert(x == 1);
    comptime assert(y == 2);
}
test "destructure tuple" {
    var runtime: u32 = undefined;
    runtime = 123;
    const x, const y = .{ 42, runtime };
    // The first tuple field is a `comptime` field, so `x` is comptime-known even
    // though `y` is runtime-known.
    comptime assert(x == 42);
    try expectEqual(123, y);
}

$ zig test destructure.zig
1/3 destructure.test.destructure array... OK
2/3 destructure.test.destructure vector... OK
3/3 destructure.test.destructure tuple... OK
All 3 tests passed.

Pieces can not be straight destructured. To destructure worths from a piece, transform it to a range by slicing with comptime-known bounds, such as slice[0..3].*

Namespace Type Equivalence §

In Zig, struct enum unionand opaque types are unique. They do not utilize structural equivalence, like tuples and ranges do; rather, they produce unique types. These types have namespaces, and therefore might consist of statements. For this factor, they can be described jointly as “namespace types”.

In 0.11.0, each time a statement of such a type was semantically examined, a brand-new type was developed. Equivalence of generic types was managed by means of memoization of comptime function calls; i.e.
std.ArrayList(u8) == std.ArrayList(u8) held since the ArrayList function was just called when, and its outcomes memoized.

In 0.12.0, this has actually altered. Namespace types are now deduplicated based upon 2 elements: their source place, and their captures.

The “records” of a type describes the set of comptime-known types and worths which it closes over. To put it simply, it is the set of worths referenced within the type however stated beyond it. The
comptime T: type specification of std.ArrayList is recorded by the type it returns. If 2 namespace types are stated by the very same piece of code and have the exact same captures, they are now thought about to be specifically the exact same type.

Keep in mind that the compiler will still memoize comptime calls: that hasn’t altered. This memoization no longer has a significant effect on language semantics.

It is not likely that this modification will trigger damage in existing code. The most likely situation where it might is something like the following:

fn MakeOpaque(comptime n: comptime_int) type {
    _ = n;
    return opaque {};
}
const A = MakeOpaque(0);
const B = MakeOpaque(1);

In Zig 0.11.0, this code would produce 2 unique types, due to the fact that the calls to MakeOpaque stand out and therefore the opaque statement was evaluated individually for each call. In Zig 0.12.0, these types equal (A == Bsince while the function is called two times, the statement does not catch any worth.

This code can be repaired by requiring the type statement to record n:

fn MakeOpaque(comptime n: comptime_int) type {
    return opaque {
        comptime {
            _ = n;
        }
    };
}
const A = MakeOpaque(0);
const B = MakeOpaque(1);

Considering that n is referenced within the opaque statement, this code develops 2 unique types.

Comptime Memory Changes §

Zig 0.12.0 revamps the compiler’s internal representation of comptime memory, and more particularly comptime-mutable memory (i.e. comptime var. This overhaul includes some user-facing modifications in the kind of brand-new limitations on what you can do with a comptime var

The very first, and the majority of substantial, brand-new guideline is that a tip to a comptime var is never ever permitted to end up being runtime-known. Think about the following bit:

test "runtime-known comptime var pointer" {
    comptime var x: u32 = 123;
    // `var` makes `ptr` runtime-known
    var ptr: *const u32 = undefined;
    ptr = &x;
    if (ptr.* != 123) return error.TestFailed;
}

$ zig test comptime_var_ptr_runtime.zig
docgen_tmp/comptime_var_ptr_runtime.zig:5:11: error: runtime value contains reference to comptime var
    ptr = &x;
          ^~
docgen_tmp/comptime_var_ptr_runtime.zig:5:11: note: comptime var pointers are not available at runtime

In previous variations of Zig, this test passed as you may anticipate. In Zig 0.12.0, it gives off a put together mistake, due to the fact that the task to ptr makes the worth &x – which is a guideline to a
comptime var – runtime-known.

Such guidelines can likewise end up being runtime-known by, for example, being passed to a function called at runtime:

test "comptime var pointer as runtime argument" {
    comptime var x: u32 = 123;
    if (load(&x) != 123) return error.TestFailed;
}
fn load(ptr: *const u32) u32 {
    return ptr.*;
}

$ zig test comptime_var_ptr_runtime_arg.zig
docgen_tmp/comptime_var_ptr_runtime_arg.zig:3:14: error: runtime value contains reference to comptime var
    if (load(&x) != 123) return error.TestFailed;
             ^~
docgen_tmp/comptime_var_ptr_runtime_arg.zig:3:14: note: comptime var pointers are not available at runtime

This test likewise produces a put together mistake in Zig 0.12.0. The call to load happens at runtime, and its
ptr criterion is not significant comptimeso ptr is runtime-known within the body of loadThis suggests the call to load makes the tip &x
runtime-known, thus the put together mistake.

This limitation was put in location to repair some strength bugs. When a tip to a comptime var
ends up being runtime-known, anomalies to it end up being void considering that the pointed-to information ends up being continuous, however the type system stops working to show this, resulting in the capacity for runtime division faults in what seems legitimate code. In addition, the worth you check out from such a guideline at runtime would be its “last” comptime worth, which was an unintuitive habits. Therefore, these guidelines can no longer be runtime-known.

The 2nd brand-new constraint is that a guideline to a comptime var is never ever permitted to be included within the dealt with worth of an international statement. Think about the following bit:

const ptr: *const u32 = ptr: {
    var x: u32 = 123;
    break :ptr &x;
};
comptime {
    _ = ptr;
}

$ zig test comptime_var_ptr_global.zig
docgen_tmp/comptime_var_ptr_global.zig:1:30: error: global variable contains reference to comptime var
const ptr: *const u32 = ptr: {
                        ~~~~~^
referenced by:
    comptime_0: docgen_tmp/comptime_var_ptr_global.zig:6:9
    remaining reference traces hidden; use '-freference-trace' to see all reference traces

Here, ptr is a worldwide statement whose worth is a tip to a comptime varThis statement was allowed in Zig 0.11.0, however raises an assemble mistake in Zig 0.12.0. The very same guideline uses in more intricate cases, such as when the tip is included within a struct field:

const S = struct { ptr: *const u32 };
const val: S = blk: {
    var x: u32 = 123;
    break :blk .{ .ptr = &x };
};
comptime {
    _ = val;
}

$ zig test comptime_var_ptr_global_struct.zig
docgen_tmp/comptime_var_ptr_global_struct.zig:2:21: error: global variable contains reference to comptime var
const val: S = blk: {
               ~~~~~^
referenced by:
    comptime_0: docgen_tmp/comptime_var_ptr_global_struct.zig:7:9
    remaining reference traces hidden; use '-freference-trace' to see all reference traces

This code raises the very same assemble mistake as the previous example. This constraint has actually been put in location mostly to help the application of incremental collection in the Zig compiler, which depends upon the truth that analysis of international statements is order-independent, and the dependences in between statements can be quickly designed.

The most typical method for this to manifest as a put together mistake in existing code is if a function constructs a piece at comptime which is then utilized at runtime. Think about the following bit:

fn getName() []const u8 {
    comptime var buf: [9]u8 = undefined;
    // In practice there would likely be more complex logic here to populate `buf`.
    @memcpy(&buf, "some name");
    return &buf;
}
test getName {
    try @import("std").testing.expectEqualStrings("some name", getName());
}

$ zig test construct_slice_comptime.zig
docgen_tmp/construct_slice_comptime.zig:5:12: error: runtime value contains reference to comptime var
    return &buf;
           ^~~~
docgen_tmp/construct_slice_comptime.zig:5:12: note: comptime var pointers are not available at runtime
referenced by:
    decltest.getName: docgen_tmp/construct_slice_comptime.zig:8:64
    remaining reference traces hidden; use '-freference-trace' to see all reference traces

A call to getName returns a piece whose ptr field is a tip to a
comptime varThis indicates the worth can not be utilized at runtime, nor can it appear in the worth of a worldwide statement. This code can be repaired by promoting the computed information to a const
after filling the buffer:

fn getName() []const u8 {
    comptime var buf: [9]u8 = undefined;
    // In practice there would likely be more complex logic here to populate `buf`.
    @memcpy(&buf, "some name");
    const final_name = buf;
    return &final_name;
}
test getName {
    try @import("std").testing.expectEqualStrings("some name", getName());
}

$ zig test construct_slice_comptime.zig
1/1 construct_slice_comptime.decltest.getName... OK
All 1 tests passed.

Like in previous variations of Zig, comptime-known consts have unlimited life time, and the limitations talked about here do not use to them. This code operates as anticipated.

Another possible failure mode remains in code which utilized the old semantics to develop worldwide mutable comptime state. The following bit efforts to develop an international comptime counter:

const counter: *u32 = counter: {
    var n: u32 = 0;
    break :counter &n;
};
comptime {
    counter.* += 1;
}

$ zig test global_comptime_counter.zig
docgen_tmp/global_comptime_counter.zig:1:32: error: global variable contains reference to comptime var
const counter: *u32 = counter: {
                      ~~~~~~~~~^
referenced by:
    comptime_0: docgen_tmp/global_comptime_counter.zig:6:5
    remaining reference traces hidden; use '-freference-trace' to see all reference traces

This code discharges an assemble mistake in Zig 0.12.0. This usage case is not and will not be supported by Zig: any mutable comptime state should be represented in your area.

@fieldParentPtr §

The very first argument is gotten rid of in favor of utilizing the outcome type

Migration guide:

const parent_ptr = @fieldParentPtr(Parent, "field_name", field_ptr);

↓

const parent_ptr: *Parent = @fieldParentPtr("field_name", field_ptr);

or

const parent_ptr: *Parent = @alignCast(@fieldParentPtr("field_name", field_ptr));

depending upon what moms and dad guideline positioning the compiler has the ability to show. The 2nd kind is more portable, because it’s possible for the
@alignCast to be required for some targets however not others.

Prohibit positioning on function type §

Zig 0.11.0 enabled function types to define a positioning. This is prohibited in Zig 0.12.0, because is it a home of function statements and guidelines, not of function types.

comptime {
    _ = fn () align(4) void;
}

$ zig test func_type_align.zig
docgen_tmp/func_type_align.zig:2:21: error: function type cannot have an alignment
    _ = fn () align(4) void;
                    ^

@errorCast §

Previous releases of Zig consisted of an @errSetCast builtin which carried out a safety-checked cast from one mistake set to another, possibly smaller sized, one. In Zig 0.12.0, this builtin is changed with
@errorCastPrevious usages will continue to work, however in addition, this brand-new builtin can cast the mistake set of a mistake union:

const testing = @import("std").testing;

test "@errorCast error set" {
    const err: error{Foo, Bar} = error.Foo;
    const casted: error{Foo} = @errorCast(err);
    try testing.expectEqual(error.Foo, casted);
}

test "@errorCast error union" {
    const err: error{Foo, Bar}!u32 = error.Foo;
    const casted: error{Foo}!u32 = @errorCast(err);
    try testing.expectError(error.Foo, casted);
}

test "@errorCast error union payload" {
    const err: error{Foo, Bar}!u32 = 123;
    const casted: error{Foo}!u32 = @errorCast(err);
    try testing.expectEqual(123, casted);
}

$ zig test error_cast.zig
1/3 error_cast.test.@errorCast error set... OK
2/3 error_cast.test.@errorCast error union... OK
3/3 error_cast.test.@errorCast error union payload... OK
All 3 tests passed.

@abs §

Previous releases of Zig consisted of the @fabs builtin. This has actually been changed with a brand-new
@abs builtin, which has the ability to run on integers along with drifts:

const expectEqual = @import("std").testing.expectEqual;

test "@abs on float" {
    const x: f32 = -123.5;
    const y = @abs(x);
    try expectEqual(123.5, y);
}

test "@abs on int" {
    const x: i32 = -12345;
    const y = @abs(x);
    try expectEqual(12345, y);
}

$ zig test abs.zig
1/2 abs.test.@abs on float... OK
2/2 abs.test.@abs on int... OK
All 2 tests passed.

Requirement Library §

Windows Command Line Argument Parsing §

On Windows, the command line arguments of a program are a single WTF-16 encoded string and it’s up to the program to divide it into a variety of strings. In C/C++, the entry point of the C runtime looks after splitting the command line and passing argc/argv to the primary function.

Formerly, ArgIteratorWindows matched the habits of CommandLineToArgvW, however it ends up that CommandLineToArgvW’s habits does not match the habits of the C runtime post-2008. In 2008, the C runtime argv splitting
altered how it deals with successive double quoteswithin a priced quote argument (it’s now thought about a left quote, e.g.
"foo""bar" post-2008 would get parsed into foo"barand the guidelines around argv[0] were likewise altered.

This release makes ArgIteratorWindows match the habits of the post-2008 C runtime. The inspiration here is approximately the like when the
very same modification was made in Rust that is (paraphrased):

• Constant habits in between Zig and contemporary C/C++ programs
• Enables users to leave double quotes in such a way that can be more simple

Furthermore, the recommended mitigation for
BatBadBut depends on the post-2008 argv splitting habits for roundtripping of the arguments provided to cmd.exe.

The BadBatBut mitigation did not make the 0.12.0 release cutoff.

Bring-Your-Own-OS API Layer Regressed §

Previous variations of Zig enabled applications to bypass the POSIX API layer of the basic library. This release purposefully eliminates this capability, without any migration course used.

This was an error from the first day. This is the incorrect abstraction layer to do this in.

The alternate prepare for this is to make all I/O operations need an IO user interface specification, comparable to how allotments need an Allocator user interface criterion today.

Such a strategy is not yet executed, so applications which need this performance needs to keep a fork of the basic library up until then.

std.os relabelled to std.posix §

Migration guide:

std.os.abort();

↓

std.posix.abort();

Normally, one ought to choose to utilize the higher-level cross-platform abstractions instead of reaching into the POSIX API layer. std.process.exit is more portable than
std.posix.exitYou ought to typically anticipate the API inside std.posix
to be offered on an offered OS when the OS executes that corresponding POSIX performance.

Ryu Floating-Point Formatting §

Zig 0.12.0 changes the previous errol drifting point format algorithm with one based upon
Ryua modern-day algorithm for transforming IEEE-754 floating-point numbers to decimal strings.

The enhancements this brings are:

• Capability to format f80 and f128 types
• More precise f16 and f32 format
• Total round-trip assistance for every single float type
• Generic backend that can be utilized to print any float of a basic variety of bits (less than or equivalent to 128 bits)

Habits Differences:

• Exponents are no longer padded with a leading 0 to 2-digits and if favorable, the indication is no longer printed:

  errol: 1e+02
  ryu:   1e2

• Fractional worths of 0 are left out completely accuracy mode:

  errol: 2.0e+00
  ryu:   2e0

• Complete accuracy output is more precise in all cases besides f64, considering that we no longer do a cast internally to f64:

  # Ryu
  3.1234567891011121314151617181920212E0 :f128
  3.1234567891011121314E0 :f80
  3.1234567891011121314E0 :c_longdouble
  3.123456789101112E0 :f64
  3.1234567E0 :f32
  3.123E0 :f16
  
  ## Errol
  3.123456789101112e+00 :f128
  3.123456789101112e+00 :f80
  3.123456789101112e+00 :c_longdouble
  3.123456789101112e+00 :f64
  3.12345671e+00 :f32
  3.123046875e+00 :f16

• Furthermore, rounding behaviour in these cases can vary in the repaired accuracy case as the fastest representation will usually vary:

  # bits:         141333
  # precision:    3
  # std_shortest: 1.98049715e-40
  # ryu_shortest: 1.9805e-40
  # type:         f32
  |
  | std_dec: 0.000
  | ryu_dec: 0.000
  |
  | std_exp: 1.980e-40
  | ryu_exp: 1.981e-40

Efficiency: ~ 2.3 x efficiency enhancement

Code Size: approximately +5 KB (2x)

Source for those statistics

Revamped HTTP §

Some quite simple modifications:

• do not give off Server HTTP header. Let the user include that if they want to. It’s not strictly needed, and perhaps a damaging default.
• fix the mistake set of finish to not have NotWriteable and MessageTooLong in it
• safeguard versus zero-length pieces in Server
• include missing out on redirect habits choice to FetchOptions and make it an enum rather of 2 fields
• error.CompressionNotSupported is relabelled to error.CompressionUnsupportedmatching the calling convention from all the other mistakes in the very same set.
• Gotten rid of paperwork remarks that were redundant with field and type names.
• Disabling zstd decompression in the server in the meantime; see # 18937.
• Immediately manage anticipate: 100-continue demands

Next,
eliminated the capability to heap-allocate the buffer for headersThe buffer for HTTP headers is now constantly offered through a fixed buffer. As an effect, OutOfMemory is no longer a member of the read() mistake set, and the API and execution of Client and Server are streamlined. error.HttpHeadersExceededSizeLimit is relabelled to error.HttpHeadersOversize

The huge modifications:

Rather, some headers are supplied through specific field names occupied while parsing the HTTP request/response, and some are supplied through brand-new fields that support passing additional, approximate headers. This led to simplification of reasoning in lots of locations, in addition to removal of the possibility of failure in numerous locations. There is less deinitialization code occurring now. It made it no longer essential to clone the headers information structure in order to manage redirects.

http_proxy and https_proxy fields are now guidelines given that it prevails for them to be uninhabited.

loadDefaultProxies is become initDefaultProxies to interact that it does not in fact load anything from disk or from the network. The function now is dripping; the API user need to pass a currently instantiated arena allocator. Eliminates the requirement to deinitialize proxies.

Before, proxies saved approximate sets of headers. Now they just save the permission worth.

Eliminated the duplicated code in between https_proxy and http_proxy. Parsing failures of the environment variables result in mistakes being produced rather than quietly neglecting the proxy.

Rework Server Entirely §

Primarily, this gets rid of the badly called wait send finish functions, which all run on the exact same “Response” things, which was really being utilized as the demand.

Now, it appears like this:

1. std.net.Server.accept() offers you a std.net.Server.Connection
2. std.http.Server.init() with the connection
3. Server.receiveHead() offers you a Request
4. Request.reader() offers you a body reader
5. Request.respond() is a one-shot, or Request.respondStreaming() develops a Response
6. Response.writer() offers you a body author
7. Response.end() surfaces the action; Response.endChunked() permits passing reaction trailers.

Simply put, the type system now guides the API user down the appropriate course.

receiveHead permits additional bytes to be checked out into the read buffer, and after that will recycle those bytes for the body or the next demand upon connection reuse.

respond()the one-shot function, will send out the whole reaction in one syscall.

Streaming action bodies no longer wastefully covers every call to compose with a portion header and trailer; rather it just sends out the HTTP piece wrapper when flushing. This suggests the user can still manage when it takes place however it likewise does not include unneeded pieces.

Empirically, the use code is considerably less loud, it has less mistake managing while dealing with mistakes more properly, it’s more apparent what is taking place, and it is syscall-optimal.

var read_buffer: [8000]u8 = undefined;
    accept: while (true) {
        const connection = try http_server.accept();
        defer connection.stream.close();

        var server = std.http.Server.init(connection, &read_buffer);
        while (server.state == .ready) {
            var request = server.receiveHead() catch |err| {
                std.debug.print("error: {s}n", .{@errorName(err)});
                continue :accept;
            };
            try static_http_file_server.serve(&request);
        }
    }

pub fn serve(context: *Context, request: *std.http.Server.Request) ServeError!void {
    // ...
    return request.respond(content, .{
        .status = status,
        .extra_headers = &.{
            .{ .name = "content-type", .value = @tagName(file.mime_type) },
        },
    });

In addition:

• Uncouple std.http.HeadParser from protocol.zig
• Erase std.Server.Connection; usage std.net.Server.Connection rather.
  • The API user provides the read buffer when initializing the http.Server, and it is utilized for the HTTP head along with a buffer for checking out the body into.
• Change and record the State enum. No longer exists both “begin” and “very first”.

std.http.Client has actually not yet been remodelled in a comparable way as std.http.Server

deflate reimplemented from very first concepts §

In Zig 0.11.0, the deflate application was ported from the Go basic library, which had a lot of unfavorable residential or commercial properties, such as inaccurate usage of worldwide variables, remarks about Go’s optimizer in Zig’s codebase, and the requirement of vibrant memory allotment.

Zig 0.12.0 has a brand-new application that is not a port of an existing codebase.

The brand-new execution is approximately 1.2-1.4 x quicker in decompression and 1.1-1.2 x quicker in compression. Compressed sizes are practically the very same in both cases (source .

The brand-new code utilizes fixed allowances for all structures, does not need allocator. That makes good sense particularly for deflate where all structures, internal buffers are designated to the complete size. Bit less for pump up where the previous verision utilized less memory by not preallocating to theoretical max size range which are normally not totally utilized.

For deflate the brand-new implementaiton designates 395K while previous execution utilized 779K. For pump up the brand-new application designates 74.5 K while the old one around 36K.

Pump up distinction is since we here utilize 64K history rather of 32K formerly.

Migration guide:

const std = @import("std");

// To get this file:
// wget -nc -O war_and_peace.txt https://www.gutenberg.org/ebooks/2600.txt.utf-8
const data = @embedFile("war_and_peace.txt");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer std.debug.assert(gpa.deinit() == .ok);
    const allocator = gpa.allocator();

    try oldDeflate(allocator);
    try new(std.compress.flate, allocator);

    try oldZlib(allocator);
    try new(std.compress.zlib, allocator);

    try oldGzip(allocator);
    try new(std.compress.gzip, allocator);
}

pub fn new(comptime pkg: type, allocator: std.mem.Allocator) !void {
    var buf = std.ArrayList(u8).init(allocator);
    defer buf.deinit();

    // Compressor
    var cmp = try pkg.compressor(buf.writer(), .{});
    _ = try cmp.write(data);
    try cmp.finish();

    var fbs = std.io.fixedBufferStream(buf.items);
    // Decompressor
    var dcp = pkg.decompressor(fbs.reader());

    const plain = try dcp.reader().readAllAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(plain);
    try std.testing.expectEqualSlices(u8, data, plain);
}

pub fn oldDeflate(allocator: std.mem.Allocator) !void {
    const deflate = std.compress.v1.deflate;

    // Compressor
    var buf = std.ArrayList(u8).init(allocator);
    defer buf.deinit();
    // Remove allocator
    // Rename deflate -> flate
    var cmp = try deflate.compressor(allocator, buf.writer(), .{});
    _ = try cmp.write(data);
    try cmp.close(); // Rename to finish
    cmp.deinit(); // Remove

    // Decompressor
    var fbs = std.io.fixedBufferStream(buf.items);
    // Remove allocator and last param
    // Rename deflate -> flate
    // Remove try
    var dcp = try deflate.decompressor(allocator, fbs.reader(), null);
    defer dcp.deinit(); // Remove

    const plain = try dcp.reader().readAllAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(plain);
    try std.testing.expectEqualSlices(u8, data, plain);
}

pub fn oldZlib(allocator: std.mem.Allocator) !void {
    const zlib = std.compress.v1.zlib;

    var buf = std.ArrayList(u8).init(allocator);
    defer buf.deinit();

    // Compressor
    // Rename compressStream => compressor
    // Remove allocator
    var cmp = try zlib.compressStream(allocator, buf.writer(), .{});
    _ = try cmp.write(data);
    try cmp.finish();
    cmp.deinit(); // Remove

    var fbs = std.io.fixedBufferStream(buf.items);
    // Decompressor
    // decompressStream => decompressor
    // Remove allocator
    // Remove try
    var dcp = try zlib.decompressStream(allocator, fbs.reader());
    defer dcp.deinit(); // Remove

    const plain = try dcp.reader().readAllAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(plain);
    try std.testing.expectEqualSlices(u8, data, plain);
}

pub fn oldGzip(allocator: std.mem.Allocator) !void {
    const gzip = std.compress.v1.gzip;

    var buf = std.ArrayList(u8).init(allocator);
    defer buf.deinit();

    // Compressor
    // Rename compress => compressor
    // Remove allocator
    var cmp = try gzip.compress(allocator, buf.writer(), .{});
    _ = try cmp.write(data);
    try cmp.close(); // Rename to finisho
    cmp.deinit(); // Remove

    var fbs = std.io.fixedBufferStream(buf.items);
    // Decompressor
    // Rename decompress => decompressor
    // Remove allocator
    // Remove try
    var dcp = try gzip.decompress(allocator, fbs.reader());
    defer dcp.deinit(); // Remove

    const plain = try dcp.reader().readAllAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(plain);
    try std.testing.expectEqualSlices(u8, data, plain);
}

std.posix APIs Gain Type Safety §

Let’s look at std.posix.termios:

• Include missing out on API bits to termios and the kinds of its fields for all 12 os
• Right API bits on Linux (they were incorrect for some CPU architectures)
• Combine std.c meanings
• Include type security to all integers

Formerly this is how you would set instant mode on a tty:

const in = std.io.getStdIn();

// copy original settings and restore them once done
const original_termios = try std.posix.tcgetattr(in.handle);
defer std.posix.tcsetattr(in.handle, .FLUSH, original_termios) catch {};

// set immediate input mode
var termios = original_termios;
termios.lflag &= ~@as(std.posix.system.tcflag_t, std.posix.system.ICANON);

// flush changes
try std.posix.tcsetattr(in.handle, .FLUSH, termios);

Now the middle part appears like this:

// set immediate input mode
var termios = original_termios;
termios.lflag.ICANON = false;

This is thanks to the brand-new meanings based upon packed structHere’s for instance the meaning of lflag for Linux:

pub const tc_lflag_t = switch (native_arch) {
    .powerpc, .powerpcle, .powerpc64, .powerpc64le => packed struct(u32) {
        _0: u1 = 0,
        ECHOE: bool = false,
        ECHOK: bool = false,
        ECHO: bool = false,
        ECHONL: bool = false,
        _5: u2 = 0,
        ISIG: bool = false,
        ICANON: bool = false,
        _9: u1 = 0,
        IEXTEN: bool = false,
        _11: u11 = 0,
        TOSTOP: bool = false,
        _23: u8 = 0,
        NOFLSH: bool = false,
    },
    .mips, .mipsel, .mips64, .mips64el => packed struct(u32) {
        ISIG: bool = false,
        ICANON: bool = false,
        _2: u1 = 0,
        ECHO: bool = false,
        ECHOE: bool = false,
        ECHOK: bool = false,
        ECHONL: bool = false,
        NOFLSH: bool = false,
        IEXTEN: bool = false,
        _9: u6 = 0,
        TOSTOP: bool = false,
        _: u16 = 0,
    },
    else => packed struct(u32) {
        ISIG: bool = false,
        ICANON: bool = false,
        _2: u1 = 0,
        ECHO: bool = false,
        ECHOE: bool = false,
        ECHOK: bool = false,
        ECHONL: bool = false,
        NOFLSH: bool = false,
        TOSTOP: bool = false,
        _9: u6 = 0,
        IEXTEN: bool = false,
        _: u16 = 0,
    },
};

Much more std.posix APIs were changed in a comparable method.

std.builtin Enum Fields Lowercased §

Zig 0.12.0 seizes the day to change the field names of some enums in std.builtin to line up with our existing identifying conventions, which determine that enum fields ought to be snake_caseThe following enums have actually been upgraded:

• std.builtin.AtomicOrder
• std.builtin.ContainerLayout
• std.builtin.Endian
• std.builtin.FloatMode
• std.builtin.GlobalLinkage
• std.builtin.LinkMode

Worldwide Configuration §

Formerly, when one wished to bypass defaults, such as the logging function utilized by std.logthey would need to specify std_options in their root file, thus:

pub const std_options = struct {
    pub const logFn = myLogFn;
};

Keep in mind how std_options above is a struct type definitonIn this release std_options is now a circumstances of std.Optionsmaking the procedure of specifying overrides less error-prone.

The code above would appear like this now:

pub const std_options: std.Options = .{
    .logFn = myLogFn,
};

And this is the meaning of std.Options to see what else you can bypass.

pub const Options = struct {
    enable_segfault_handler: bool = debug.default_enable_segfault_handler,

    /// Function used to implement `std.fs.cwd` for WASI.
    wasiCwd: fn () os.wasi.fd_t = fs.defaultWasiCwd,

    /// The current log level.
    log_level: log.Level = log.default_level,

    log_scope_levels: []const log.ScopeLevel = &.{},

    logFn: fn (
        comptime message_level: log.Level,
        comptime scope: @TypeOf(.enum_literal),
        comptime format: []const u8,
        args: anytype,
    ) void = log.defaultLog,

    fmt_max_depth: usize = fmt.default_max_depth,

    cryptoRandomSeed: fn (buffer: []u8) void = @import("crypto/tlcsprng.zig").defaultRandomSeed,

    crypto_always_getrandom: bool = false,

    crypto_fork_safety: bool = true,

    /// By default Zig disables SIGPIPE by setting a "no-op" handler for it.  Set this option
    /// to `true` to prevent that.
    ///
    /// Note that we use a "no-op" handler instead of SIG_IGN because it will not be inherited by
    /// any child process.
    ///
    /// SIGPIPE is triggered when a process attempts to write to a broken pipe. By default, SIGPIPE
    /// will terminate the process instead of exiting.  It doesn't trigger the panic handler so in many
    /// cases it's unclear why the process was terminated.  By capturing SIGPIPE instead, functions that
    /// write to broken pipes will return the EPIPE error (error.BrokenPipe) and the program can handle
    /// it like any other error.
    keep_sigpipe: bool = false,

    /// By default, std.http.Client will support HTTPS connections.  Set this option to `true` to
    /// disable TLS support.
    ///
    /// This will likely reduce the size of the binary, but it will also make it impossible to
    /// make a HTTPS connection.
    http_disable_tls: bool = false,

    side_channels_mitigations: crypto.SideChannelsMitigations = crypto.default_side_channels_mitigations,
};

Tip Stability Locks §

This includes std.debug.SafetyLock and utilizes it in basic library hash maps by including lockPointers() and unlockPointers()

This supplies a method to find when an unlawful adjustment has actually occurred and panic instead of conjure up undefined habits:

const std = @import("std");

pub fn main() !void {
    const gpa = std.heap.page_allocator;
    var map: std.AutoHashMapUnmanaged(i32, i32) = .{};

    const gop = try map.getOrPut(gpa, 1234);
    map.lockPointers();
    defer map.unlockPointers();

    gop.value_ptr.* = try calculate(gpa, &map);
}

fn calculate(gpa: std.mem.Allocator, m: anytype) !i32 {
    try m.put(gpa, 42, 420);
    return 999;
}

$ zig build-exe safety_locks.zig
$ ./safety_locks
thread 188810 panic: reached unreachable code
/home/andy/local/lib/zig/std/debug.zig:403:14: 0x1036b4d in assert (safety_locks)
    if (!ok) unreachable; // assertion failure
             ^
/home/andy/local/lib/zig/std/debug.zig:2845:15: 0x10375fb in lock (safety_locks)
        assert(l.state == .unlocked);
              ^
/home/andy/local/lib/zig/std/hash_map.zig:1331:44: 0x1066683 in getOrPutContextAdapted__anon_6584 (safety_locks)
                self.pointer_stability.lock();
                                           ^
/home/andy/local/lib/zig/std/hash_map.zig:1318:56: 0x1037505 in getOrPutContext (safety_locks)
            const gop = try self.getOrPutContextAdapted(allocator, key, ctx, ctx);
                                                       ^
/home/andy/local/lib/zig/std/hash_map.zig:1244:52: 0x103765a in putContext (safety_locks)
            const result = try self.getOrPutContext(allocator, key, ctx);
                                                   ^
/home/andy/local/lib/zig/std/hash_map.zig:1241:35: 0x1034023 in put (safety_locks)
            return self.putContext(allocator, key, value, undefined);
                                  ^
/home/andy/docgen_tmp/safety_locks.zig:15:14: 0x1033fb6 in calculate__anon_3194 (safety_locks)
    try m.put(gpa, 42, 420);
             ^
/home/andy/docgen_tmp/safety_locks.zig:11:36: 0x10341eb in main (safety_locks)
    gop.value_ptr.* = try calculate(gpa, &map);
                                   ^
/home/andy/local/lib/zig/std/start.zig:511:37: 0x1033ec5 in posixCallMainAndExit (safety_locks)
            const result = root.main() catch |err| {
                                    ^
/home/andy/local/lib/zig/std/start.zig:253:5: 0x10339e1 in _start (safety_locks)
    asm volatile (switch (native_arch) {
    ^
???:?:?: 0x0 in ??? (???)
(process terminated by signal)

Something great about this is that if you utilize the “presume capability” variations then such anomalies are in fact distinct, and do not set off the issue:

const std = @import("std");

pub fn main() !void {
    const gpa = std.heap.page_allocator;
    var map: std.AutoHashMapUnmanaged(i32, i32) = .{};

    try map.ensureUnusedCapacity(gpa, 2);
    const gop = map.getOrPutAssumeCapacity(1234);
    map.lockPointers();
    defer map.unlockPointers();

    gop.value_ptr.* = calculate(&map);
}

fn calculate(m: anytype) i32 {
    m.putAssumeCapacity(42, 420);
    return 999;
}

$ zig build-exe assume_capacity.zig
$ ./assume_capacity

Follow-up jobs that did not make the release cutoff:

• present guideline stability security locks to selection lists
• present guideline stability security locks to MultiArrayList
• include stack traces to tip stability security locks

Develop System §

System Package Mode §

Makes the zig construct system considerably more friendly to system bundle maintainers by presenting System Integration Options.

Let’s analyze this function utilizing
groovebasin as an example task:

Capability to Declare Optional System Library Integration §

--- a/build.zig
+++ b/build.zig
@@ -5,18 +5,8 @@ pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{
         .preferred_optimize_mode = .ReleaseSafe,
     });
-    const libgroove_optimize_mode = b.option(
-        std.builtin.OptimizeMode,
-        "libgroove-optimize",
-        "override optimization mode of libgroove and its dependencies",
-    );
     const use_llvm = b.option(bool, "use-llvm", "LLVM backend");
 
-    const groove_dep = b.dependency("groove", .{
-        .optimize = libgroove_optimize_mode orelse .ReleaseFast,
-        .target = target,
-    });
-
     b.installDirectory(.{
         .source_dir = .{ .path = "public" },
         .install_dir = .lib,
@@ -31,7 +21,22 @@ pub fn build(b: *std.Build) void {
         .use_llvm = use_llvm,
         .use_lld = use_llvm,
     });
-    server.linkLibrary(groove_dep.artifact("groove"));
+
+    if (b.systemIntegrationOption("groove", .{})) {
+        server.linkSystemLibrary("groove");
+    } else {
+        const libgroove_optimize_mode = b.option(
+            std.builtin.OptimizeMode,
+            "libgroove-optimize",
+            "override optimization mode of libgroove and its dependencies",
+        );
+        const groove_dep = b.dependency("groove", .{
+            .optimize = libgroove_optimize_mode orelse .ReleaseFast,
+            .target = target,
+        });
+        server.linkLibrary(groove_dep.artifact("groove"));
+    }
+
     b.installArtifact(server);
 
     const run_cmd = b.addRunArtifact(server);

With this diff plus some comparable modifications in the task’s dependence tree …

System Integration Help Section §

There is a brand-new --help area:

System Integration Options:
  --system [dir]               System Package Mode. Disable fetching; prefer system libs
  -fsys=[name]                 Enable a system integration
  -fno-sys=[name]              Disable a system integration
  --host-target [triple]       Use the provided target as the host
  --host-cpu [cpu]             Use the provided CPU as the host
  --host-dynamic-linker [path] Use the provided dynamic linker as the host

  Available System Integrations:                Enabled:
    groove                                      no
    z                                           no
    mp3lame                                     no
    vorbis                                      no
    ogg                                         no

Utilizing the System Integration Options §

[nix-shell:~/dev/groovebasin]$ zig build -fsys=z

[nix-shell:~/dev/groovebasin]$ ldd zig-out/bin/groovebasin
    linux-vdso.so.1 (0x00007fff054c7000)
    libz.so.1 => /nix/store/8mw6ssjspf8k1ija88cfldmxlbarl1bb-zlib-1.2.13/lib/libz.so.1 (0x00007fe164675000)
    libm.so.6 => /nix/store/whypqfa83z4bsn43n4byvmw80n4mg3r8-glibc-2.37-45/lib/libm.so.6 (0x00007fe164595000)
    libc.so.6 => /nix/store/whypqfa83z4bsn43n4byvmw80n4mg3r8-glibc-2.37-45/lib/libc.so.6 (0x00007fe1643ae000)
    /nix/store/whypqfa83z4bsn43n4byvmw80n4mg3r8-glibc-2.37-45/lib64/ld-linux-x86-64.so.2 (0x00007fe164696000)

Now, re-run the command however eliminating -fsys=z:

[nix-shell:~/dev/groovebasin]$ ~/Downloads/zig/build-release/stage4/bin/zig build

[nix-shell:~/dev/groovebasin]$ ldd zig-out/bin/groovebasin
    linux-vdso.so.1 (0x00007ffcc23f6000)
    libm.so.6 => /nix/store/whypqfa83z4bsn43n4byvmw80n4mg3r8-glibc-2.37-45/lib/libm.so.6 (0x00007f525feea000)
    libc.so.6 => /nix/store/whypqfa83z4bsn43n4byvmw80n4mg3r8-glibc-2.37-45/lib/libc.so.6 (0x00007f525fd03000)
    /nix/store/whypqfa83z4bsn43n4byvmw80n4mg3r8-glibc-2.37-45/lib64/ld-linux-x86-64.so.2 (0x00007f525ffcc000)

New Release Option §

System bundle maintainers can supply the brand-new --release choice in order to set a system-wide choice for optimization mode, while appreciating the application designer’s option.

  --release[=mode]             Request release mode, optionally specifying a
                               preferred optimization mode: fast, safe, small

andy@ark ~/d/a/zlib (main)> zig build --release
the project does not declare a preferred optimization mode. choose: --release=fast, --release=safe, or --release=small
error: the following build command failed with exit code 1:
/home/andy/dev/ayb/zlib/zig-cache/o/6f46a03cb0f5f70d2c891f31086fecc9/build /home/andy/Downloads/zig/build-release/stage3/bin/zig /home/andy/dev/ayb/zlib /home/andy/dev/ayb/zlib/zig-cache /home/andy/.cache/zig --seed 0x3e999c60 --release
andy@ark ~/d/a/zlib (main) [1]> zig build --release=safe
andy@ark ~/d/a/zlib (main)> vim build.zig
andy@ark ~/d/a/zlib (main)> git diff
diff --git a/build.zig b/build.zig
index 76bbb01..1bc13e6 100644
--- a/build.zig
+++ b/build.zig
@@ -5,7 +5,9 @@ pub fn build(b: *std.Build) void {
     const lib = b.addStaticLibrary(.{
         .name = "z",
         .target = b.standardTargetOptions(.{}),
-        .optimize = b.standardOptimizeOption(.{}),
+        .optimize = b.standardOptimizeOption(.{
+            .preferred_optimize_mode = .ReleaseFast,
+        }),
     });
     lib.linkLibC();
     lib.addCSourceFiles(.{
andy@ark ~/d/a/zlib (main)> zig build --release
andy@ark ~/d/a/zlib (main)> zig build --release=small
andy@ark ~/d/a/zlib (main)>

This choice might be set even if the task’s develop script does not clearly expose an optimization setup alternative.

Prevent Fetching in System Mode §

--system avoids Zig from bring bundles. Rather, a directory site of bundles is supplied, inhabited probably by the system bundle supervisor.

[nix-shell:~/dev/2Pew]$ zig build --system ~/tmp/p -fno-sys=SDL2
error: lazy dependency package not found: /home/andy/tmp/p/1220c5360c9c71c215baa41b46ec18d0711059b48416a2b1cf96c7c2d87b2e8e4cf6
info: remote package fetching disabled due to --system mode
info: dependencies might be avoidable depending on build configuration

[nix-shell:~/dev/2Pew]$ zig build --system ~/tmp/p

[nix-shell:~/dev/2Pew]$ mv ~/.cache/zig/p/1220c5360c9c71c215baa41b46ec18d0711059b48416a2b1cf96c7c2d87b2e8e4cf6 ~/tmp/p

[nix-shell:~/dev/2Pew]$ zig build --system ~/tmp/p -fno-sys=SDL2
steps [5/8] zig build-lib SDL2 ReleaseFast native... Compile C Objects [75/128] e_atan2... ^C

[nix-shell:~/dev/2Pew]$

Lazy Dependencies §

--- a/build.zig
+++ b/build.zig
-    const groove_dep = b.dependency("groove", .{
-        .optimize = libgroove_optimize_mode orelse .ReleaseFast,
-        .target = target,
-    });
+    if (b.lazyDependency("groove", .{
+        .optimize = libgroove_optimize_mode orelse .ReleaseFast,
+        .target = target,
+    })) |groove_dep| {
+        server.linkLibrary(groove_dep.artifact("groove"));
+    }

--- a/build.zig.zon
+++ b/build.zig.zon
@@ -5,6 +5,7 @@
         .groove = .{
             .url = "https://github.com/andrewrk/libgroove/archive/66745eae734e986cd478e7220664f2de902d10a1.tar.gz",
             .hash = "1220285f0f6b2be336519a0e612a11617c655f78b0efe1cac12fc73fc1e50c7b3e14",
+            .lazy = true,
         },
     },
     .paths = .{
    

This makes the dependence just get brought if it is in fact utilized. The develop runner will be reconstructed if any missing out on lazy reliances are come across.

There is a mistake for utilizing dependency() rather of lazyDependency():

$ zig build -h
thread 2904684 panic: dependency 'groove' is marked as lazy in build.zig.zon which means it must use the lazyDependency function instead
/home/andy/Downloads/zig/lib/std/debug.zig:434:22: 0x11901a9 in panicExtra__anon_18741 (build)
    std.builtin.panic(msg, trace, ret_addr);
                     ^
/home/andy/Downloads/zig/lib/std/debug.zig:409:15: 0x1167399 in panic__anon_18199 (build)
    panicExtra(null, null, format, args);
              ^
/home/andy/Downloads/zig/lib/std/Build.zig:1861:32: 0x1136dca in dependency__anon_16705 (build)
                std.debug.panic("dependency '{s}{s}' is marked as lazy in build.zig.zon which means it must use the lazyDependency function instead", .{ b.dep_prefix, name });
                               ^
/home/andy/dev/groovebasin/build.zig:33:40: 0x10e8865 in build (build)
        const groove_dep = b.dependency("groove", .{
                                       ^
/home/andy/Downloads/zig/lib/std/Build.zig:1982:33: 0x10ca783 in runBuild__anon_8952 (build)
        .Void => build_zig.build(b),
                                ^
/home/andy/Downloads/zig/lib/build_runner.zig:310:29: 0x10c6708 in main (build)
        try builder.runBuild(root);
                            ^
/home/andy/Downloads/zig/lib/std/start.zig:585:37: 0x10af845 in posixCallMainAndExit (build)
            const result = root.main() catch |err| {
                                    ^
/home/andy/Downloads/zig/lib/std/start.zig:253:5: 0x10af331 in _start (build)
    asm volatile (switch (native_arch) {
    ^
???:?:?: 0x8 in ??? (???)
Unwind information for `???:0x8` was not available, trace may be incomplete

error: the following build command crashed:
/home/andy/dev/groovebasin/zig-cache/o/20af710f8e0e96a0ccc68c47688b2d0d/build /home/andy/Downloads/zig/build-release/stage3/bin/zig /home/andy/dev/groovebasin /home/andy/dev/groovebasin/zig-cache /home/andy/.cache/zig --seed 0x513e8ce9 -Z4472a09906216280 -h

It’s permitted to do the reverse – lazyDependency() when the manifest file does not mark it as lazy.

It’s most likely finest practice to constantly utilize lazyDependency() in build.zig.

present b.path; deprecate LazyPath.relative §

This includes the *std.Build owner to LazyPath so that lazy courses returned from a reliance can be utilized in the application’s construct script without friction or footguns.

Migration guide:

Source-Relative LazyPath:

.root_source_file = .{ .path = "src/main.zig" },

↓

.root_source_file = b.path("src/main.zig"),

LazyPath.relative

.root_source_file = LazyPath.relative("src/main.zig"),

↓

.root_source_file = b.path("src/main.zig"),

Test Runner

.test_runner = "path/to/test_runner.zig",

↓

.test_runner = b.path("path/to/test_runner.zig"),

The intent for Compile.installHeader and buddies has actually constantly been to bundle the headers along with an artifact, have them be set up together with the artifact and get immediately contributed to the consist of search courses of modules that relate to the artifact.

In Zig 0.11.0, nevertheless, these functions customized the default
install high-level action of the contractor, result in a variety of unforeseen outcomes such as setting up or not setting up the headers depending upon which high-level construct actions are conjured up.

Zig 0.12.0 modifications it so that set up headers are contributed to the assemble action itself rather of customizing the high-level set up action. To deal with the building and construction of the consist of search course for reliant connecting modules, an intermediary WriteFile action accountable for building the suitable consist of tree is produced and established the very first time a module links to an artifact.

Migration guide:

installHeader now takes a LazyPath:

for (headers) |h| lib.installHeader(h, h);

↓

for (headers) |h| lib.installHeader(b.path(h), h);

Compile.installConfigHeader has actually had its 2nd argument eliminated and now utilizes the worth of include_path as its sub course, for parity with
Module.addConfigHeaderUsage
artifact.installHeader(config_h.getOutput(), "foo.h")
if you wish to set the sub course to something various.

lib.installConfigHeader(avconfig_h, .{});

↓

lib.installConfigHeader(avconfig_h);

Compile.installHeadersDirectory/installHeadersDirectoryOptions
have actually been combined into Compile.installHeadersDirectorywhich takes a
LazyPath and permits exclude/include filters similar to InstallDir

lib.installHeadersDirectoryOptions(.{
        .source_dir = upstream.path(""),
        .install_dir = .header,
        .install_subdir = "",
        .include_extensions = &.{
            "zconf.h",
            "zlib.h",
        },
    });

↓

lib.installHeadersDirectory(upstream.path(""), "", .{
        .include_extensions = &.{
            "zconf.h",
            "zlib.h",
        },
    });

• [Breaking] b.addInstallHeaderFile now takes a LazyPath
• [Breaking] As a workaround for
  reanimate emit-h the created
  -femit-h header is now never ever released even when the user defines an override for h_dir. If you definitely require the released header, you now require to do install_artifact.emitted_h = artifact.getEmittedH() up until
  -femit-h is repaired.
• Included WriteFile.addCopyDirectorywhich operates extremely comparable to InstallDir.
• InstallArtifact has actually been upgraded to set up the bundled headers alongide the artifact. The bundled headers are set up to the directory site defined by h_dir (which is zig-out/include by default).

dependencyFromBuildZig §

Provided a struct that represents the build.zig of a dependence, b.dependencyFromBuildZig returns that very same reliance. To put it simply, if you have currently a @imported a depdency’s build.zig, you can utilize this function to get the matching Dependency:

// in consumer build.zig
const foo_dep = b.dependencyFromBuildZig(@import("foo"), .{});

This function is likewise crucial for bundles that expose functions from their build.zig submits that requirement to utilize their matching Dependency (for instance, for package-relative courses, or for running system commands and returning the output as lazy courses). This would be achieved through:

// in dependency build.zig
pub fn getImportantFile(b: *std.Build) std.Build.LazyPath {
    const this_dep = b.dependencyFromBuildZig(@This(), .{});
    return this_dep.path("file.txt");
}

// in consumer build.zig
const file = @import("foo").getImportantFile(b);

Compiler §

x86 Backend §

The x86 backend is now passing 1765/1828 (97%) of the habits test suite, compared to the LLVM backend. It is far enough along that it is often beneficial while establishing, generally due to the reality that it uses considerably much faster collection speed:

Benchmark 1 (8 runs): zig-0.12.0 build-exe hello.zig
  measurement          mean ± σ            min … max           outliers         delta
  wall_time           667ms ± 26.7ms     643ms …  729ms          1 (13%)        0%
  peak_rss            175MB ± 19.3MB     168MB …  223MB          1 (13%)        0%
  cpu_cycles         3.42G  ±  532M     3.21G  … 4.74G           1 (13%)        0%
  instructions       6.20G  ± 1.05G     5.83G  … 8.79G           1 (13%)        0%
  cache_references    241M  ± 19.9M      234M  …  291M           1 (13%)        0%
  cache_misses       48.3M  ± 1.26M     47.7M  … 51.4M           1 (13%)        0%
  branch_misses      35.3M  ± 4.07M     33.7M  … 45.4M           1 (13%)        0%
Benchmark 2 (26 runs): zig-0.12.0 build-exe hello.zig -fno-llvm -fno-lld
  measurement          mean ± σ            min … max           outliers         delta
  wall_time           196ms ± 5.77ms     187ms …  208ms          0 ( 0%)        ⚡- 70.6% ±  1.7%
  peak_rss           88.7MB ±  721KB    87.8MB … 90.4MB          2 ( 8%)        ⚡- 49.3% ±  4.3%
  cpu_cycles          842M  ± 6.01M      836M  …  866M           1 ( 4%)        ⚡- 75.4% ±  6.0%
  instructions       1.60G  ± 9.62K     1.60G  … 1.60G           0 ( 0%)        ⚡- 74.1% ±  6.5%
  cache_references   56.6M  ±  378K     56.0M  … 57.3M           0 ( 0%)        ⚡- 76.6% ±  3.2%
  cache_misses       8.43M  ±  104K     8.30M  … 8.79M           2 ( 8%)        ⚡- 82.5% ±  1.0%
  branch_misses      7.20M  ± 30.2K     7.15M  … 7.28M           2 ( 8%)        ⚡- 79.6% ±  4.4%

This backend can be accessed when putting together for an x86_64 target by passing the CLI alternatives
-fno-llvm -fno-lldor by setting the construct system flags use_llvm and use_lld on
std.Build.Step.Compile to falseThis backend is now able to put together numerous Zig tasks, consisting of the compiler itself.

Staying jobs up until it can be picked by default rather of LLVM for debug develops:

• 100% habits tests passing
• Enhanced debug details
• Better runtime efficiency

Windows Resources §

Zig now supports putting together (and cross-compiling) Windows resource scripts (.rc files) and .manifest files, and connecting the resulting .res files into the resource table of PE/COFF binaries.

• Include a.rc ->>. res compiler to the Zig compiler
• Include zig rc subcommand, a (cross-platform) drop-in replacement for rc.exe
• Include initial assistance for Windows.manifest files

See Zig is now likewise a Windows resource compiler for some use-cases of this function and information of how to utilize it.

Linker §

Zig now supports ELF connecting for x86_64, aarch64, and partial assistance for riscv64.

Reliance on LLD is anticipated to be dropped throughout the next release cycle.

The -fno-lld flag can be utilized to utilize Zig’s linker where it is not presently the default.

Cache System §

This rather bothersome bug is repaired now: mistake: StreamTooLong when recompiling; replicate source files in cache manifest

The repair, which deduplicates files noted in the cache manifest, makes cache hits considerably quicker. Information point: cache struck structure hey there world with fixed musl libc

Benchmark 1 (61 runs): master/zig build-exe hello.c -target native-native-musl -lc
  measurement          mean ± σ            min … max           outliers         delta
  wall_time          81.4ms ± 1.76ms    77.7ms … 87.1ms          1 ( 2%)        0%
  peak_rss           64.6MB ± 77.7KB    64.4MB … 64.7MB          0 ( 0%)        0%
  cpu_cycles         97.2M  ± 1.04M     95.1M  …  101M           1 ( 2%)        0%
  instructions        153M  ± 11.1K      152M  …  153M           0 ( 0%)        0%
  cache_references   2.21M  ± 97.1K     2.05M  … 2.54M           2 ( 3%)        0%
  cache_misses        529K  ± 24.4K      486K  …  600K           4 ( 7%)        0%
  branch_misses       409K  ± 6.45K      397K  …  437K           1 ( 2%)        0%
Benchmark 2 (189 runs): cache-dedup/zig build-exe hello.c -target native-native-musl -lc
  measurement          mean ± σ            min … max           outliers         delta
  wall_time          25.8ms ± 1.26ms    23.9ms … 30.7ms         11 ( 6%)        ⚡- 68.4% ±  0.5%
  peak_rss           65.2MB ± 61.8KB    65.1MB … 65.4MB          2 ( 1%)        💩+  1.0% ±  0.0%
  cpu_cycles         41.2M  ±  608K     40.1M  … 46.3M           4 ( 2%)        ⚡- 57.6% ±  0.2%
  instructions       64.3M  ± 12.6K     64.3M  … 64.4M           2 ( 1%)        ⚡- 57.8% ±  0.0%
  cache_references   1.28M  ± 34.5K     1.21M  … 1.35M           0 ( 0%)        ⚡- 41.9% ±  0.7%
  cache_misses        348K  ± 18.6K      297K  …  396K           0 ( 0%)        ⚡- 34.2% ±  1.1%
  branch_misses       199K  ± 1.34K      197K  …  206K           6 ( 3%)        ⚡- 51.2% ±  0.2%

Bug Fixes §

Complete list of the 502 bug reports closed throughout this release cycle

Numerous bugs were both presented and solved within this release cycle. Many bug repairs are left out from these release notes for the sake of brevity.

Comptime Pointer Access §

Zig has actually had numerous enduring bugs associating with accessing guidelines at put together time. When trying to gain access to guidelines in a non-trivial method, such as packing a piece of a selection or reinterpreting memory, you would sometimes be welcomed with an incorrect favorable assemble mistake specifying that the comptime dereference needed a particular type to have a distinct design.

The combine of # 19630 solves this problem. In Zig 0.12.0, the compiler ought to no longer discharge inaccurate assemble mistakes when doing intricate things with comptime memory. This modification likewise consists of some repairs to the reasoning for comptime @bitCast; in specific, bitcasting aggregates consisting of guidelines no longer improperly requires the operation to happen at runtime.

This Release Contains Bugs §

Zig has
recognized bugs and even some
miscompilations

Zig is immature. Even with Zig 0.12.0, dealing with a non-trivial task utilizing Zig will likely need taking part in the advancement procedure.

When Zig reaches 1.0.0,
Tier 1 Support will acquire a bug policy as an extra requirement.

LLVM 17 §

This release of Zig upgrades to
LLVM 17.0.6

Zig now creates LLVM bitcode module files straight and after that passes those to LLVM. This indicates that a Zig compiler developed without LLVM libraries can still produce .bc files, which can then be passed to clang for collection.

musl 1.2.4 §

Musl v1.2.5 is now readily available upstream, this variation of Zig continues to supply v1.2.4. The next release of Zig is anticipated to have actually the upgraded musl.

glibc 2.38 §

glibc variations 2.35, 2.36, 2.37, and 2.38 are now offered when cross-compiling.

mingw-w64 §

Based upon a tip from Martin StorsjöZig now tracks the current master branch dedicate of mingw-w64.

Roadmap §

The significant style of the 0.13.0 release cycle will be collection speed

Some approaching turning points we will be working towards in the 0.13.0 release cycle:

• Making the x86 Backendthe default backend for debug mode.
• Linkerassistance for COFF. Remove dependence on LLD
• Allowing incremental collection for quick rebuilds.
• Present Concurrency to semantic analysis to additional boost collection speed.

The concept here is that focusing on much faster collection will increase advancement speed on the Compileritself, resulting in more bugs repaired and includes finished in the following release cycles.

It likewise might possibly cause language modifications that unclog quick collection.

Async/Await Feature Status §

Async functions fallen back with the release of 0.11.0 (the previous release to this one). Their future in the Zig language is uncertain due to numerous unsolved issues:

• LLVM’s absence of capability to enhance them.
• Third-party debuggers’ absence of capability to debug them. 19659855 The cancellation issue 19459302 19659856 Async function tips avoiding the stack size from being understood. 19659857 These issues are surmountable, however it will require time. The Zig group is presently concentrated on other concerns. Thank You Contributors! 19659859 § Ziggy the Ziguana” src=”https://ziglang.org/img/Ziggy_7.svg Here are all individuals who landed a minimum of one contribution into this release: Andrew Kelley 19659863 Jakub Konka Jacob Young 19659865 Matthew Lugg Robin Voetter 19659867 Igor Anić Ryan Liptak 19659869 Veikka Tuominen 19659870 antlilja 19659871 Carl Åstholm Luuk de Gram Michael Dusan Dominic 19659875 Krzysztof Wolicki 19659876 Casey Banner 19659877 Ali Chraghi Anonymous Ian Johnson 19659880 David Rubin 19659881 Meghan Denny 19659882 Marc Tiehuis Techatrix 19659884 Xavier Bouchoux 19659885 Bogdan Romanyuk Pat Tullmann 19659887 Frank Denis Tristan Ross 19659889 Loris Cro 19659890 Stephen Gregoratto 19659891 xdBronch 19659892 Evan Haas 19659893 John Schmidt 19659894 Ryan Zezeski expikr Elaine Gibson 19659897 MrDmitry e4m2 Adam Goertz Jan Philipp Hafer 19659901 Jay Petacat Jonathan Marler Travis Staloch Wooster XXIV 19659906 joadnacer Jae B 19659908 Kai Jellinghaus 19659909 Linus Groh frmdstryr 19659911 Garrett Beck Josh Wolfe Karl Seguin 19659914 Sahnvour 19659915 february cozzocrea 19659916 fn ⌃ ⌥ Carter Snook 19659918 Eric Joldasov Erik Arvstedt 19659920 Gordon Cassie 19659921 HydroH JustinWayland Lucas Santos Luis Cáceres 19659925 Motiejus Jakštys Nguyễn Gia Phong Paul Berg 19659928 Pavel Verigo 19659929 Piotr Szlachciak Prokop Randáček 19659931 Ratakor Stevie Hryciw 19659933 SuperAuguste Zachary Raineri 19659935 amp-59 19659936 garrisonhh 19659937 Alex Kladov Ben Crist 19659939 Eric Eastwood 19659940 Jan200101 Jari Vetoniemi 19659942 Jeremy Volkman Kang Seonghoon Manlio Perillo 19659945 Markus F.X.J. Oberhumer 19659946 Michael Ortmann Pascal S. de Kloe 19659948 Philipp Lühmann Ruben Dimas Sean 19659951 Tobias Simetsreiter 19659952 Tom Read Cutting 19659953 Tw Vlad Pănăzan cipharius 19659956 jimying nikneym 19659958 none ocrap7 19659960 riverbl 19659961 snoire 19659962 tjog xEgoist Abhinav Gupta 19659965 Adrià Arrufat Ahmed 19659967 Alex 19659968 Alexander Heinrich AlliedEnvy 19659970 Ambareesh “Amby” Balaji Amir Alawi Andre Herbst Andre Weissflog Andreas Herrmann 19659975 Anubhab Ghosh Arnau Artem Kolichenkov 19659978 Aven Bross 19659979 Banacial 19659980 Becker A 19659981 Ben Sinclair 19659982 Brandon Black Brandon Botsch CPestka Chadwain Holness Chris Boesch Chris Burgess 19659988 Christian Flicker Christiano Haesbaert Christofer Nolander Constantin Bilz Constantin Pestka 19659993 Craig O’Connor 19659994 Curtis Tate Wilkinson Daniel A.C. Martin 19659996 Daniel Guzman David Gonzalez Martin DilithiumNitrate 19659999 Dillen Meijboom 19660000 DraagrenKirneh Emil Lerch Emil Tywoniak F3real 19660004 Federico Stra Felix Kollmann Gregory Anders Gregory Mullen Guillaume Wenzek Gustavo C. Viegas Hashi364 19660011 Hong Shick Pak 19660012 Ian Kerins Igor Sadikov IntegratedQuantum 19660015 Jacob G-W 19660016 James Chen-Smith 19660017 Jan Weidner 19660018 Jeremia Dominguez Jiacai Liu 19660020 Jim Calabro Joachim Schmidt 19660022 Joel Gustafson Johan Jansson 19660024 John Benediktsson Jordyfel 19660026 Justus Klausecker Kamil T Karl Böhlmark 19660029 Khang Nguyen Duy 19660030 Kirk Scheibelhut 19660031 Koakuma 19660032 Lateef Jackson Lauri Tirkkonen 19660034 Lee Cannon 19660035 Leo Emar-Kar 19660036 Leonardo Gatti 19660037 Lewis Gaul LinuxUserGD 19660039 Littleote Liviu Dudau LordMZTE 19660042 Luca Ivaldi Lucas Culverhouse 19660044 Maciej ‘vesim’ Kuliński Marcius Mason Remaley Matt Knight 19660048 Matthew Wozniak 19660049 Maximilian 19660050 Michael Bradshaw Michael Lynch 19660052 Michael Pfaff 19660053 Michael Scott 19660054 Michal Ziulek 19660055 Mikko Kaihlavirta Minsoo Choo 19660057 Mustafa Uzun Naboris 19660059 Nan Zhong Niles Salter Nitin Prakash 19660062 Okay Ryoko 19660063 PanSashko Paul Jimenez PauloCampana 19660066 Peng He 19660067 Phil Richards 19660068 Prcuvu Purrie Pyry Kovanen Qusai Hroub Rafael Fernández López Rahul Prabhu Reokodoku Robinson Collado 19660076 Roman Frołow 19660077 Ryan Barth 19660078 Samuel Fiedler 19660079 Samuel Nevarez 19660080 Scott Schwarz 19660081 Sebastien Marie Simon Brown Stefan Su Stephen Gutekanst 19660085 Tim Culverhouse Tobias Simetsreiter Tomasz Lisowski 19660088 Vitalijus Valantiejus Winter season andrewkraevskii arbrk1 bfredl binarycraft007 castholm cdrmack 19660096 cfillion crayon cryptocode 19660099 danielsan901998 davideger dbandstra 19660102 dhash dundargoc 19660104 emberfade hdert iwVerve 19660107 jacwil jaina heartles jd 19660110 leap123 19660111 lockbox loris mataha melonedo 19660115 mllken 19660116 ndbn 19660117 notcancername 19660118 pancelor 19660119 paoda radar roark regeliv 19660122 salo-dea sammy j tinusgraglin 19660125 tison 19660126 vinnichase yunsh1 zhylmzr Андрей Краевский Ziggy the Ziguana” src=”https://ziglang.org/img/Ziggy_6.svg 19660131 Unique thanks to those who 19459305 sponsor Zig 19459302 Due to the fact that of repeating contributions, Zig is driven by the open source neighborhood, instead of the objective of making earnings. In specific, these great folks sponsor Zig for $50/month or more: 19660132 Josh Wolfe 19660133 Matt Knight 19660134 Stevie Hryciw 19660135 Jethro Nederhof Karrick McDermott 19660137 José M Rico drfuchs Joran Dirk Greef Rui Ueyama 19660141 bfredl Simon A. Nielsen Knights Stephen Gutekanst 19660144 Derek Collison 19660145 Daniele Cocca 19660146 Rafael Batiati Aras Pranckevičius Terin Stock Loïc Tosser 19660150 Kirk Scheibelhut Mitchell Hashimoto Brian Gold 19660153 Paul Harrington Clark Gaebel Bun Marcus Eagan Ken Chilton 19660158 Sebastian Will Manning Fulcrum Labs 19660161 Alex Mackenzie at Tapestry VC Alok Parlikar Viktor Tratsevskyy 19660164 johnpyp Huly ® Platform ™ Reuben Dunnington 19660167 Isaac Yonemoto Luuk de Gram Auguste Rame Jay Petacat Dirk de Visser Santiago Andaluz 19660173 Andrew Mangogna 19660174 Yaroslav Zhavoronkov Christian Wesselhoeft 19660176 Anton Kochkov Max Bernstein James McGill Luke Champine AG.王爱国 Wojtek Mach Nicola Larosa 19660183 Daniel Hensley 19660184 cryptocode Erik Mållberg 19660186 Collin Kemper 19660187 Fabio Arnold Tom Read Cutting 19660189 Ross Rheingans-Yoo 19660190 Emily A. Bellows Justin “J.R.” Hill Mykhailo Tsiuptsiun Kiril Mihaylov Brett Slatkin 19660195 Sean Carey Yurii Rashkovskii 19660197 Benjamin Ebby 19660198 Ralph Brorsen 19660199 OM PropTech GmbH 19660200 Alex Sergeev Pierre Curto 19660202 Kemal Akkoyun 19660203 Marco Munizaga Josh Ashby 19660205 Chris Baldwin 19660206 Malcolm Still Viktor Hellström 19660208 Francis Bouvier 19660209 Fawzi Mohamed 19660210 Alve Larsson Nicolas Goy Ian Johnson Carlos Pizano Uribe 19660214 Rene Schallner Linus Groh Jinkyu Yi jake hemmerle 19660218 Will Pragnell Nathan Youngman Peter Snelgrove 19660221 Jeff Fowler Nate Samu foxnne Christian Gibson 11sync. net impactaky Dylan Conway 19660229 Hlib Kanunnikov merkleplant 19660231 Omar AlSuwaidi Find out more