
The Odin Programming Language - gingerBill
https://odin-lang.org/
======
jitl
Odin seems rather similar to Zig: [https://ziglang.org/](https://ziglang.org/)

It would be interesting to hear from anyone who has spent time in both about
the differences in experience.

It’s a trend of “Better C than C” languages that don’t go as far as Rust or
C++ in terms of either complexity (or safety) but are more opinionated and
modern than C. I think Nim can squeeze into this category, too, but maybe not?
Nim is confusing to me.

Jon Blow is also working on one of these, but it isn’t released yet:
[https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md](https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md)

~~~
rehemiau
Jonathan Blow's language is the most interesting from these three for me
because it will have nice metaprogramming features. The document you linked to
seems slightly outdated. One of the beta testers has published some more up to
date videos with his language introduction and initial experience:
[https://youtube.com/watch?v=i1vbvikDiI8&index=1&list=PLhEuCy...](https://youtube.com/watch?v=i1vbvikDiI8&index=1&list=PLhEuCycbde-
vyFoSBJbdKjw-AVTdQRE5g)

~~~
gingerBill
Personally, I agree with Jon in that he is not too bothered about being the
"winner" with regarding to his language. He wants a tool that can help him
actually solve problems he has. And he wants to make sure that his tool is
good before releasing it to the public. Releasing a product before it is done
is can of worms in itself, not to mention the problems related to open source
software itself. So it is entirely respectable for why Jon has not been as
opened up his language to the public yet.

I created Odin for the very same reason that I wanted a tool that made me more
productive and helped me solve the problems that I actually have. Even if Odin
only benefited myself, I would class that as a success, but it has been
helping so many people create amazing things.

~~~
andyroid
> Releasing a product before it is done is can of worms in itself

Perhaps, but a programming language which is released when “done” is
essentially dead on arrival. I’d guess the people who created amazing things
with Odin helped the language move forward, right? Nothing wrong with keeping
something to oneself, but promising for a long time to move something into an
open source model with no set date.. I’ve rarely seen that end well. Hope I’m
proved wrong though!

------
_bxg1
Whenever I see a language like this (niche and new yet more than a toy,
minimal ecosystem/tooling support, and evolutionary - not revolutionary -
improvements over a much more widely-used language), I have to wonder, who's
actually using these languages, and in what contexts? Where does the build
complexity/hiring difficulty/lack of tooling tradeoff make sense for the
advantages that one of these languages offers in return?

I'm genuinely asking; any anecdotes out there?

~~~
lang_throw_away
throwaway because I don't want to DOX myself

I'm working with language development where we're deploying a custom language
built with another custom language.

>who's actually using these languages, and in what contexts?

Compare it to using C in 1970 or Ruby in 1995. It's people who have a real
problem they're trying to solve for which existing tooling and widely used
languages are a poor fit - as well as people who genuinely enjoy developing
their own PLs that have their own ways of doing things.

>Where does the build complexity/hiring difficulty/lack of tooling tradeoff
make sense

With VC money, anything is possible...

>build complexity

Fairly nil. Contemporary build systems are language agnostic, and the steps to
make one that functions good enough are well known and can be thrown together
in a week or so. Not to mention it's become increasingly common for "widely
used" PLs to fallback on things like python scripts to handle builds.

>hiring difficulty

It's actually a fantastic way to weed people out and find good candidates. In
my (limited) experience, people willing and able to learn a new language (or
have a few under their belt) are generally the exact kinds of people you want
to hire anyway. Code switching between languages on a daily basis is a
fantastic skill, and leads to good developers and mindshare, helps create a
diverse technical background.

>lack of tooling

This is a legit problem, and one that a lot of folks stumble on. But luckily
building tooling is a great way to dogfood your language - and it's never been
easier to integrate with various tool frameworks via standard protocols.

But that said - every company just getting off the ground lacks tooling. For
language devs it's a language server, debugger, disassembler, and what have
you. For your bootstrapped startup it's build systems/procedures and code
review, ERPs and CRMs, etc. Building your own tooling is a part of the growth
of a business, tech or otherwise, it's just that when you work on a custom
language you have to build some different tools than a SaaS might.

I'll throw one more in though that's the biggest hurdle - wheel reinvention.
Stuff you take for granted in any language or have great packages for are the
biggest blockers to being productive. But you do the ROI math and decide if it
makes sense, so hopefully your lang has good FFI.

Also worth mentioning - if you're working in an esoteric language with heavy
contribution by your own team, you're probably doing it because you have a lot
of work that looks nothing like putting together a CRUD app or developing a
backend for your latest API for your SaaS idea.

~~~
_bxg1
> Compare it to using C in 1970 or Ruby in 1995

That's not the category I'm talking about, though. C (and I believe Ruby) was
a major shift from what came before. Those two are better compared to Clojure
or Go: dramatically different value-propositions that can make it worth the
time and effort to take a chance on a new, green technology. What I'm talking
about is languages that are "like X but with improvements to Y and Z".

~~~
aidenn0
I'm not sure about this. Algol 60 was a strong influence on most of the
programming languages from around this time.

Algol 60 had a number of obvious deficiencies, which needed to be addressed.
Both Algol 68 and CPL were designed to fix these issues, but had a level of
complexity that made them impractical to implement.

Pascal, which Predates C slightly, grew out of of Wirth's much simpler
(compared to Algol 68) set of changes to Algol 60.

The CPL people were having trouble with implementation, so Richards created a
stripped down version (BCPL). Thompson apparently didn't have access to the
full specification, but samples of it greatly informed the the design of B,
which eventually begat C. Apparently the "killer-feature" of C over B at the
beginning was byte-addressing, which is arguably no more or less niche than
what any of these new languages claim.

------
Nveterate
Nim, Zig, Jai, Odin, Beef

I wonder if a large company will throw into this royal of small and productive
system languages. It seems like Nim, Zig/Odin, and presumably Jai all fit into
their corners well. Someone with funds to generate tooling and combine the
static structure of Zig, the productivity of coding in Nim. I think these
language have all shown the potential for a great new language in this space.

~~~
toxik
I wonder why this type of language is so attractive to bike shed. Just the
right balance of complexity and usefulness perhaps?

~~~
jessermeyer
I think it's a mistake to think that in 10,000 years C will remain the golden
standard for a language that still is reasonably close to the hardware.

~~~
lang_throw_away
It's no longer close to the hardware

~~~
jessermeyer
Not necessarily contrary to my point.

------
bsldld
There is one more programming language that "loves C's efficiency for running
code." Not tried it myself, but anyone interested can have a look at:
[https://github.com/crystal-lang/crystal](https://github.com/crystal-
lang/crystal)

------
kornish
Not to be confused with Oden ([http://oden-lang.github.io/](http://oden-
lang.github.io/)), a functional language which compiled to Go. May it rest in
Valhalla!

------
grumpy8
Such a great landing page, clear examples and documentation. Good job!

By the way, there seems to be a css bug in the FAQ/quote section (The text
shows dark grey on a dark grey background)

~~~
gingerBill
Thank you.

I have fixed the css bug now.

------
SiempreViernes
With that name I expected a esolang build around the idea of everything being
somehow globally accessible, why else name it after the all seeing god?

~~~
gingerBill
Odin was originally the code name for this project, as names are not something
to worry about when developing. However, people liked the name of the language
so it has stuck.

Most of my internal projects are usually named after a mythological figure
before I give it a finalized name. It just makes me stop worrying about it and
get on with solving the problems at hand.

------
jug
Positively surprised by such an early language supporting multiple platforms
already, having a clear Getting Started guide and FAQ, language spec and
examples. Even aware about the Visual Studio Command Prompt in Windows despite
supporting *nix — what is this!

~~~
gingerBill
I commonly develop on Windows first, and thus support Windows as the main
platform. My general philosophy is if it works on Windows, porting to _nix is
usually pretty simple.

One thing that did take some time was getting System V ABI support for the
Odin compiler so that _nix platforms could support C-ABI 100%.

As for VCVARSALL.BAT, there is work currently trying to remove the requirement
for it once the compiler is built on Windows. However, Microsoft being what it
is, it's quite annoying to get it working on everyone's machine correctly.

------
jaked89
We need less languages, more IDEs.

------
typ
Looks promising and I haven't found an obvious pitfall (designs that I don't
like) except the coupling with LLVM.

I wonder if there is any feature that makes it unable to be translated to
efficient C and therefore preventing it from bootstrapping with a C backend
like Nim and V. I'll look forward to the self-hosting compiler.

------
azhenley
Any comment on how Odin would work as a target for a compiler? I have a toy
compiler project that I’m exploring different languages to compile to. So far
I’ve tested compiling to C, Go, Zig, and Python.

------
shdh
My problem with most of these new languages (Zig, Odin, V, Nim, etc.) is that
they lack an ecosystem.

Lots of niceties don't exist yet.

~~~
pasttense01
And that's one of the reasons they are posted about here: to help find
developers who will work on the ecosystem.

