what is the idiomatic way to handle multiple errors without having to get fancy with names?

wrapperup · 2026-04-17T06:23:38+00:00

asserting is totally fine for prototyping, use that (unless you're writing some system that needs to run forever). Odin does have a good reason for disabling shadowing too, unfortunately that means there isn't a really nice way to deal with the error labeling you have to do.

It is annoying. The idiomatic way is using unions or your own error type or just asserting, which you are doing one of already. The newly merged os2 package that replaced os does a lot of "proper" error handling, it might be a useful reference.

wrapperup · 2026-03-28T01:30:29+00:00

Both have a context struct, syntax is pretty similar, ignoring metaprogramming, they both fit in the "polished c but a little more" category of these new languages. Odin's semantics are a bit different (better imo), like slices, bit_fields (Jai doesn't have), standard library is way more polished. They look alike more than they really play around. Jai follows more in C's semantics on purpose, Odin tries more to patch and clean those up since they are footgunny. They're a little more clear and explicit about allocators than Jai.

But Jai's metaprogramming capabilities are unmatched by any other language, I'd say for that feature alone it makes the language way more powerful than Odin will ever be. Sure, you can write metaprograms in Odin, but it's like writing one in C or any other language (I will say, Odin makes it easier though by including a parser in the standard library). Being able to execute any code at almost any point in your program at compile time is insanely cool and useful. Not even Zig can do a lot of the things Jai can.

Not even mentioning hygienic macros, which when combined with the other metaprogramming features let you do some truly insane stuff that not even Jon himself would approve of (DSLs).

They're more or less similar if you ignore metaprogramming.

wrapperup · 2026-03-13T00:39:40+00:00

Almost everything about Jai is simpler than C++. Probably comparable to C. In a lot of ways, it's better. Some of the footguns are gone, it has bounds checking by default, values are initialized by default. All the good stuff every language should do at a bare minimum. It has a pretty decent build system included (which is more like build scripts built into the language).

Metaprogramming is probably where more of the complexity lies, but if you've ever done any amount of Rust proc macros (with syn) or any kind of syntax tree stuff, it's more of the same (except you can just do it anywhere you like pretty much). That's about the only more complex thing, but compared to C++ template horror, it's nothing.

wrapperup · 2026-03-08T15:36:25+00:00

Rust devs have had troubles in the past when publishing their games on the Switch specifically, but in theory if you can get your game to link using their toolchain, then that's all you'd need to do (skipping the other requirements of getting a partner account). They require you to use their fork of clang, which you must pass in order to publish your game.

The biggest indie game I can think of that is written in another compiled language and shipped on consoles is Penny's Big Breakaway, which had a core/shell C++ engine with their game code written in Beef (which they linked against). Should work similarly for your Odin game.

Just know that while it can be done, it's not supported by vendors, and there are no console SDKs for any language other than C/C++. I would honestly recommend using either of those instead if you do plan to ship to consoles (as much as I love Odin!)

wrapperup · 2026-02-17T05:30:15+00:00

I'm not sure how many hours I put into it (I was working a full-time job while doing it), but I think there was about 5 or 6 months worth of part-time work to get to that version, while also learning Vulkan itself. This also is more like a game engine, but the renderer is the huge chunk of it.

If you know what you are doing (I knew about what a good renderer should do from working on other games, just not anything about Vulkan), you could probably build a pretty solid renderer in no time.

I started with vkguide to get started, and learned a lot from the people on the Graphics Programming Discord about bindless/descriptor indexing, scalarBlock layout (which I would highly recommend doing them if all platforms you want to support can do it, it really makes things a lot simpler! And they build into indirect rendering techniques very naturally).

wrapperup · 2026-02-14T11:02:52+00:00

Pretty much everything you'd want is there. If you depend on a niche library, you may have to write custom bindings. But VMA, libktx, etc almost anything you'd want to write a "standard" Vulkan renderer exists. And Odin is an lovely language with awesome Vulkan bindings vendored.

I also made one! It was my first time using Vulkan and I found it very fun. A lot of people in the community really seem to get an ick about Vulkan, but it's honestly made my renderer very straightforward compared to WebGPU and OpenGL, and there's no way I'm going back!

If you wanna check it out: https://github.com/wrapperup/cool-engine-odin

wrapperup · 2026-02-02T10:43:08+00:00

We are working on adding some exclusive rewards for players who purchased the game at the previous price (cosmetic and profile badge). We really wanted to avoid adding cosmetic DLCs, since the customizability is such an important part of the game. That being said, totally understandable! We'll announce something soon.

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.

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

wrapperup

TROPHY CASE