clr

That’s not entirely true. There’s a third choice. You can go the TigerBeetle route (TigerStyle). Zig is extremely well suited for software where you just avoid dynamic memory allocation all together. It’s extremely fast, very effective and arguably very safe. But not suitable for all applications obviously. There’s also another caveat that there’s an effort to build in build time static memory safety checks in a way that’s more general than Rusts borrow checker, through a kind of plug in system rather than forced into the language. It’s not part of mainline Zig yet but this seems to be the direction Andrew wants to go. https://github.com/ityonemo/clr

This is getting really close to 1.0 now? I guess may be 2 more release and 1 more RC? That is 2028. I am looking forward to stabilising the language and the core team has previously indicated that exporting ir will be a supported feature. Once that is done, @dnautics is working on memory safety for zig [1]. A Checker for Lifetimes and other Refinement types. Then we can start the Rust vs Zig Debate again. Hopefully not too late. [1] https://github.com/ityonemo/clr/

Maybe the authors just don't want to do it? Anyways: its possible, I am building it as a very side project. github.com/ityonemo/clr

You can very likely borrow check in languages that don't have it in the type system. Exactly the way you suggest, as an optional add-in. It's still WIP but in my side project I haven't found cases that can't be handled yet. https://github.com/ityonemo/clr

(wip) https://github.com/ityonemo/clr

it seems like a reasonable enterprise to intercept the data dependency graph from the zig compiler and subject it to analysis to prove memory safety parameters: (my wip experiment: ) https://github.com/ityonemo/clr

It's possible to detect and ban the version of the problematic pattern that I made as short and simple as possible to illustrate the point, sure. I'm general though, I don't believe it is practical to do so. Not without every library being designed with the checker in mind and annotated to more precisely describe their APIs. Which is why I'm not surprised to see the limitations.md that seems to exclude all the hard cases (aliasing, pointers used as first class values, cross function analysis): https://github.com/ityonemo/clr/blob/main/LIMITATIONS.md#mem... Obviously if you rewrite the zig world to obey rust like rules and include rust like annotations you can implement a rust like borrow checker, but I don't think that it would still be meaningfully zig. It might be an interesting language worth exploring.

so yes it is possible to detect those patterns and ban them as unsafe, and have a"safety checked alternative. clr does this currently: https://github.com/ityonemo/clr#safety-oriented-architecture

> if only somehow we could get Rust's safety with all of Zig's features i periodically throw my unused codex tokens at this: https://github.com/ityonemo/clr

> A true competitor would need to offer genuine extra value, such as dependent types or other formal verification features, to carve out a niche. believe it or not it is generally easy to do this with zig with few modifications (WIP), and the team has said publically that they will be making this sort of thing a supported operation once the IR stabilizes post-1.0. https://github.com/ityonemo/clr/

> Everything you do in Zig can be done almost in the same way in C or C++. Can you do this in C? https://github.com/ityonemo/clr

> before Zig gets properly established. zig is reasonably established. the llms write pretty good zig. see project linked below which is almost entirely llm-written > And it is going to be very hard to justify choosing Zig for your sloppy-but-functional AI-written code why? because one project that was shipping fast made a dog's breakfast of it? > why open yourself up to memory unsafety on top of everything else? this can be addressed by third parties in the reasonable near-term. for example: https://github.com/ityonemo/clr the zig team says that in the future stabilizing the IR and providing an API will happen. fwiw in the process of building this project the llms have never once written a memory safety error in the "lib" section (in the src section there was a lot of tripping over segfaults since memory mapping datatypes accessed by

no. red green tdd is great because you'll have tests when your llm breaks something later, or you're doing a massive refactor. i imagine studies are not done on codebases where the complexity gets that high. tdd has been invaluable for this project (almost entirely llm written, but i review it) https://github.com/ityonemo/clr