Kapendev

Thanks!!

I like how easy it is to switch between low-level and high-level code, and it has some neat features for modeling data.

No idea. I weirdly want to use the Wasm target with some JS thingy to target mobile. Sounds like fun?

Parin is a 2D game engine I've been working on for about two years.

Very interesting post. How can I use that for web development? My senior told me to ask this question.

Good stuff. I say that as someone that is not biased.

Really? Wow, this is like Zig and I love Zig!

Flutter

That's a nice list!

People here need time to notice XD

Zoomer is a good word btw. I love zoomers.

Well, I do!?!! It's even faster than zoomer langs like Odin. You should try it.

> This whole GC vs no-GC thingy

And I am here, enjoying both. Life is good.

> String Interpolation (F-strings)

This is so nice. It's crazy how other low-level langs don't have it. I know Dlang and Rust have it. Maybe Swift too? The way Dlang does it is nice because you can do a lot of stuff with them at compile time.

Vlang mentioned, let's goo! I like low-level languages that provide easy access to a GC. It's a nice way to make some parts of the code more high-level and it kinda avoids the need for a scripting language sometimes.

I wrote a simple benchmark comparing my custom dynamic array implementation in Dlang with dynamic arrays in other languages. The test appends and then removes 100,000,000 integers on a Ryzen 3 2200G with 16 GB RAM. This is just a rough cross-language benchmark and not something serious:

Appending and removing 100000000 items... Testing: ./app_d real 0.16 user 0.03 sys 0.12 Testing: ./app_zig real 0.18 user 0.05 sys 0.13 Testing: ./app_odin real 0.27 user 0.10 sys 0.16

Code and benchmark files are here: https://github.com/Kapendev/joka/tree/main/benchmarks/array_...

> Using D in betterC mode is what I am most interested about

Well you will. It's a common mistake new D users do.

Don't use betterC as a global @nogc attribute. This flag does more than just remove the garbage collector and adds extra checks that can sometimes be overly restrictive. If writing GC-free code is important and compiler assistance is really needed, then add @nogc: at the top of every file. But even that is a bit extreme because the @nogc attribute is just a hint to the compiler, telling it to check that called functions also carry that hint. It is not essential for writing GC-free code.

My library for example is not using the GC, but I don't put @nogc on every function because it does not make sense. Here is the link to the library: https://github.com/Kapendev/joka

You and Walter could do that, but this post is about some cool devs and their cool Zig project.

Good question, but I don't think this is the place for that conversation :) And I say that as a Dlang fan :)

> language is fractured by the optional GC

That's an interesting fantasy you have constructed. You should try listening to the people who actually use it.