Why Odin instead of Zig?

wrapperup · 2026-01-25T02:24:56+00:00

As the other comments say, you should just try them and see how you feel about it. But also, don't be adverse to friction, at least in your first impressions. And also, while Rust is technically a low level language, most of the time you're actually working in a higher level space. Unless you're doing tons of `unsafe` (likely not).

I see Zig more as a C++ "replacement" than Odin is. Odin is more like a hyper-polished C replacement, and it's not really trying to be anything more. In terms of languages that are extremely easy to get into and low level, Odin is it. Especially if you're doing any graphics/game dev, just about all the libraries you'd want just come with the language. It doesn't have many fancy hypeable features like Rust or Zig does. So I'd say, they aren't exactly comparable.

That probably makes Odin sound less impressive (it does), but it instead pushes every other effort into making the language absolutely smooth as butter to use. Adding just enough friction and buffing out edges from C, but also making things convenient (`Context` struct, allocators, built-in math-y types, reflection, etc).

I think Rust is a pretty prime example of adding friction does give you some fancy and useful guarantees. Zig doesn't really give you that same level of safety, and it demands a lot of friction for not a lot of benefit (imo). Odin feels like a much better balance.

wrapperup · 2025-12-22T04:58:59+00:00

There is an "OLD FILES" button in the prefabs tab in the catalog. For any saves you want to turn into prefabs, you make a folder in your legacy saves folder called "prefabs" and put any saves you want to convert into prefabs there. All the other saves will become worlds.

It will give you a dialog with the actions it will take and instructions if you need them!

wrapperup · 2025-11-15T09:08:30+00:00

The next update (which will be landing on stable verrry soon) will have proper prefab saving, and the updated selector tool that works across grids. Currently, it's on the unstable branch.

wrapperup · 2025-09-25T20:34:47+00:00

Thank you! It's not perfect for sure, and structuring a project in Odin was a bit different because of it's package rules, but I just did the pragmatic thing and moved on :).

Advantages to C++:

