Odin 1.0 Announcement
youtube.com
youtube.com
Love the books in the background, and the whole video.
It is also nice that Odin takes the batteries included approach.
How well it would fair in the mainstream remains to be seen.
Rust is shockingly good at being a general purpose language, but that's in the face of the strict semantics of the language and approach to memory. There became a comparison against Go because Go offers strong performance and a complete opposite memory-management experience (in having a GC that largely solves it for you.) Odin sits between these two levels of friction, leaning far more on the Go side of things. There are goodies in Odin which make memory management much breezier than other manual languages, but I'll admit it is still a task you are expected to complete.
So that's the story on the memory-management effort. That aside, I'd say Odin is best for interactive applications where a GC is not an option. Although at this point it comes out of my hands so easily that I'd probably write Odin in some situations where it'd be less optimal, and it'd be fun so why not?
Go really only took off thanks to Docker and Kubernetes, and even if it would be capable, there is hardly an ecosystem there.
Rust could be there, but there is really only Bevy, and several companies have tried it and pivoted to something else due to compile times hindering fast prototyping workflows.
Odin was created at a games company, JangaFX, and has already a few products using it.
Also Odin batteries include what you need to start coding a game right away, https://pkg.odin-lang.org/vendor
And just to clarify, personally, I would not describe JangaFX as a game company myself (as you pointed out, they aren't in the game business per se, but the visual effects business) - I'm just trying to clarify why the claim isn't completely outlandish.
A caterer that only caters to oil camps isn't suddenly in the oil business, for example. To take an easier to understand example.
Or my brother in law runs a company that does CNC machining and sells to Airbus. He's not suddenly an aircraft manufacturer, even though his parts make it onto planes.
That may sound like "Q:why buy this truck? A:Cos it has a nice oil filter" but it marketed as a language "[for the] joy of programming".
Perhaps the goal is to get more people into programming following the same playbook as the scripting wars we had in the 2000s. Or it's part of a larger trend to get mind-share away from c.
So for any sort of visual engine development (game engines being the most obvious, but also applications like blender or the JangaFx suite which is the main user of Odin), it is great. What you need is just there ready to go.
The language design itself is very much oriented around appealing to people who do this sort of work.
Other than there isn't much to the language really. It lacks a "big idea" feature like Rust's lifetimes or Zig's comptime. The closest thing to a "big idea" is the rejection of package managers but that's not really part of the language.
It's pleasant to use and compiles fast. Hard to complain.
https://www.swift.org/install/linux/
See:
"A series of small programs/tasks to compare C++, Go, Zig, Odin, D, Janet, Swift, Nim and C# to see which I like the most"
EDIT: Actually Typescript is more distracting than Swift. I could spend days toying with the type-checker to make the program sturdier against one change or another.
Semantically it's quite C-like, but it's got some nice modern features like a real module system (Odin calls it packages), a project-aware compiler (no build system needed, just run "odin build ." in your project root), fast compile times, and some nice quality of life stuff (good string type, good maths library, built in array maths, some nice built in stuff for memory management). It's also fast. Like in the same ballpark as C, C++ or Rust.
It's basically a modern C replacement.
It has naturally the influences that came via Oberon-2.
Odin is a pretty neat language, I should play more with it. There's nothing outright wrong with it I can think of. Some things I would have done slightly different but they're all nitpicks (mainly having the context be a thread local so #contextless wouldn't be necessary).
Another common question I’ve gotten a few times is why the `context` is passed as an implicit pointer argument to a procedure, and not something like a thread local variable stack? The rationale being that there would not need to be a calling convention difference for `context`. Unfortunately through a lot of experimentation and thought, there are a few reasons why it is implemented the way it is:
* Easier to manage across LIB/DLL boundaries than trying to use a single thread-local stack
* Easier management of recovery from crashes where the context might be hard to figure out.
* Using the existing stack makes stack management easier already, you don’t need to have a separate allocator for that stack
* Some platforms do not thread-local variables (e.g. freestanding targets)
* Works better with async/fiber based things, which would then require a fiber-local stack instead of a thread-local one
* Prevent back-propagation, which would be trivial with a global/thread-local stack
Odin’s context also has copy-on-write semantics. This is done for two reasons: to keep things local, and prevent back-propagation of “bad” data from an third-party library (be it malicious or just buggy). So not having an easily accessible stack of context values makes it harder for this back-propagation to happen.
shame that HN can't meet the moderation quality bar set by wikipedia
The random ginger dude is the creator of Odin.
I do think the guy's politics suck, but I also think his language's wiki page was probably targeted for it.
What politics?
I've been in the Odin Discord for 4 years, talked to GB a lot. He literally never talks about politics. On Discord (where one of the channels is basically politics 24/7), on X, nowhere.
https://katamari64.se/posts/2026/odin-wikipedia/
a little over the etiquette line for HN, the lack of joke comments here is awesome and i shouldn't be part of lowering our collective brows
Any one of those things you could ignore, but all of them together and its starting to be weird.
Again, any one of those things on it's own is not a smoking gun, and many of these features and syntax are becoming standard in modern languages. But the fact that SO MANY of Odin's features and even it's marketing strategy seems to be copying Jon Blow is weird to me. You can still go watch Jon's videos demoing early Jai from 11 years ago...and if you check the comments you'll see a familiar ginger face, so there's no doubt Bill saw those videos when they came out, and began developing Odin AFTER he saw Jai.
If he was simply inspired by Jon that's fine, there's nothing wrong with more well-thought out programming languages in the world. But when you copy a lot of the language, copy the announcement to the announcement video, copy the announcement video, and also plan to release at the exact same time as Jai, while largely denying that Jai had any influence of your language, red flags will go off for anyone that's paying attention.
Both Odin and Zig were inspired by Jai. Both creators were in the "Handmade" community and inspired.
That being said, a ton of these concepts existed in many languages that pre-date the developement of Jai by a very large margin.
> using
Literally in C++. Common Lisp has ":use" for packages/namespaces and "with-slots" for structs. Pascal has "with". A bunch of others too.
> defer
This came from Go.
> the context system
Jonathan Blow talked about where he got this, basically using obscure SML compilers in the 90's. Jon probably got this from MLKit. This is also how some Lisps did arenas in like the 70's... Ada also has a similar feature.
> The entire concept of Odin seems to be taken from Jai. They're both aiming to be C/C++ replacements "for the joy of programming"
Except D, Nim and Haxe are probably the actual precursors.
According to Jon the biggest feature of Jai is it's macros which are basically taken from Common Lisp although languages like Haxe, D, Rust, Nim and probably others also allow execution of any arbitrary code at compile time. At a recent LambdaConf he also talked about what he called a "plugin" system for the Jai compiler which kind of sounds like how OCaml or Haskell do macros/templates.
But Odin famously eschews macros. There's a few built-in features that do things at compile time but you can't just execute any code at compile time.
> began developing Odin AFTER he saw Jai
Jon (and Casey's) videos inspired the whole "Handmade" community, for better or worse. Both Bill (Odin) and Andrew Kelley (Zig) started their respective projects because of it. Both "took" ideas from Jai. Except none of those ideas are unique. There's literally nothing in Jai another language doesn't have. Even the syntax "name :: type" seems to come from Haskell type declarations, although :: is also used for types in Fortran and it's used in Backus-Naur form.
Anyhow in the end Jon's the one who just took a bunch of pre-existing functional language features, added it to a C-like language and acted like he reinvented the wheel. He didn't.
And finally, the "joy of programming" comes from Ruby's creator Matz.
> any one of those things on it's own is not a smoking gun, and many of these features and syntax are becoming standard in modern languages. But the fact that SO MANY of Odin's features and even it's marketing strategy seems to be copying Jon Blow is weird to me.
Why did you type all those paragraphs quoting me but happen to gloss over the one that already takes your entire comment into account? I never claimed that Jon invented any of these things. My point stands regardless, the way Ginger Bill has moved regarding Jai has been weird, and this most recent announcement confirms it for me. Its a vibe thing and if you're gonna "um akshually' me about where this or that language feature originated from, then you're missing the point.
Because everyone is inspired by everyone in programming language design but Jon Blow is the only one weird about it, talking about suing people on stream for features he himself took from others...
See [1] where Bill discusses the influences and where they've diverged longer-form.
Debatably, Odin's limited success, is due to Jai not being available to more of the public.
Jai, on the other hand, arguably appeals to the same groups and circles as those that are or might be attracted to Odin. That even appears to go for their creators, where similar demographics of fans would likely choose Jonathan Blow.
Except that Odin has been "released" and has been used to ship software for years now. Regardless of Bill's inspirations for his language, I can write code with Odin right now, and that's a huge benefit compared to waiting for Blow to finally be in the mood to release Jai.
I guess a gamedev niche language can fly with these restrictions, but for a new general purpose langauge these are a must have.
* The Data-Oriented Language for Sane Software Development.
* Odin is the C alternative for the Joy of Programming.
* Simplicity, High Performance, For Modern Systems
If you don't see value in these points, you are not part of the target audience.
What does this mean? What makes it more Data-Oriented than Go? What is sane development? What is insane development?
>Simplicity
What is simplicity in its case?
For example one can argue that borrow checker in Rust is "simplicity" (even if you have to master it) but at the same time you can say that BC is complexity.
Similar examples can be outlined for Go or any other language.
Yes, I do not see value in knowing someone likes this language. I see value in technical features and examples showing how those features address common pain points in programming.
[1] https://en.wikipedia.org/wiki/Odin_(firmware_flashing_softwa...