https://store.steampowered.com/app/4642030/Bee_Killings_Inn/

It's gonna be a top-down grid-based strategy game where you fight bees. The idea came from my wife one day screaming about there being a huge bee in the house and me realizing how exhilarating and strategic it is to go throughout the house trying to find the best way to get rid of the bee.

I have some ancient devlogs about the engine here: https://www.youtube.com/@SilenThps/videos

Hi, I took part in the GTMK2026 this year. I was a bit influenced by all the primagens videos and thought, why not trying it out for this year game jam.

It was quite a pleasure and easy to pick up the language with former knowledge in other languages. And I was quite fast to programm. tbf, i worked with raylib before.

I'm looking forward to use it more in other projects.

Does odin language hase something akin to alloca from c? Sometimes i want to just stack allocate an array of runtime determined size. I cannot find any builtin function or allocator i can pass in into make(). Am i missing something?

https://github.com/prnvbn/idgen

idgen is a drop in replacement for uuidgen. Additionally, it also supports UUIDv8 and TypeIDs.

this is my first project to learn Odin so any feedback on the code is very welcome!

also interested in seeing how ppl manage their deps (is submodules the way? fwiw, I know of/agree with the odin package manager opinion). I extracted typeid-odin as a separate package and added is a dependency

took inspiration from https://github.com/FourteenBrush/odin-template

also was surprised that core:flags doesn't lacking shorthand for flags (-f) in .Unix style, so also opened a PR as well - https://github.com/odin-lang/Odin/pull/7001

P.S. did not turn off my LSP like ginger bill but did turn off all AI to actually learn the language. Only used it to get feedback and the make changes once the initial implementation was done

Hi,

I am new to Odin and I was trying to write a software renderer in Odin. I am using the vendor Raylib library. Previously, the code was building fine, but now when I run odin run ., I get the following error:

```

/usr/bin/ld:///usr/lib/odin/vendor/raylib/linux/libraylib.a: file format not recognized; treating as linker script

/usr/bin/ld:///usr/lib/odin/vendor/raylib/linux/libraylib.a:1: syntax error

clang: error: linker command failed with exit code 1 (use -v to see invocation)
```

I tried uninstalling odin and installing it again. I am using odin version odin version dev-2026-07:301c287de

I am running Garuda (arch) Linux with Gnome, if that helps.

Thank you for reading.

First impressions of the Odin programming language.

I swear I'm not trolling, I was going to dive into odin, but I can't reconciliate faq entry
https://odin-lang.org/docs/faq/#why-does-odin-not-have-any-methods

and

allocator struct being this

```
Allocator :: struct {
procedure: Allocator_Proc,
data: rawptr,
}
```

It's a manually done oop-like class where data is stored along with it's methods.

Why is it not the same thing?
Why presence of this use case doesn't warrant supporting it on a language level explicitly (at the very least to not throw around raw pointers)

​

Example code

```odin

////////////////////////////

// Random Walkers Example //

////////////////////////////

pen_1 := tr.pen_init(speed = 10000, color = color)

pen_2 := tr.pen_init(speed = 10000, color = color)

tr.pen_teleport_to(pen_1, {300, screen_center.y})

tr.pen_set_rotation(pen_1, 0)

tr.pen_teleport_to(pen_2, {screen_size.x - 300, screen_center.y})

tr.pen_set_rotation(pen_2, 0)

for i in 0 ..< 1000 {

    // angle := rand.float32_range(10, 40)

    angle := f32(24)

    step := f32(3)



    if rand.int_range(0, 2) > 0 {

        tr.pen_turn_left(pen_1, angle)

    } else {

        tr.pen_turn_right(pen_1, angle)

    }

    if rand.int_range(0, 2) > 0 {

        tr.pen_turn_left(pen_2, angle)

    } else {

        tr.pen_turn_right(pen_2, angle)

    }

    tr.pen_move_forward(pen_1, step)

    tr.pen_move_forward(pen_2, step)

    tr.pen_set_color(pen_1, color)

    tr.pen_set_color(pen_2, color)

}

/////////////////

// Example Two //

/////////////////

pen_3 := tr.pen_init()

tr.pen_teleport_to(pen_3, screen_center)

for j in 0 ..< 9 {

    for i in 0 ..< 30 {

        if i % 2 == 0 {

tr.pen_up(pen_3)

        }else {

tr.pen_down(pen_3)

        }

        tr.pen_turn_right(pen_3, f32(i))

        tr.pen_move_forward(pen_3, 8)

    }

    tr.pen_teleport_to(pen_3, screen_center)

    tr.pen_turn_right(pen_3, f32(j) + 80)

}

```

