only for hobby project

TigerBeetle, Bun, and Ghostty all beg to differ...

Bun is 100% fine in production. And you should be using it instead of transpiling TypeScript unless there’s some other barrier to using it.

I am not trying to dunk on this project

all of these project is great but we cant ignore that Zig is not enter phase where we can guarantee stable API compability

Nobody is denying that? Andrew Kelly and the Zig team have been extremely clear that they are okay making break changes. So if you're choosing to use it in large projects, as some have, you're taking that risk.

I think it speaks volumes that these projects chose to use it, and speak very highly of it, despite the fact that it's still pre 1.0.

"Nobody is denying that?"

seems like you missing a lot of comment on this tree

Care to point out a few?

You or in general? Because, you know, this is like, your opinion, man.

My Opinion???

how about you goes to Zig github and check how progress of the language

it literally there and its still beta test and not fit for production let alone have mature ecosystem

Yes, your opinion. I run it in production and everything I've built with it has been rock solid (aside from my own bugs). I haven't touched a few of my projects in a few years and they work fine, but if I wanted to update them to the latest version of Zig I'd have a bit of work ahead of me. That's it.

Can you rage bait somewhere else?

since when stating fact is rage bait????

following upstream is overrated since we have good package managers and version control.

it's completely feasible to stick to something that works for you, and only update/port/rewrite when it makes sense.

what matters is the overall cost.

Hmm, if one writes a library Zetalib for the language Frob v0.14 and then Frob v0.15 introduces breaking changes that everyone else is going to adapt to, then well, package managers and version control is going to help indeed - they will help in staying in a void as no one will use Zetalib anymore because of the older Frob.

For libs, yes, for applications dev, no.

I would expect fixing an application to an older version would be just fine, so long as you don't need newer language features. If newer language features are a requirement, I would expect that would drive refactoring or selecting a different implementation language entirely if refactoring would prove to be too onerous.