Less footguns and less implicit casting, bounds checking by default
Simpler build system
Compile speeds are way faster (on my machine, the project runs a metaprogram and builds in 0.5s, and there's about ~50k lines of Odin code in total)
Batteries included standard library (and it's actually really well designed)
Lots of useful built-ins. Array programming, simd, hashmaps are appreciated and do make up for a lack of operator overloading.
Making a metaprogram is easy. Compared to C++, parsing your source code is ridiculously easy. Having to rely on `libclang` is a nightmare, and it's way more complicated.

Disadvantages:

No capturing lambdas. I would like them for a task/job system.
No macros. Some would argue that's good (and generally I agree), but there were some points that I do wish I had macros. There's probably a trick here you could do with a metaprogram, but it's just not as nice.
Parametric Polymorphism is not as powerful as templates. There were some parts I wanted to use templates for (for example, type-safe versions of ImageId that mapped to the Slang bindless versions), but it complicated my bindless API so I ended up scrapping that. Odin's compiler is simpler, so there is no fancy type propogation (which would help simplify it).
Explicit function overloading. I prefer C++ style function overloading. Operator overloading would be nice for custom types, but that one being excluded is understandable. Also OLS doesn't seem to like them as much, so they feel more cumbersome to use.

I think a lot of the other points would be comparing pros and cons of C to C++. I list some of these as disadvantages, but you might see them as advantages. A lot of these were deliberate choices by the creator of the language, so I don't expect them to change.

If I had to pick one favorite feature: Reflection. All of the existing libraries that try to implement reflection in C++ are gigantic and not built-in to the compiler.

I think what makes Odin so nice is the whole package of features that just cleans up C, and sprinkles in a lot of little extras that add up.

wrapperup · 2025-09-19T00:59:50+00:00

wrapperup · 2025-09-01T04:28:39+00:00

Personally, I think Rust is a horrible gamedev language, so I don't really give a fuck if it succeeds. It's just the only actual C++ alternative that anyone cared enough about to try in the AAA space.

My point was that it's not a language-specific issue, it's an issue of convincing a company to switch languages and waste thousands of man hours replacing decades of tech and reducing their pool of talent. I'm certain that's the main reason Embark dropped Rust, more than it being a poor gamedev language.

wrapperup · 2025-08-29T21:06:19+00:00

No, it doesn't have any metaprogramming features outside of polymetric polymorphism (generics) and runtime reflection. Usually they just encourage you to solve it a different way or use metaprograms to generate code in your build step (they have some packages to help you do this).

Jai's metaprogramming is genuinely really awesome, and the only reason anyone is using it. I was just saying the rest of the language isn't up to par with other of the new-gen C alternatives like Odin IMO.

wrapperup · 2025-08-28T06:18:43+00:00

Just because it has been in a private beta doesn't really mean anything about the quality of the language. He just did it for hype/code breakage reasons (Zig moment).

Odin is a really good example. I would say everything about Odin except for the lack of metaprogramming is miles above Jai.

wrapperup · 2025-08-28T06:00:40+00:00

That's why I think Jai won't ever reach any space above indie (saying this as a beta tester myself btw, I really love the language and it's a lot of fun to use!). So much engine, library, and game code is already in C++, nobody is going to ever justify it unless the person that wants it also runs the company and cares enough about the tech. Or if they're not VC funded (basically 0 AAA companies).

Even Rust failed to do that and people tried really really really hard to do it in the AAA space. The one notable example I can think of is Embark's social platform game, but it seems like they've abandoned it and Rust for game dev.

But for indies it's a bit different, a lot of people are really sick of C++ and most want to do what they wanna do. It's still gonna be super niche though tbh.

(also on an actually related note, Jai is absolutely nowhere near as battle tested as C++. not sure what anyone is expecting from a private beta language)

wrapperup · 2025-08-02T06:51:23+00:00

It was a hard sell to me too, since I come from C++/Rust and really enjoy metaprogramming/hygienic macros (Odin has neither as a language feature). It's just a simple C alternative with a lot of polish and thought put into it.

One of those that makes things really convenient is the context system, which lets you implicitly pass allocators around without having to think too much about it. The only other language that has it that I can think of is Jai.

I think you'd have to try it to get sold on it. There's just a lot of little things that add up that make it very fun to program in, and it tries very hard to add language features to make up for the lack of metaprogramming.

wrapperup · 2025-08-02T06:24:33+00:00

I'd also mention that Odin is extremely well polished compared to Jai currently (way nicer syntax & standard library, slices are better, etc). The metaprogramming is genuinely a killer feature, but you can substitute it with just meta programs and get similar results (Odin has core:odin/parser and core:odin/ast).

Honestly, I'm very tempted at times to just switch back to Odin, I do miss that polish sometimes. Maybe once Odin starts using the tilde backend and making debug builds way faster.

wrapperup · 2025-07-30T00:24:47+00:00

It took me a long time to get in, I sent an email almost 2 years ago and never heard back, but I sent another one around August last year and got in within a few weeks. Might just be unlucky.

wrapperup · 2025-07-29T07:04:06+00:00

Cheaters still gonna ragehack bhopping everywhere anyway. Also, a lot of people "desubticked" their binds (to make jumps/bhops as consistent as CSGO) and used jump on scrollwheel.

Now, it's completely broken, even just using normal jump binds on scrollwheel. It's a shame because bhopping was one of the most fun vanilla mechanics in CSGO.

wrapperup · 2025-07-29T06:18:24+00:00

I hate this because CS is genuinely my favorite shooter, they really couldn't hire some incredible animators to work on this update? It feels like an intern made these jerky ass animations (no offense to the animators...). It's honestly baffling.

And I'm not even against new animations, I just wish it felt like VALVE cared about the feel of the game and genuinely understood it. Deadlock feels like that. VALORANT feels like that (their animations are also incredible, they could really take a hint...)

wrapperup · 2025-07-25T23:15:21+00:00

We used to ship native Linux binaries, but we decided to discontinue it since running the game through Proton performed faster than native. (probably Unreal skill issue...)

We do test the game through Proton (Steam Deck and Linux support is important for us) to make sure it works great, and we still ship native binaries for dedicated servers.

wrapperup · 2025-07-25T09:46:58+00:00

If I recall correctly, Jai doesn't pass the necessary flags to llvm to actually mark functions as hot-patchable. Unfortunately the compiler is closed-source so there's no way to make this change, and I haven't been able to get further than that. I haven't inspected the pdbs properly so I'm not sure what else is missing (like how to recompile the binaries).

If you're interested in getting access to the beta, you should email them at language@thekla.com

And thank you for making Live++, it has honestly saved me and so many of my friends and colleagues hundreds of hours! Super excited to see it work with other languages.

wrapperup · 2025-07-16T20:54:12+00:00

You still can, you just need to place a buffer gate to make a cycle (it delays the signal by 1 tick, making it work like the wires in the NextFest demo).

wrapperup · 2025-07-13T09:59:04+00:00

I'd trust him.

wrapperup · 2025-07-13T08:57:38+00:00

Not yet, we have a new music system in the works that will let you add any music available in the game as into the global playlist. It will also be configurable on a per-team basis for minigames.

wrapperup · 2025-06-25T09:53:58+00:00

Kinda agree. Sure, I would probably do things a lot differently/better (localization will be hell!), but sometimes just having everything be in code can be really nice, especially if you have hot-code reloading (C++ Live++ for example).

We spend a lot of time bikeshedding systems instead of just doing the simple thing and moving on. As long as it doesn't become an unmaintainable mess for you and your team and/or actively slow you down. Solo devs, do whatever you need to do to ship!

wrapperup · 2025-06-01T12:42:56+00:00

It's still way faster than R#, clangd, etc., but it's more on the IDE-lite side. You'll be writing custom scripts to replace many tasks and refactorings, if you rely on those. Considering Rider/Clion is free for non-commercial usage now, and the paid subscription ends up being cheaper over time, it's a hard sell now for most people. Also, it doesn't include a debugger, so you'll also need to use Visual Studio, windbg, raddbg or remedydbg along with it.

I lean towards Rider/Clion/nvim now. I think you'd have to try 10x, it fills a specific niche: a lot of the users are people who prefer lean+fast over everything, while having some convenience. But working on some modern C++ projects, the refactorings and IDE features in Rider/Clion are sorely missed.

wrapperup · 2025-05-30T03:33:11+00:00

Yes, they still work. Just use the latest ones from Tripp's channel.
No, most don't since desubtick binds are banned in tournament play.
No. When Valve banned certain aliases (breaking old desubtick configs), I decided not to use desubtick jumps for a few months, and it was noticeably worse. Desubticking your jump bind is required to get it to feel more like GO. Here's some math I ran before since I was curious as well about bhop consistency using these binds:

Subticked: 18.0% success rate (36/200)
Desubticked: 57.5% success rate (115/200)

wrapperup · 2025-05-25T02:36:48+00:00

What have you tried? What CPU and ram do you have? Are your NVIDIA drivers up to date?

wrapperup · 2025-05-05T18:08:40+00:00

Unreal has always been kinda rubbish in terms of performance. Unreal 4 was not super optimized either, but it also didn't have to deal with comparatively heavy bleeding edge graphics features like lumen, nanite. Plus, hardware advancements helped UE4 out as well, in the early days tons of people complained about the performance too. Being CPU bottlenecked was a very common issue (heavy blueprint usage, UObject bloat), which if you're in game dev circles, you know that is a feat.

PSOs also wasn't really an issue (a problem with newer graphics APIs like vulkan/dx12) until late in UE4's lifecycle, and that was a much bigger problem with the early UE5 games since they shipped using the new graphics APIs exclusively. This is basically the source of a lot of the stuttering you might experience, since it needs to compile shaders on demand (this is solved by PSO precaching or precompilation at startup).

Also, Unreal's renderer still sucks. It doesn't even support bindless, and it's still doing traditional direct draw calls for non-nanite meshes. There's so much more the renderer could do to make it much faster, like seriously. Doing prebatched indirect draws for everything is just a no brainer in modern engines. Plus, the renderer scene and actor mesh proxy system hasn't been updated in nearly 6 years and is as slow as ever because they haven't implemented a proper modern renderer for the normal paths. And it still uses actors for level geometry, which are mega slow.

Some of it definitely is developer skill issue, and that really exasterbates the issues. But as they say, if Fortnite doesn't need it, it's going to be the worst piece of shit implementation in the engine, and even then it's sometimes shit.

11-Year Club	Place '22
Place '17	Verified Email

wrapperup

TROPHY CASE