18 ms·
Maintain It with Zig
- sandwichbop 5y agoInteresting read and I agree that growth in technical debt is something to worry about. I want to get more involved and been trying my best to learn the skills needed but there’s so much to consider that it’s a bit overwhelming. I’m not familiar with Zig, it’s neat that it has a toolchain that can compile C/C++ but it reminds me a lot of Nim. Could someone explain to me some differences between the two and why you would pick Zig over the other besides personal preference?
- cassepipe 5y agoI'd say Zig wants is really serious on wanting to be a better C, that is have the same (better?) access to bare-metal, memory and bits but with a better type system and error management and without C's footguns and cruft (build system, memory errors, preprocessor). I don't know Nim that well but it seems more ambitious and seems to cater to be more "general purpose" if that means anything. For example there's no hidden flow control in Zig.
- habibur 5y agoNim is garbage collected, thus is a higher level language but doesn't fit the high performance low overhead of "systems programming" requirement. While Zig is manual memory managed like C and nearer to the core, but harder to program.
- sa1 5y agoWith ARC, Nim's memory management would be closer to Rust than to Go.
- michaelsbradley 5y agoI think the maintainers of Nim would disagree with your assessment given that the first sentence on the front page of Nim's official website is: "Nim is a statically typed compiled systems programming language." As someone else pointed out, when using Nim with its ARC/ORC and move semantics (which will eventually be the default), it's closer to Rust than to Go. That being said, Nim's current default GC does well for many kinds of workloads. If it's really causing a performance problem, it's possible to disable it and manage memory manually (or use a different language for the task at hand, of course).
- goodpoint 5y agoNot at all: Nim always targeted system programming. Even before the new ARC/ORC, the GC was optional and done independently in each thread.
- pjmlp 5y agohttps://people.inf.ethz.ch/wirth/ProjectOberon/Sources/Kernel.Mod.txt https://people.inf.ethz.ch/wirth/ProjectOberon/Sources/Kerne... https://tinygo.org/ https://tinygo.org/ https://www.ptc.com/en/products/developer-tools/perc https://www.ptc.com/en/products/developer-tools/perc
- nimmer 5y agoNim targets all the architectures that GCC targets, including less common microcontrollers.
- rattray 5y agoInteresting; this piece advocates for porting only (or at least initially) the build system of C/C++ projects to use the Zig compiler and the build.zig build system for cross-compiling dependencies. A package manager in the works could be interesting too. I don't do C/C++ development. How many headaches would using Zigs compiler & build system solve?
- mishafb 5y agoZig has painless cross compilation, with gcc or clang it's a nightmare
- pjmlp 5y agoI would like to see that painless cross compilation for UWP applications. Truth is that cross compilation always breaks down in complex deployment use cases.
- int_19h 5y agoIn principle, why wouldn't it work for C++/WinRT, given that it doesn't use the WinMD metadata directly, but rather produces valid C++ headers from it? I think the problem for Zig is that they use MinGW as their Windows target, and the latter's standard library isn't really UWP compatible (yet?).
- pjmlp 5y agoBecause the whole build process to produce a MSIX or APPX requires a little more, like the whole Windows SDK, plus whatever might be fetch via NuGET via MSBuild, and the process to sign the packages?
- int_19h 5y agoI would compare building MSIX or APPX to building an apt or rpm package on Linux - that's the next step after building the actual executables, which is what Zig covers.
- skywal_l 5y agoZig is a very interesting language. You are able to do thing that would require wizard level skills in C with simple plain language construct. Like serializing/deserializing an enum variants over the wire for example in the most efficient way (look at std.json.{parser, stringify} [0]). > soon we’ll also have a package manager This. If they succeed to do this (and I have my doubts) it will be a paradigm shift for low-level "system" programming. Let's hope this is not vaporware. Finally, it's relatively easy to contribute to Zig. Andrew Kelley is very opinionated on where the language should go with an emphasis on simplicity which sometimes can make things awkward but he is also persuasive and welcoming. I have been using Zig for a month and I am still positively surprised so he must be onto something. [0]: https://github.com/ziglang/zig/blob/master/lib/std/json.zig#L2273 https://github.com/ziglang/zig/blob/master/lib/std/json.zig#...
- void_mint 5y agoI've been paying attention to Zig posts on HN, mostly just because it seems well-liked and I think Andrew Kelley is interesting/smart. Would it be fair to say that Zig is to C, what Rust is to C++? Or are they both just kind of...low-ish-level systems languages solving similar problems, differently?
- tristan957 5y agoZig/Rust aim to fit in the same systems/general purpose space which can be viewed as alternatives to both C and C++.
- oconnor663 5y ago> Would it be fair to say that Zig is to C, what Rust is to C++? There's definitely something to that analogy, but I think it also misses a lot of really important details. For example, Zig has generics, which right off the bat makes it hard to say that it's "like C". Also Rust enforces memory safety, which isn't like C or C++.
- roblabla 5y agoI mean, C11 also has generics, but I would really suggest not using it X). See https://en.cppreference.com/w/c/language/generic https://en.cppreference.com/w/c/language/generic Of couse, it's a much less powerful feature, there's nothing like interfaces or stuff, just a way to "overload" based on the type.
- dnautics 5y agoZig is clearly leaning in hard to the E3 strategy! (embrace, extend, extinguish) for those not familiar
- deadwisdom 5y ago4x Explore, Expand, Exploit, Exterminate
- ynx0 5y agobased
- kristoff_it 5y agoNot sure why people are downvoting. We all have our hidden agendas, mine is the destruction of all macros.
- jeofken 5y agoWhat are compilers but advanced text macros?
- tialaramex 5y agoSurely if you ensure people can't write macros in your language they'll just wrap the entire language in a pre-processing layer to enable macros which seems obviously worse ?
- IggleSniggle 5y agoSomething something typescript
- dralley 5y agoI disagree for two reasons. The first is that if the traditional upstream stops caring about improvement, it's only reasonable for other parties to move on. And that's largely true with the C ecosystem, as it was with OpenOffice for example. Second, "extend" has traditionally meant "extend with proprietary code". Think early 2000s Microsoft with browser APIs and J++, or Amazon with their in-house forks of MongoDB, PostgresQL, etc. There's plenty of innocuous activity that could be called E3 if you stretch the definition that far. Most of the GNU ecosystem for example.
- fractalb 5y agoIf zig.build can alleviate the pain of building C/C++ projects, then it will surely to replace C in the future. So, IMHO, it's more important to get zig.build right than zig itself
- aninteger 5y agoAren't C projects relatively easy to build? C++ is a little more complicated, so there is more of a push for header only libraries there. I see the problem is probably with external libraries, but that is largely not a huge problem on Linux/Unix. Windows was more of a pain but msys/mingw alleviated most of it.
- woodrowbarlow 5y agonot really, unless you're only building for one platform. gnu make isn't portable and doesn't have any real dependency management, so meta build systems quickly become a necessity. cmake is the most portable and the only real option on windows, but it's common to see projects that maintain support for both cmake and autotools. and that's ignoring the nightmare of cross-compiling with gcc. andrew kelley has talked about this[1]. his main point was about the number of dependencies you end up with compared to zig, where the standard library includes a high-level build system api. so your zig build scripts are written in ziglang and run by the zig compiler. no extra dependencies. [1] https://youtu.be/Gv2I7qTux7g?t=2120 https://youtu.be/Gv2I7qTux7g?t=2120
- steveklabnik 5y agoAgreed for sure that working with C and C++ is the only way forward for systems languages. Rust's expression of this is the zero-cost C FFI, using native platform tooling, and stuff like that. Rust was never about re-writing the world, after all, its reason for existing was to eventually improve Firefox. The very first presentation about Rust (http://venge.net/graydon/talks/intro-talk-2.pdf http://venge.net/graydon/talks/intro-talk-2.pdf) says "We are not “rewriting the browser”. That's impossible. Put down the gun." Zig's cross compilation stuff and general compiler features, that this post talks about, is excellent, awesome, and makes me quite jealous frankly.
- underdeserver 5y agoI admire your use of special quotes to not break my mental parsing of your quote.
- steveklabnik 5y agoHilariously it was a copy/paste situation that I went "oh, that's kinda neat, I'll leave that" so I'm glad you noticed. (I am often guilty of nesting thoughts (inside of other thoughts) which is kind of amusing (even though I've never found lisps particularly easy to read)).
- wyldfire 5y agoI think typical writing style guides suggest the single-quote for nested quotes. "I think he said, 'No way?! Zig for the win!'"
- kristoff_it 5y agoNot sure if this transpired in the writing, but my interpretation of RIIR, partially informed by the chat with JT [0], is that this is a sentiment that I guess is there in some people, but that it was never something officially sanctioned. [0] https://www.youtube.com/watch?v=X7ny7Qrsbd8&t=5391s https://www.youtube.com/watch?v=X7ny7Qrsbd8&t=5391s
- deleted 5y ago[deleted]
- vlovich123 5y ago> added a Rust dependency which in turn changed the list of supported platforms My understanding is that `zig cc`/`zig c++` are thin wrappers around LLVM, so doesn't that just reintroduce the same problem?
- deleted 5y ago[deleted]
- skybrian 5y agoYes, if you exclusively use Zig to build the code. But on an platform that Zig doesn’t support, you could write your own makefile instead to compile the C code with the native compiler, so the situation seems a bit better than with Rust?
- williamstein 5y ago‘zig cc’ is more than that. You get a very powerful caching system, and built in support for cross compilation to a huge range of targets (via zig shipping with libc sources). Zig is extremely impressive.
- dleslie 5y agoThe built in cross compilation is just LLVM; it's a narrower set of targets than GCC, and a _far_ narrower set of targets than where you'll find a C compiler. clang cross compilation is not really any harder, you just supply the -target flag.
- messe 5y ago> clang cross compilation is not really any harder, you just supply the -target flag. Yes, but it doesn't bundle and automatically compile the appropriate C library for the platform. Zig does.
- dleslie 5y agoIt can, if the package manager bundles it that way. Instead, clang is usually packaged and distributed as cross-compilation variants; because most of the time users don't need all of the different possible targets, they just want one or two.
- losvedir 5y agoThe build tooling of Zig is very impressive. I'm a sponsor of the project not necessarily because of the language itself, but because it surely has the potential to make waves in some way or another (edit: though the language itself is also quite interesting). One thing I wish the blog post had brought up is testing! Zig has some great tooling around tests, and that is something sorely lacking in a lot of C projects. If nothing else, you can pretty easily use Zig to simply write some tests for a C project! Even that would be a big improvement to the ecosystem.
- hitekker 5y ago> To improve our critical infrastructure we must improve the developer experience (DX) of systems programming, but rewriting everything is not the only answer. I like Kristoff from what I've read of him. He seems like a leader who will take responsibility and not shy away from hard decisions. On that quality alone, my money is on Zig winning systems programming over Rust in 10 years.
- xedrac 5y agoWhen choosing between Zig and Rust for systems programming, I would reach for Rust most of the time. It's just a more expressive language with some seriously awesome compile-time guarantees. There are three things that bother me about Rust: bloated binaries, slow compile times, and dependency bloat (accidentally building 5 versions of the same crate). But seeing as it's being integrated into the Linux Kernel, I think Rust has a long and bright future in that space. Having said that, I think Zig would be a really great language for kernel programming.
- 0xCMP 5y agoYou can build C projects using Rust and Cargo as well[0], but it requires more work than Zig appears to need. Rust also has good C FFI story and honestly I think we will still see a lot of important code rewritten in Rust. That said, a more ergonomic C which seamlessly replaces the often bloated build configuration of C/C++ projects while allowing a far nicer language to slowly replace the existing code feels like TypeScript for JS (which I consider a good and smart thing). Definitely agree it's going to get far more use than I'd originally have guessed. [0]: https://adventures.michaelfbryan.com/posts/how-to-riir/ https://adventures.michaelfbryan.com/posts/how-to-riir/
- steveklabnik 5y agoThis is qualitatively different, that requires a C compiler to be installed. rustc cannot compile C code itself. zig can.
- roca 5y agoIn the 21st century, if you're building systems infrastructure and are able to choose a language that's not C or C++, it's a pretty big call to decline memory/type/datarace safety.
- pjmlp 5y agoUntil Zig fixes the issues with use after free, it is hardly an improvement.
- wyldfire 5y agoCan you clarify your point?
- sigzero 5y agoProbably related to the following: https://github.com/ziglang/zig/issues/3180 https://github.com/ziglang/zig/issues/3180
- wyldfire 5y agoGee, IIUC it looks like it's been addressed by offering a new allocator that's able to detect use-after-free.
- kristoff_it 5y agoTo be fair this alone is nowhere near what Rust can do for you in terms of safety.
- wyldfire 5y agoBut Zig makes this tradeoff intentionally. By design.
- kllrnohj 5y ago"It's intentionally less safe! That's why you should use it!" Zig may strike a better balance than Rust does here, but it seems more like Rust stole its lunch. I don't know why I'd migrate from C/C++ to Zig instead of going all the way to Rust?
- 5y ago
- clipradiowallet 5y agoThe article didn't tell me what Zig really was, so for other people in my boat: https://ziglang.org/ https://ziglang.org/ headline from that website: Zig is a general-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.
- chakkepolja 5y agoI am a fan of all the interesting work happening in zig, especially tooling side. But I don't like that headline. Zig is a system programming language, whereas when someone says general purpose programming language they mean java or python. And "robust, optimal, and reusable software" - this type of words are used by all projects these days that it sounds like MBA speak. I also don't like the tendency of system language projects (zig, rust) to market as if they are application languages, perhaps in an attempt to drive adoption. Can't blame them for this, but it seems an influx of relatively young, inexperienced programmers from ruby rails / javascript crowds creates false impression of a strong ecosystem.
- smasher164 5y agoWhat I don’t understand is why Clang doesn’t do this? What’s stopping them from shipping libc’s for cross compilation? Given that they are a C and C++ compiler, surely this is in their domain.
- matu3ba 5y agoYou need to provide low-level build functions, which is quite some work. On top of that you need to understand the build system of the libcs to replicate it. On top of that for libcs you want to deduplicate all symbols to reduce as much space as possible. On top of that you might want to provide glibc symbol versioning. People without incentive usually do not do this tedious kind of work, since "it works for me".
- azakai 5y agoIn principle, clang could do it, you're right. I think there are two main reasons why it hasn't. First, Zig has a pretty unique and impressive build&caching system. It makes something like this a lot less painful than it would be otherwise. It makes it practical to just download a 40MB tarball and get full cross-compiling from it. Second, clang itself isn't in the business of building a distribution of itself + third-party libraries. Usually developers using clang get such libraries from their "vendor" (package manager if on a Linux distro, Apple if on MacOS, etc.). And those vendors naturally focus on their own platforms. So Zig ended up the first to really do the work to build a cross-platform C/C++ toolchain.
- dleslie 5y agoThe author seems to be under the impression that Rust cannot live harmoniously within the C ABI ecosystem, which is false. To some extent. Rust, due to relying on LLVM, is limited by its available targets; and so cannot enjoy the full access that C/C++ can. The same is true for Zig, however, since it does not compile to C.
- kllrnohj 5y agoYeah it was a really odd choice of a "why not Rust" bug since the problem with Rust in that bug applies entirely to Zig as well. So if you can't use Rust because it doesn't have the broad compiler support that C does, you almost certainly can't use Zig either for the exact same reason. And then the article touts Zig using their own in-house linker, which seems inevitable to have less platform support than LLVM will? Zig isn't wrong for doing that, but you can't claim that's a benefit at the same time the problem with Rust is it's lack of fringe system support... :/
- kristoff_it 5y ago> which seems inevitable to have less platform support than LLVM will? ZLD can link for M1 while LLVM can't yet. And Zig can also use lld alongside it to increase the platform coverage. > but you can't claim that's a benefit at the same time the problem with Rust is it's lack of fringe system support... :/ I find it hard to believe that a dispassionate reader could misinterpret to this degree the goal of a sentence written in a chapter dedicated entirely to showcase the limits of rewriting code in another language, be it RIIR or RIIZ. See my reply to the parent comment for the intended meaning of that example.
- matu3ba 5y agoyet.
- zamadatix 5y agoOne could say the same thing about Rust, and at least that language has hit 1.0.
- scrubs 5y agoFolks, gotta like the sentiment and artifacts to back it up with here.
- pharke 5y agoI prefer D, it can be fully compatible with C, the syntax is easy to learn if you've used any of the C family you already know 80%, the package system is simple, modules mean no more headers or include statements just import things where and when you need them, supports every style of programming, QOL improvements like ranges and foreach, proper strings, optional garbage collector, has a long history of continuous improvement and support. To me it's the clear choice if I'm going to rewrite an old C project since I can mostly just copy paste the old code and it runs, after which I can clean it up and simplify it using the new features mentioned. Oh! and integrated unit tests and documentation generation are superb. Helpful error messages too. I could go on but I'd prefer everyone just try it out and see for themselves. https://dlang.org/ https://dlang.org/
- 10000truths 5y agoI would say that Zig has the same advantages for a lot of these points. Its interoperability with C at the source and object level is first-class, the syntax was very easy for me to pick up as someone familiar with C/C++, the features it adds on top of C (e.g. slices, compile time execution) are few but huge QoL improvements, its translate-c utility works amazingly well at transpiling C code to Zig, and its test blocks make unit testing trivial to integrate.
- gavinray 5y agoOut of curiosity, have you written apps in both languages? I have written small applications in both. To be transparent: my total dev hours in D are probably somewhere around ~100, and in Zig about ~30. So I am more familiar with D than Zig, though competent enough with both to have written a few small real-world programs. > Its interoperability with C at the source and object level is first-class D has direct interop with both C, and C++. Also, it's recently gained it's own C compiler, and can natively compile C code so that they are D objects, not just external definitions. - https://dlang.org/spec/interfaceToC.html https://dlang.org/spec/interfaceToC.html - https://dlang.org/spec/cpp_interface.html https://dlang.org/spec/cpp_interface.html It can even directly interop with C++ classes: - https://dlang.org/spec/cpp_interface.html#using_cpp_classes_from_d https://dlang.org/spec/cpp_interface.html#using_cpp_classes_... > the syntax was very easy for me to pick up as someone familiar with C/C++ D is closer to C/C++ than Zig IMO. One of it's design goals is actually: "10. Where D code looks the same as C code, have it either behave the same or issue an error." And: "The general look and feel of C/C++ is adopted. It uses the same algebraic syntax, most of the same expression and statement forms, and the general layout." See: https://dlang.org/overview.html#goals https://dlang.org/overview.html#goals I found Zig to be much less syntactically similar to C/C++ than D. Zig felt more like a mix of Rust/Go. > the features it adds on top of C (e.g. slices, compile time execution) D also has slices and (outside of Lisp) was the first programming language I believe to introduce CTFE and CTFE-based metaprogramming. C++'s implementation as I understand it is essentially lifted from D. - https://dlang.org/articles/d-array-article.html#introducing-slices https://dlang.org/articles/d-array-article.html#introducing-... - https://tour.dlang.org/tour/en/gems/compile-time-function-evaluation-ctfe https://tour.dlang.org/tour/en/gems/compile-time-function-ev... > its translate-c utility works amazingly well at transpiling C code to Zig As stated above, not required due to ImportC, but there are several tools to automatically generate "extern" bindings to C/ObjectiveC/C++. You use these if you're linking with an external out-of-tree library, or a C++ library. - C, Limited C++ = https://dlang.org/blog/2019/04/08/project-highlight-dpp https://dlang.org/blog/2019/04/08/project-highlight-dpp - C, Extensive C++ = https://github.com/Superbelko/ohmygentool https://github.com/Superbelko/ohmygentool - C, Objective-C = https://github.com/jacob-carlborg/dstep https://github.com/jacob-carlborg/dstep > its test blocks make unit testing trivial to integrate. Again, D also has this: - https://tour.dlang.org/tour/en/gems/unittesting https://tour.dlang.org/tour/en/gems/unittesting ============= Not trying to start a pissing match, because I actually think that Zig has a lot to offer as well -- but for these particular list of things, there's no clear winner here.
- yawn 5y agoThis post has a copy of an xkcd comic (https://xkcd.com/2347/ https://xkcd.com/2347/) without linking back to it (https://xkcd.com/license.html https://xkcd.com/license.html). It's probably a mistake.
- torginus 5y agoGenerally speaking, what killed C++/C for me is the absolute insanity that comes with it's build systems/third party dependency management. I feel like the notoriety that C++ gets for it's absurd complexity comes not from variadic template metaprogramming/rvalue references/unique_ptr or whatever, but the absolutely humongous effort needed to understand automake/CMake/autotools just to build other people's code (god forbid on a different platform than the original author).
- adamdusty 5y agoThe build system for zig is essentially the same as CMAKE just in Zig and entirely undocumented.
- rofrol 5y ago- https://ziglang.org/learn/overview/#zig-build-system https://ziglang.org/learn/overview/#zig-build-system - https://ziglearn.org/chapter-3/#zig-build https://ziglearn.org/chapter-3/#zig-build - https://zig.news/xq/zig-build-explained-part-1-59lf https://zig.news/xq/zig-build-explained-part-1-59lf - https://dev.to/mattnite/weaning-zig-off-of-git-submodules-1-3jen https://dev.to/mattnite/weaning-zig-off-of-git-submodules-1-... - https://dev.to/fabioarnold/setup-zig-for-gamedev-2bmf https://dev.to/fabioarnold/setup-zig-for-gamedev-2bmf
- pjmlp 5y agoI just build a VS solution, call MSBuild, install dependencies via NuGET/vcpkg and be done with it. And even better since they support binary libraries, I can focus on my own code instead of building the foundations first.
- deleted 5y ago[deleted]
- slimsag 5y agoI totally 100% agree. "Getting started" with a C/C++ project is a huge pain and IMO where most people get stuck and give up on their weekend project. I'm working on a game engine in Zig[0], and I've been able to package up GLFW, write a build.zig file that `git clone`s all of the third-party system dependencies so that anyone can just: const glfw = @import("glfw/build.zig"); ... lib.addPackagePath("glfw", "glfw/src/main.zig"); glfw.link(b, lib, .{}); And have GLFW building (and cross-compiling!) for their project, without installing anything other than Zig and Git. No XCode. No `apt-get install ...`. Nothing. Just `zig` and `git` binaries. Zig is the C compiler and builds the GLFW source, and I have repositories with the required prebuilt system libs for cross compilation. [0] https://github.com/hexops/mach https://github.com/hexops/mach
- BiteCode_dev 5y agoI hear about zig all the time, and I'm surprised I don't more about vlang. Yet they still to target a similar audience. Is this a matter of popularity or features ?
- ternaryoperator 5y agoI too am surprised V does not get more attention here. I think the main developer frayed his ties with HN by some of his early claims. Nonetheless, he's doing good work moving V forward and developing community. [0] [0] https://vlang.io/ https://vlang.io/
- dralley 5y agoVlang started as a closed source project with a lot of lofty claims that fell apart quickly once the project was actually opened up. Combined with all the delays and broken delivery promises leading up to that, it gave people a poor impression of the project. With that said, I've heard the situation has improved since then.
- amedvednikov 5y agoCan you list any claims that fell apart? For example, one of the biggest claims has always been fast compilation. Here's V compiling itself in 0.3 seconds: https://www.youtube.com/watch?v=pvP6wmcl_Sc https://www.youtube.com/watch?v=pvP6wmcl_Sc V was also self hosted (written in V) from the start, which says a lot about the maturity of the language. > Combined with all the delays There were no delays. The project was announced to be released in June, and it was. By the way, we now have a cool OS written in V, that can already run Bash, g++, and V itself! https://github.com/vlang/vinix https://github.com/vlang/vinix
- vlang1dot0 5y ago> V was also self hosted (written in V) from the start, which says a lot about the maturity of the language. How could that possibly be true? You need a V compiler to compile V but none would have existed "from the start". You've also said multiple times on Discord that the original V compiler was written in Go.
- modeless 5y agoIf Zig can solve the C++ build system quagmire then I will love it for that reason alone, even if I never write a line of Zig for any other purpose.
- geon 5y ago> once you learn JS you can do [...] video games (Unity) Not true. Unity once supported their own language based on Boo, a python dialect for the .net runtime, that they falsely advertised as "Javascript". That has since been depreciated.
- ndesaulniers 5y agoReplacing lld rather than add macho support send like a mistake.
- ndesaulniers 5y agos/send/seems/
- AndyKelley 5y agoLLD is written in C++ and depends on LLVM (a massive C++ library). Zig's self-hosted linker has no C++ or LLVM dependency. One of the features of a compiler is how short the bootstrapping path is. C++ as part of the bootstrapping process is a failure of sorts. Furthermore, LLD doesn't support incremental compilation. It's just not fast enough for our compilation performance goals.
- ndesaulniers 5y agoAndrew, let me know if you want to try to compile the Linux kernel with zig cc. ;)
- shp0ngle 5y agoYou replace the pipeline from GCC/LLVM to Zig. But the codebase is still in C and therefore has all the negative properties (memory unsafety, undefined behaviour), so what did you gain?
- pphysch 5y agoYou can write new code in Zig and gradually refactor the problematic bits of C
- deleted 5y ago[deleted]