Zig breaking change – initial Writergate

Zig has a pretty well documented 1.0 goals. It was the first thing I heard about zig from Andrew about. https://youtu.be/5eL_LcxwwHg

advances the purposes of cynics as well, so big bonus.

In the C and C++ languages there's a thing called a "freestanding" implementation. This is roughly analogous to Rust's nostd.

In C the freestanding environment doesn't provide any concrete features, you don't get any functions at all, you can get a bunch of useful constants such as the value of Pi or the maximum value that will fit in an unsigned integer, some typedefs, that's about it. Concrete stuff from the "C standard library" is not available, for example it does not provide any sort of in-place sort algorithm, or a way to compare whether two things are the same (if they fit in a primitive you can use the equality operator)

In C++ there are concrete functions provided by the language standard in freestanding mode. These, together with definitions for types etc. form the freestanding version of the "standard library" in C++. There's a long period where this was basically untended, it wasn't removed but it also wasn't tracking new features or feedback. In the last few C++ versions that improved, but even if you have a new enough compiler and it's fully compliant (most are not) there's still not always a rhyme or reason to what is or is not available.

In Rust it's really easy. You always have core, if you've got a heap allocator of some sort you can have alloc, and if there's a whole operating system it provides std.

In most cases a whole type lives entirely in one of those modules, Duration for example lives in core. Maybe your $5 device has no idea which year this is, let alone day but it does definitely know 60 seconds is a minute.

But in some cases modules extend a type. For example arrays exist in core of course - an array of sixty Doodads where Doodads claim to be Totally Ordered, can just be unstably sorted, that works. But, what if we want a stable sort, so that if two equal Doodads were arranged A, B they are not reversed B, A ? Well Rust's core module doesn't provide a stable sort, the stable sort provided uses an allocation and so the entire function you need just doesn't exist unless you've got allocators.

That's the most frustrating part, a lot of the std library would work on a bare metal system (and would be rather useful), but getting those parts into your project and avoiding the ones that will give you compiler errors in form of esoteric poems is a nightmare.

Vendors at this point seem to give their implementation of some of the std library components, but the one's I've seen were lacking in terms of features.

Yeah you don't get its std library, but Rust makes a distinction between core and std, and core is available. Doesn't sound like a lot but you get your standard types like Result and Option, you get slices since they're part of the language or if you need allocation you can define the global allocator in core::alloc.

This distinction makes it really comfortable to use.

Though one caveat about no_std is that you'll need some support library like https://docs.rs/cortex-m-rt/latest/cortex_m_rt/

Is that versioning site supposed to be some kind of joke? I can't really figure out if they are joking or serious - the tone comes off as joking, but it could be read as serious too.

I've built a bridge 20 years ago. It was great, people could finally go from one side of the river to the other.

Everyday, more and more people started using that bridge.

In 2025, I've rebuilt the bridge twice as big to accommodate the demand of a growing community.

It's great and the people love it!

A less experienced Andrew

Indeed, but to be fair, the old stack was done with a hand, not a foot!

I think what you're not appreciating is how this design is a huge improvement over the status quo, not only in Zig, but also the streaming interfaces in most languages.

Wait till the SD25 talk on this comes out, to first understand the rationale a bit better!

Depends on which language you're coming from. Compared to C or even C++, the Zig stdlib has already many more things to offer. Compared to Python it's quite bare bones (but then, everything is).

Thanks zwnow, appreciate your kind words, and my pleasure!

I think you'll enjoy Andrew's talk on this too when it comes out in the next few weeks.

The velocity of Zig has been valuable for us. Being able to put things like io_uring or @prefetch in the std lib or language, and having them merged quickly. Zig has been so solid, even with all the fuzzing we do. It's really held up, and upgrades across versions have not been much work, only a pleasure.

Some prod are more prod than the others.

> A lot of people were using tokio in prod when it was 0.1 and didn’t get upset afaik.

Citation needed. A lot of people wanted Rust to stabilize. Hence why they huried to Rust 1.0.

Not having breaking changes every N months?

It's not about sticking around on an old version, it's about ever being able to catch up, and what the rest of the ecosystem is going to do. Python did this major version bump that broke a lot of the ecosystem, and it went so poorly that they've effectively promised never to do it again and completely excised any thought of ever having a major version bump again, and other languages and communities now point to it regularly as a debacle to be avoided.

When you break things regularly, you're forcing a choice on every individual package in the ecosystem: move forward, and leave the old users behind, or stay behind, and risk that the rest of the ecosystem moves forward without you. Now you've got a whole ecosystem in a prisoner's dilemma. For an individual, maybe you can make a choice and dig in and make your way along without too much trouble. But the ecosystem as a whole can't, the ecosystem fractures, and if it doesn't converge on the latest version, it slowly withers and dies.

My understanding is that the current plans are to implement async in userspace, as part of a broader IO overhaul.

This would involve removing async/await as keywords from the language.

As far as I know, Zig still wants their implementation of async to avoid function colouring.

Much of the discussion is buried in the various GitHub issues related to async. I found something of a summary in this Reddit comment

https://www.reddit.com/r/Zig/comments/1d66gtp/comment/l6umbt...

Thank you, my bad - I wasn't aware.

I still think what drives languages to continuously make changes is the focus on developer UX, or at least the intent to make it better. So, PLs with more developers will always keep evolving.

This feels out of touch with the actual industry today.

It hardly brings anything new to the table in such cases, given its approach to safety.

Most of it you can already get in C and C++, by using the tools that have in the market for the last 30 years.

I think that's long been the argument of simplicity. 'Simple to remember' vs 'simple to perform.'

I tend to fall into the former camp. Something like BF would be the ultimate simple language, even if not particularly useful.

GamerGate is well worth understanding. While some of the details are unique to the situation, it’s provided a template for right-wing radicalisation that’s been employed multiple times since. There’s also an entertaining “where are they now” aspect where some people have been almost forgotten and some are in the White House. KotakoInAction is still going and has (inevitably) morphed into a bunch of people complaining about the Lūgenpresse.

Then those developers won't ever use anything ever. Why would breaking changes in an explicitly unstable development version exclude it from use for all time?

If you want stability, stick to stuff that has stability guarantees, but at the very least let them make breaking changes during development.