zig VS Nim

Zig compiler pipeline (AST, Zir, Air, Sema) does exactly this on all layers. Not only contiguous, but instead of array-of-structs it is struct-of-arrays, so walking the tree is even more cache friendly. For AST see: https://github.com/ziglang/zig/blob/master/lib/std/zig/Ast.z...

Yes, please read the comment linked at the issue description: https://github.com/ziglang/zig/issues/16270#issuecomment-161...

A few notes:

1) Lack of a garbage collector does not make your program faster, it makes the performance more easily predictable in terms of latency.

It also makes it more friendly for memory bandwidth, CPU cache and to overall memory usage, which in turn results in better performance in real-case scenarios vs synthetic/toy benchmarks. This is particularly noticeable in constrained environments (like embedded systems).

2) Zig was never about memory safety, and it is not a memory-safe language.

It might have better plumbing than C, it might add better way to implement and abstract concepts.. but so does C++, for instance.

The more striking differences between C++ and Zig, IMHO, are syntax and the ability to use the same language instead of a separate one to do meta-programming (templates vs comptime).

3) Aliasing enforcement in Rust is there for a reason.

Two examples I quickly found on Zig's issue tracker:

https://github.com/ziglang/zig/issues/3696

I'll tell you my experience with Zig. I don't have any. I saw maybe Primagen talking about it and I see your post here. I watched 10 minutes of your vimeo video. I see it has 30k+ stars on github. So now I have to try to understand it in a nutshell.

First like any language, I go to indeed.com and put in "Zig" to see if there are any jobs listed which use it. I don't see any.

Then I click to https://ziglang.org/ and it describes Zig as "robust, optimal and reusable". Well that doesn't really say much of anything.

I read the example listed, which appears to be a test case, and I wonder how the 'try' mechanism works without a 'catch'

Then I go to https://ziglang.org/documentation/master/ and see that it says:

> will that function also get to return a u8?

No, the main function (the entry point of the entire program) is special cased. Have a look at the source code. There you can see the it's calling the user defined main function and handling its return value / error.

https://github.com/ziglang/zig/blob/2d888a8e639856e8cb6e4c6f...

> Also, what happened to argv/argc?

You can access argv with std.os.argv which is a slice of null terminated strings. It's better to go with std.process.argsAlloc though (requires an allocation but works on all supported platforms).

I'm a bit hesistant to mentally invest in Zig, given the maintainers choice to directly develop against a mostly undocumented NT-API instead of the Win32 API.

[1]: https://github.com/ziglang/zig/issues/1840

Interestingly, Huly is also the sponsor of the Zig programming language[1].

[1]: https://ziglang.org/

> And there's also the aliasing issue

Plans to address this were shared just last week: https://github.com/ziglang/zig/issues/5973#issuecomment-2380...

All these organizations[1] using nim in production must disagree with you then.

[1]: https://github.com/nim-lang/Nim/wiki/Organizations-using-Nim

With function overloading and templates

You just use a `hash` function in your library code and user has to implement a version of it that accepts the Foo type.

To resolve the scope problem, Nim uses templates[1] with `dirty` pragma (makes template unhygienic), but there is also a `mixin`[2] statement for later static binding.

0 - https://github.com/nim-lang/Nim/lib/pure/collections/tables....

1 - https://github.com/nim-lang/Nim/blob/78983f1876726a49c69d656...

2 - https://nim-lang.org/docs/manual.html#generics-mixin-stateme...

Check out Nim[0] - it's strongly typed, with good type inference, clean elegant syntax, memory management is automatic (optional gc, default is ARC + small footprint cycle collector), compiles to small single binaries (Hello World is less than 100 kb), has powerful metaprogramming and lsp support.

Nim compiles to C/C++ and then to native code, so performance is on the same level as Rust/C/C++. You can also compile Nim to js/wasm and run the same code in the web.

[0] - https://nim-lang.org

Programming Language: Nim

Take a look at Nim.

You get C performance, with the readability of Python.

https://nim-lang.org/

It’s not exhaustive/definitive yet (should be for the actual release), but this might be helpful:

https://github.com/nim-lang/Nim/blob/devel/changelog.md

22. Nim - $80,000