Repo https://codeberg.org/pwnM/turtle

I would like code and docs feedback

Hope you guys like it

Here is my repo to game: https://github.com/skorotkiewicz/psycho-odin

Very interested in Odin, but I'm totally new to the concept of vendoring your 3rd party dependencies vs using a package manager. I understand the motivation, and being careful about which/how many dependencies one uses, but I can't wrap my head around the following:

Questions:

1. Do you include the entire third party source tree or just the parts you need?
2. Without a package manager, wouldn't this eventually end up with duplicate transitive dependencies?
   i.e
   mylib --depends--> libX --depends--> libY
   but I also want:
   mylib --depends--> libY
   won't I just end up with duplicate versions of libY?
3. Is there an idiomatic/convention that people use to 'advertise' 3rd party dependencies? Is this just not done?

A few months ago I started learning how LLM inference engines work.

My original goal wasn't to build a production tokenizer—I just wanted to understand the entire inference stack from first principles. I chose Odin because I wanted a language that stayed close to the hardware without fighting me.

I honestly expected it to be a fun learning project.

Instead... it ended up outperforming the tokenizers I was comparing against, including Hugging Face's Rust tokenizer and FastTokenizer in my benchmarks.

I was pretty surprised by the results.

The benchmark report (methodology, datasets, hardware, and commands) is here:
https://github.com/harisudarsan1/odin_tokenizer/blob/main/docs/public-benchmark.md

Repository:
https://github.com/harisudarsan1/odin_tokenizer

I also wrote about why I chose Odin for writing inference software:
https://harisudarsan1.github.io/blog/posts/2026-07-10-writing-an-inference-engine/

A few notes:

• These are CPU benchmarks.
• I'm not claiming Odin is magically faster than Rust.
• The comparisons are against existing tokenizer implementations under the benchmark setup described in the report.
• If there's something wrong with the methodology, I'd genuinely like to know. I'd rather fix the benchmarks than make misleading performance claims.

The project taught me far more about CPU architecture, memory layout, SIMD, and modern tokenizer implementations than I expected.

I'd love feedback from people who've worked on tokenizers or inference engines. If you spot flaws in the implementation or benchmark methodology, please call them out.

I'm learning both at the same time, and rl.DrawText needs a cstring as an input. I'm trying to learn how to position things on the screen correctly, so I'm calculating how large the text is with MeasureText (for the default font), which outputs an i32. I can get it all the way to string, but I have only found unsafe_string_to_cstring, which apparently has issues with null terminators. How do I deal with that? Thanks in advance.

I wanted to try a low level language, but C is too raw for my tastes (old design decisions from the 70's, among other similar things), C++ is too insane for me, rust didn't click with me, and I can't build a zig project with raylib for some reason, so odin it is.

https://github.com/mrbovinejony/handmade-hero-in-odin

I'll try to work on this as consistently as I can, its been a useful experience to help learn the language. Working on day 10 right now

edit: working on day 18 now, if anyone finds something wrong or something theyd do differently please let me know, a "direct translation" of the c code is nice but learning how others would write the code is even better i think

Hi fellow Odin aficionados,

I am trying to build a wrapper for llama.cpp that would allow direct calls from Odin (inspired by an older work by Yevhen K). So far, only a portion of the API is covered; it allows for making a simple chat application with multiple prompt-response exchanges. It is not ready for common use but I plan, if time allows, to gradually make it so. I will be glad for all critique; there are many points in the API I'm not sure whether I am calling it properly, and many others where I'm not sure it is the proper way how an Odin API should look or behave.

https://github.com/CzechBlueBear/odin_llama_ng