Odin Programming Language Documentation

https://odin-lang.org/docs
Admin
The Odin Programming Language is a data-oriented language for sane software development. This...
Tokens:75,922
Snippets:928
Trust Score:8.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Basic Threads in Odin

Source: https://odin-lang.org/docs/demo

Demonstrates the creation, starting, and management of basic threads in Odin. Each thread executes a procedure and prints its progress.

```odin
{
		fmt.println("\n## Basic Threads")
		worker_proc :: proc(t: ^thread.Thread) {
			for iteration in 1..=5 {
				fmt.printf("Thread %d is on iteration %d\n", t.user_index, iteration)
				fmt.printf("`%s`: iteration %d\n", prefix_table[t.user_index], iteration)
				time.sleep(1 * time.Millisecond)
			}
		}

		threads := make([dynamic]^thread.Thread, 0, len(prefix_table))
		defer delete(threads)

		for _ in prefix_table {
			if t := thread.create(worker_proc); t != nil {
				t.init_context = context
				t.user_index = len(threads)
				append(&threads, t)
				thread.start(t)
			}
		}

		for len(threads) > 0 {
			for i := 0; i < len(threads); /**/ {
				if t := threads[i]; thread.is_done(t) {
					fmt.printf("Thread %d is done\n", t.user_index)
					thread.destroy(t)

					ordered_remove(&threads, i)
				} else {
					i += 1
				}
			}
		}
	}
```

--------------------------------

### Check LLVM Configuration

Source: https://odin-lang.org/docs/install

Verify LLVM installation and configuration by checking the output of `llvm-config`.

```bash
llvm-config --version
```

--------------------------------

### SoA Dynamic Array Example

Source: https://odin-lang.org/docs/overview

Shows how to use and append elements to a Structure of Arrays (SoA) dynamic array. Demonstrates append_soa and slice operations.

```odin
d: #soa[dynamic]Vector3

append_soa(&d, Vector3{1, 2, 3}, Vector3{4, 5, 9}, Vector3{-4, -4, 3})
fmt.println(d)
fmt.println(len(d))
fmt.println(cap(d))
fmt.println(d[:])

```

--------------------------------

### Install Xcode Command Line Tools on macOS

Source: https://odin-lang.org/docs/install

Installs the necessary Xcode command-line tools for development on macOS. If the command is not found, you may need to install Xcode from the App Store first.

```shell
xcode-select --install
```

--------------------------------

### Foreign System Interaction (Windows)

Source: https://odin-lang.org/docs/demo

Demonstrates interfacing with the Windows kernel32.lib using Odin's foreign system. Includes examples of default calling conventions and link name attributes.

```odin
when ODIN_OS == .Windows {
	foreign import kernel32 "system:kernel32.lib"
}

foreign_system :: proc() {
	fmt.println("\n#foreign system")
	when ODIN_OS == .Windows {
		foreign kernel32 {
			ExitProcess :: proc "stdcall" (exit_code: u32) ---
		}

		@(default_calling_convention = "std")
		foreign kernel32 {
			@(link_name="GetLastError") get_last_error :: proc() -> i32 ---
		}

		@(default_calling_convention = "std")
		@(link_prefix = "Get")
		foreign kernel32 {
			LastError :: proc() -> i32 ---
		}
	}
}
```

--------------------------------

### Install Clang on Debian/Ubuntu

Source: https://odin-lang.org/docs/install

Installs the Clang compiler, which is used for linking Odin programs on Debian-based Linux distributions.

```shell
apt install clang
```

--------------------------------

### Arbitrary Precision Mathematics Setup

Source: https://odin-lang.org/docs/demo

Initializes variables for arbitrary precision mathematics using the 'math/big' package. This includes setting up big integers and parameters for prime generation.

```odin
arbitrary_precision_mathematics :: proc() {
	fmt.println("\n# core:math/big")

	print_bigint :: proc(name: string, a: ^big.Int, base := i8(10), print_name := true, newline := true, print_extra_info := true) {
		big.assert_if_nil(a)

		as, err := big.itoa(a, base)
		defer delete(as)

		cb := big.internal_count_bits(a)
		if print_name {
			fmt.printf(name)
		}
		if err != nil {
			fmt.printf(" (Error: %v) ", err)
		}
		fmt.printf(as)
		if print_extra_info {
			fmt.printf(" (base: %v, bits: %v, digits: %v)", base, cb, a.used)
		}
		if newline {
			fmt.println()
		}
	}

	a, b, c, d, e, f, res := &big.Int{}, &big.Int{}, &big.Int{}, &big.Int{}, &big.Int{}, &big.Int{}, &big.Int{}
	defer big.destroy(a, b, c, d, e, f, res)

	// How many bits should the random prime be?
	bits   := 64
	// Number of Rabin-Miller trials, -1 for automatic.
	trials := -1

	// Default prime generation flags
	flags := big.Primality_Flags{}
}
```

--------------------------------

### Install WASM Linker (lld)

Source: https://odin-lang.org/docs/install

Install the 'lld' package via Homebrew, which includes 'wasm-ld' required for WASM compilation.

```bash
brew install lld
```

--------------------------------

### Install Clang on Fedora

Source: https://odin-lang.org/docs/install

Installs the Clang compiler, which is used for linking Odin programs on Fedora Linux.

```shell
dnf install clang
```

--------------------------------

### Setting Compile-Time Options for Odin Tests

Source: https://odin-lang.org/docs/testing

Demonstrates how to set Odin compile-time options when running tests. This example shows how to enable short logs by defining ODIN_TEST_SHORT_LOGS.

```odin
odin test . -define:ODIN_TEST_SHORT_LOGS=true

```

--------------------------------

### Array Programming Example

Source: https://odin-lang.org/docs/faq

Demonstrates Odin's array programming capabilities for element-wise operations and swizzling. This syntax allows for concise vector and matrix manipulations.

```odin
a, b: [4]f32;
c := a * b
i := a.x * b.y
v := swizzle(a, 1, 2, 0)
```

--------------------------------

### Multi-Package Testing Setup

Source: https://odin-lang.org/docs/testing

Configure tests to run across multiple packages by placing a `tests.odin` file at the root of the test directory. This file should import all necessary sub-packages.

```odin
package tests

@require import "foo"
@require import "bar"
@require import "gadgets"
@require import "widgets"

```

--------------------------------

### Matrix Flatten Example

Source: https://odin-lang.org/docs/demo

Demonstrates how to flatten a matrix into a column-major ordered array. This is useful for converting matrix data into a linear format for processing or storage.

```odin
m := matrix[2, 2]f32{
		x0, x1,
		y0, y1,
	}
	array: [4]f32 = matrix_flatten(m)
	assert(array == {x0, y0, x1, y1})
```

--------------------------------

### Test Log Output Example

Source: https://odin-lang.org/docs/testing

Example of the log output generated by the test runner for an info-level message.

```text
[INFO ] --- [2024-06-10 18:01:24] [tests.odin:8:my_test()] Hellope!

```

--------------------------------

### SoA Struct Slice Example

Source: https://odin-lang.org/docs/overview

Demonstrates creating and manipulating a Structure of Arrays (SoA) slice from a fixed-length SoA array. Includes slicing operations.

```odin
Vector3 :: struct {x: i8, y: i16, z: f32}

N :: 3
v: #soa[N]Vector3
v[0].x = 1
v[0].y = 4
v[0].z = 9

s: #soa[]Vector3
s = v[:]
assert(len(s) == N)
fmt.println(s)
fmt.println(s[0].x)

a := s[1:2]
assert(len(a) == 1)
fmt.println(a)

```

--------------------------------

### Thread Pool in Odin

Source: https://odin-lang.org/docs/demo

Illustrates the use of a thread pool for managing concurrent tasks. It shows how to initialize a pool, add tasks, start the pool, and terminate a specific thread.

```odin
{
		fmt.println("\n## Thread Pool")
		task_proc :: proc(t: thread.Task) {
			index := t.user_index % len(prefix_table)
			for iteration in 1..=5 {
				for !did_acquire(&print_mutex) { thread.yield() } // Allow one thread to print at a time.

				fmt.printf("Worker Task %d is on iteration %d\n", t.user_index, iteration)
				fmt.printf("`%s`: iteration %d\n", prefix_table[index], iteration)

				print_mutex = false

				time.sleep(1 * time.Millisecond)
			}
		}

		N :: 3

		pool: thread.Pool
		thread.pool_init(&pool, allocator=context.allocator, thread_count=N)
		defer thread.pool_destroy(&pool)


		for i in 0..<30 {
			// be mindful of the allocator used for tasks. The allocator needs to be thread safe, or be owned by the task for exclusive use
			thread.pool_add_task(&pool, allocator=context.allocator, procedure=task_proc, data=nil, user_index=i)
		}

		thread.pool_start(&pool)

		{
			// Wait a moment before we cancel a thread
			time.sleep(5 * time.Millisecond)

			// Allow one thread to print at a time.
			for !did_acquire(&print_mutex) { thread.yield() }

			thread.terminate(pool.threads[N - 1], 0)
			fmt.println("Canceled last thread")
			print_mutex = false
		}

		thread.pool_finish(&pool)
	}
```

--------------------------------

### Quaternion Operations and Types

Source: https://odin-lang.org/docs/demo

Provides examples of quaternion arithmetic, including multiplication, division, addition, and subtraction. Shows the declaration of different quaternion types (f32 and f64).

```odin
q := 1 + 2i + 3j + 4k
r := quaternion(real=5, imag=6, jmag=7, kmag=8)
t := q * r
fmt.printf("(%v) * (%v) = %v\n", q, r, t)
v := q / r
fmt.printf("(%v) / (%v) = %v\n", q, r, v)
u := q + r
fmt.printf("(%v) + (%v) = %v\n", q, r, u)
s := q - r
fmt.printf("(%v) - (%v) = %v\n", q, r, s)
```

```odin
q128: quaternion128 // 4xf32
q256: quaternion256 // 4xf64
q128 = quaternion(w=1, x=0, y=0, z=0)
q256 = 1 // quaternion(x=0, y=0, z=0, w=1)
```

--------------------------------

### Calculating Bit Set Cardinality

Source: https://odin-lang.org/docs/overview

Demonstrates how to get the number of elements (cardinality) in a bit set using the 'card' procedure and asserts the result.

```odin
x: Direction_Set
x = {.North, .West}
count := card(x)
assert(count == 2)
```

--------------------------------

### Polymorphic Hash Table Implementation

Source: https://odin-lang.org/docs/demo

Demonstrates a polymorphic hash table using Odin's type specialization. It includes structures for slots and tables, and procedures for allocation, expansion, insertion, and finding elements. Note: This is a basic example and not recommended for production.

```odin
Table_Slot :: struct($Key, $Value: typeid) {
	occupied: bool,
	hash:     u32,
	key:      Key,
	value:    Value,
}
TABLE_SIZE_MIN :: 32
Table :: struct($Key, $Value: typeid) {
	count:     int,
	allocator: mem.Allocator,
	slots:     []Table_Slot(Key, Value),
}

// Only allow types that are specializations of a (polymorphic) slice
make_slice :: proc($T: typeid/[]$E, len: int) -> T {
	return make(T, len)
}

// Only allow types that are specializations of `Table`
allocate :: proc(table: ^$T/Table, capacity: int) {
	c := context
	if table.allocator.procedure != nil {
		c.allocator = table.allocator
	}
	context = c

	table.slots = make_slice(type_of(table.slots), max(capacity, TABLE_SIZE_MIN))
}

expand :: proc(table: ^$T/Table) {
	c := context
	if table.allocator.procedure != nil {
		c.allocator = table.allocator
	}
	context = c

	old_slots := table.slots
	defer delete(old_slots)

	cap := max(2*len(table.slots), TABLE_SIZE_MIN)
	allocate(table, cap)

	for s in old_slots {
		if s.occupied {
			put(table, s.key, s.value)
		}
	}
}

// Polymorphic determination of a polymorphic struct
// put :: proc(table: ^$T/Table, key: T.Key, value: T.Value) {
put :: proc(table: ^Table($Key, $Value), key: Key, value: Value) {
	hash := get_hash(key) // Ad-hoc method which would fail in a different scope
	index := find_index(table, key, hash)
	if index < 0 {
		if f64(table.count) >= 0.75*f64(len(table.slots)) {
			expand(table)
		}
		assert(table.count <= len(table.slots))

		index = int(hash % u32(len(table.slots)))

		for table.slots[index].occupied {
			if index += 1; index >= len(table.slots) {
				index = 0
			}
		}

		table.count += 1
	}

	slot := &table.slots[index]
	slot.occupied = true
	slot.hash     = hash
	slot.key      = key
	slot.value    = value
}


// find :: proc(table: ^$T/Table, key: T.Key) -> (T.Value, bool) {
find :: proc(table: ^Table($Key, $Value), key: Key) -> (Value, bool) {
	hash := get_hash(key)
	index := find_index(table, key, hash)
	if index < 0 {
		return Value{}, false
	}
	return table.slots[index].value, true
}

find_index :: proc(table: ^Table($Key, $Value), key: Key, hash: u32) -> int {
	if len(table.slots) <= 0 {
		return -1
	}

	index := int(hash % u32(len(table.slots)))
	for table.slots[index].occupied {
		if table.slots[index].hash == hash {
			if table.slots[index].key == key {
				return index
			}
		}

		if index += 1; index >= len(table.slots) {
			index = 0
		}
	}

	return -1
}

get_hash :: proc(s: string) -> u32 { // fnv32a
	h: u32 = 0x811c9dc5
	for i in 0..<len(s) {
		h = (h ~ u32(s[i])) * 0x01000193
	}
	return h
}


table: Table(string, int)

for i in 0..=36 { put(&table, "Hellope", i) }
for i in 0..=42 { put(&table, "World!",  i) }

found, _ := find(&table, "Hellope")
fmt.printf("`found` is %v\n", found)

found, _ = find(&table, "World!")
fmt.printf("`found` is %v\n", found)

// I would not personally design a hash table like this in production
// but this is a nice basic example
// A better approach would either use a `u64` or equivalent for the key
// and let the user specify the hashing function or make the user store
// the hashing procedure with the table

```

--------------------------------

### Odin Implicit Context Example

Source: https://odin-lang.org/docs/overview

Demonstrates how to access, modify, and use the implicit `context` variable within different scopes. Shows how changes to `context` in a nested scope do not affect the outer scope.

```odin
main :: proc() {
	c := context // copy the current scope's context

	context.user_index = 456
	{
		context.allocator = my_custom_allocator()
		context.user_index = 123
		supertramp() // the `context` for this scope is implicitly passed to `supertramp`
	}

	// `context` value is local to the scope it is in
	assert(context.user_index == 456)
}

supertramp :: proc() {
	c := context // this `context` is the same as the parent procedure that it was called from
	// From this example, context.user_index == 123
	// A context.allocator is assigned to the return value of `my_custom_allocator()`

	// The memory management procedure uses the `context.allocator` by default unless explicitly specified otherwise
	ptr := new(int)
	free(ptr)
}

```

--------------------------------

### Odin Test Runner Bad Free Example

Source: https://odin-lang.org/docs/testing

This output indicates a 'bad free' error, where memory was freed incorrectly. This could be a double free or an attempt to free unallocated memory.

```text
[WARN ] --- [2024-06-10 18:11:23] <        0B/        8B> <        8B> (    1/    1) :: tests.my_test
        +++ bad free        @ 0x7136A2600048 [tests.odin:10:my_test()]

```

--------------------------------

### Deferred Procedure Call Example

Source: https://odin-lang.org/docs/overview

Illustrates the use of the `deferred_none` attribute to execute a procedure (`baz`) after the calling scope of another procedure (`bar`) has exited. Shows the execution order.

```odin
baz :: proc() {
    fmt.println("In baz")
}

@(deferred_none=baz)
bar :: proc() {
    fmt.println("In bar")
}

foo :: proc() {
    fmt.println("Entered foo")
    bar()
    fmt.println("Leaving foo")
}
// Prints:
// Entered foo
// In bar
// Leaving foo
// In baz

```

--------------------------------

### Odin Map Container Calls: Length and Capacity

Source: https://odin-lang.org/docs/overview

Provides examples of using `len()` and `cap()` with Odin maps to get the number of used slots and the total capacity, respectively.

```odin
len(some_map)
cap(some_map)
```

--------------------------------

### Basic Program Structure and Arguments

Source: https://odin-lang.org/docs/demo

Illustrates how to access command-line arguments using `os.args`. This is useful for creating command-line tools that need to process input parameters.

```odin
package main

import "core:fmt"
import "core:os"

the_basics :: proc() {
	fmt.println("\n# the basics")

	{

		// os.args holds the path to the current executable and any arguments passed to it.
		if len(os.args) == 1 {
			fmt.printf("Hellope from %v.\n", os.args[0])
		} else if len(os.args) > 2 {
			fmt.printf("%v, %v! from %v.\n", os.args[1], os.args[2], os.args[0])
		}
	}
}

```

--------------------------------

### Get Source Code Location

Source: https://odin-lang.org/docs/overview

Use #location() to get the current source code location or #location(<entity>) to get the location of a variable or procedure declaration.

```odin
foo :: proc() {}

main :: proc() {
    n: int
    fmt.println(#location())
    fmt.println(#location(foo))
    fmt.println(#location(n))
}

```

--------------------------------

### Using the glfw Vendor Library

Source: https://odin-lang.org/docs/overview

This snippet shows how to initialize and use the glfw library for window creation and event handling in an Odin application. It includes setting up error and key callbacks, creating a window, and a basic event loop.

```odin
package main

import "base:runtime"
import "core:fmt"
import "vendor:glfw"

error_callback :: proc "c" (code: i32, desc: cstring) {
	context = runtime.default_context()
	fmt.println(desc, code)
}

key_callback :: proc "c" (window: glfw.WindowHandle, key, scancode, action, mods: i32) {
	if key == glfw.KEY_ESCAPE && action == glfw.PRESS {
		glfw.SetWindowShouldClose(window, glfw.TRUE)
	}
}

main :: proc() {
	glfw.SetErrorCallback(error_callback)

	if !glfw.Init() {
		panic("EXIT_FAILURE")
	}
	defer glfw.Terminate()

	glfw.WindowHint(glfw.CONTEXT_VERSION_MAJOR, 2)
	glfw.WindowHint(glfw.CONTEXT_VERSION_MINOR, 0)

	window := glfw.CreateWindow(640, 480, "Simple example", nil, nil)
	if window == nil {
		panic("EXIT_FAILURE")
	}	
	defer glfw.DestroyWindow(window)

	glfw.SetKeyCallback(window, key_callback)

	glfw.MakeContextCurrent(window)
	// ...
	glfw.SwapInterval(1)
	// ...

	for !glfw.WindowShouldClose(window) {
		// ...

		glfw.SwapBuffers(window)
		glfw.PollEvents()
	}
}

```

--------------------------------

### Get the address of a variable

Source: https://odin-lang.org/docs/overview

Uses the `&` operator to get the memory address of the variable `i` and assign it to the pointer `p`.

```odin
i := 123
p := &i
```

--------------------------------

### SOA Slices in Odin

Source: https://odin-lang.org/docs/demo

Demonstrates the creation and manipulation of SOA slices, including slicing and dynamic SOA slices with append.

```odin
Vector3 :: struct {x: i8, y: i16, z: f32}

N :: 3
v: #soa[N]Vector3
v[0].x = 1
v[0].y = 4
v[0].z = 9

s: #soa[]Vector3
s = v[:]
assert(len(s) == N)
fmt.println(s)
fmt.println(s[0].x)

a := s[1:2]
assert(len(a) == 1)
fmt.println(a)

d: #soa[dynamic]Vector3

append_soa(&d, Vector3{1, 2, 3}, Vector3{4, 5, 9}, Vector3{-4, -4, 3})
fmt.println(d)
fmt.println(len(d))
fmt.println(cap(d))
fmt.println(d[:])
```

--------------------------------

### Getting Slice Length

Source: https://odin-lang.org/docs/overview

Shows how to use the built-in `len` procedure to get the number of elements in a slice.

```odin
x: []int = ...
length_of_x := len(x)
```

--------------------------------

### Declaring and Initializing a 2x3 Matrix

Source: https://odin-lang.org/docs/demo

Shows how to declare a matrix of 2 rows and 3 columns with f32 elements and initialize it with values. Also demonstrates accessing a specific element.

```odin
m: matrix[2, 3]f32

m = matrix[2, 3]f32{
	1, 9, -13,
	20, 5, -6,
}

// Element types of integers, float, and complex numbers are supported by matrices.
// There is no support for booleans, quaternions, or any compound type.

// Indexing a matrix can be used with the matrix indexing syntax
// This mirrors other type usages: type on the left, usage on the right

elem := m[1, 2] // row 1, column 2
assert(elem == -6)
```

--------------------------------

### Procedure with Mutable Parameter Shadowing

Source: https://odin-lang.org/docs/overview

Demonstrates how to allow modification of an immutable parameter within a procedure using variable shadowing. Use `var := var` at the start of the procedure. Compile with `-vet` to avoid shadowing warnings.

```odin
sin_tau :: proc(angle_in_cycles: f64) -> f64 {
    angle_in_cycles := angle_in_cycles   // Allows `angle_in_cycles` to have its value changed
    
    TAU :: 2 * math.PI
    angle_in_cycles *= TAU
    return math.sin(angle_in_cycles)
}
assert(math.abs(sin_tau(0.25) - 1) <= 0.001)   // sin_tau(0.25) is approximately 1
assert(math.abs(sin_tau(0.75) - -1) <= 0.001)  // sin_tau(0.75) is approximately -1


```

--------------------------------

### SOA Zip and Unzip in Odin

Source: https://odin-lang.org/docs/demo

Illustrates how to zip multiple slices into an SOA slice and unzip an SOA slice back into individual slices.

```odin
x := []i32{1, 3, 9}
y := []f32{2, 4, 16}
z := []b32{true, false, true}

// produce an #soa slice the normal slices passed
s := soa_zip(a=x, b=y, c=z)

// iterate over the #soa slice
for v, i in s {
	fmt.println(v, i) // exactly the same as s[i]
	// NOTE: 'v' is NOT a temporary value but has a specialized addressing mode
	// which means that when accessing v.a etc, it does the correct transformation
	// internally:
	//         s[i].a === s.a[i]
	fmt.println(v.a, v.b, v.c)
}

// Recover the slices from the #soa slice
a, b, c := soa_unzip(s)
fmt.println(a, b, c)
```

--------------------------------

### Bit Set Initialization and Type Information

Source: https://odin-lang.org/docs/demo

Illustrates initializing bit sets with character ranges and integer ranges, and retrieving their type information. Includes basic set operations like addition and subtraction.

```odin
x: bit_set['A'..='Z']
#assert(size_of(x) == size_of(u32))
y: bit_set[0..=8; u16]
fmt.println(typeid_of(type_of(x))) // bit_set[A..=Z]
fmt.println(typeid_of(type_of(y))) // bit_set[0..=8; u16]

x += {'F'}
assert('F' in x)
x -= {'F'}
assert('F' not_in x)

y += {1, 4, 2}
assert(2 in y)
```

--------------------------------

### Install LLVM on macOS

Source: https://odin-lang.org/docs/install

Install LLVM using Homebrew on macOS. Supported versions are 14, 17, 18, 19, 20, and 21.

```bash
brew install llvm
```

--------------------------------

### Defer Statement Example

Source: https://odin-lang.org/docs/overview

A defer statement defers execution of a statement until the end of the current scope. This example shows variable modification and scope.

```odin
package main

import "core:fmt"

main :: proc() {
	x := 123
	defer fmt.println(x)
	{
		defer x = 4
		x = 2
	}
	fmt.println(x)

	x = 234
}

```

--------------------------------

### Get Branch Location in Defer Statement

Source: https://odin-lang.org/docs/overview

Use #branch_location within a defer statement to get the runtime source code location that triggered the defer. This can be a return statement or the end of a scope.

```odin
package main

import "base:runtime"
import "core:fmt"

find_exit :: proc(v: bool, exit: ^runtime.Source_Code_Location) {
	defer {
		exit ^= #branch_location
	}
	if v == true {
		return
	} else {
		return
	}
}

main :: proc() {
	result_true:  runtime.Source_Code_Location
	result_false: runtime.Source_Code_Location

	find_exit(true,  &result_true)
	find_exit(false, &result_false)

	fmt.println(result_true)  // prints line 11
	fmt.println(result_false) // prints line 13
}

```

--------------------------------

### Formatted Expectation Failure Log Output

Source: https://odin-lang.org/docs/testing

Example log output when a test fails using `testing.expectf` with a formatted message.

```text
[ERROR] --- [2024-06-15 07:18:03] [tests.odin:8:my_test()] Hellope! The value is: 32

```

--------------------------------

### Importing a Foreign C Library

Source: https://odin-lang.org/docs/overview

Demonstrates how to import a foreign system library, such as kernel32.lib, into Odin code.

```odin
foreign import kernel32 "system:kernel32.lib"
```

--------------------------------

### Odin Type Identification

Source: https://odin-lang.org/docs/overview

Shows how to get the type identifier of a boolean type and the type of an integer variable using `typeid_of` and `type_of`.

```odin
a := typeid_of(bool)
i: int = 123
b := typeid_of(type_of(i))
```

--------------------------------

### Convert Integer to String and Back

Source: https://odin-lang.org/docs/faq

Demonstrates how to convert an integer to its string representation and parse it back using the strconv package. The buffer for string conversion is pre-allocated.

```odin
package numbers_example

import "core:strconv"

main :: proc() {
    // We'll shortly overwrite the part of this array that we need,
    // so we use `---` to tell the compiler it doesn't have to be zero-initialized.
    buf: [64]u8 = ---

    // Format the integer to a string, using memory backed by `buf`.
    a := 4815162342
    s := strconv.itoa(buf[:], a)

    // Parse it back into an integer. We assume it's a valid base-10 representation here.
    // If you want to check it was parsed correctly or parse binary, octal or hexadecimal,
    // look at the `parse_*` procedures.
    b := strconv.atoi(s)

    assert(a == b)
}
```

--------------------------------

### Setting Error Callback with Context

Source: https://odin-lang.org/docs/overview

Example of setting an error callback for 'vendor:glfw' and explicitly setting the context within the callback.

```odin
error_callback :: proc "c" (code: i32, desc: cstring) {
	context = runtime.default_context() // set the current context
	fmt.println(desc, code) // fmt.* calls use the odin calling convention
}
gglfw.SetErrorCallback(error_callback)
```

--------------------------------

### Switch Statement with Variable Initialization

Source: https://odin-lang.org/docs/overview

A switch statement can start with an initializer. Cases are evaluated top-down, and only one case runs by default.

```odin
switch arch := ODIN_ARCH; arch {
case .i386, .wasm32, .arm32:
	fmt.println("32 bit")
case .amd64, .wasm64p32, .arm64, .riscv64:
	fmt.println("64 bit")
case .Unknown:
	fmt.println("Unknown architecture")
}

```

--------------------------------

### Basic For Loop in Odin

Source: https://odin-lang.org/docs/demo

Demonstrates a basic for loop with initialization, condition, and post-increment statements. Braces are always required.

```odin
for i := 0; i < 10; i += 1 {
	fmt.println(i)
}
```

--------------------------------

### Navigate to Odin Folder

Source: https://odin-lang.org/docs/install

Change the current directory to the cloned Odin repository folder.

```bash
cd Odin
```

--------------------------------

### Procedure Call with Named Arguments

Source: https://odin-lang.org/docs/overview

Demonstrates calling a procedure using named arguments for clarity, especially when procedures have many parameters or default values.

```odin
create_window :: proc(title: string, x, y: int, width, height: int, monitor: ^Monitor) -> (^Window, Window_Error) {...}

window, err := create_window(title="Hellope Title", monitor=nil, width=854, height=480, x=0, y=0)

```

--------------------------------

### Array of Structures (AoS) Example

Source: https://odin-lang.org/docs/overview

Defines and manipulates an Array of Structures (AoS) for Vector3 data. Demonstrates direct member access and assignment.

```odin
Vector3 :: struct {x, y, z: f32}

N :: 2
v_aos: [N]Vector3
v_aos[0].x = 1
v_aos[0].y = 4
v_aos[0].z = 9

fmt.println(len(v_aos))
fmt.println(v_aos[0])
fmt.println(v_aos[0].x)
fmt.println(&v_aos[0].x)

v_aos[1] = {0, 3, 4}
v_aos[1].x = 2
fmt.println(v_aos[1])
fmt.println(v_aos)

```

--------------------------------

### Using soa_zip to Create an SoA Slice

Source: https://odin-lang.org/docs/overview

Demonstrates using the `soa_zip` built-in procedure to combine multiple slices into a single Structure of Arrays (SoA) slice.

```odin
x := []i32{1, 3, 9}
y := []f32{2, 4, 16}
z := []b32{true, false, true}

// produce an #soa slice with the normal slices passed
s := soa_zip(a=x, b=y, c=z)

// iterate over the #soa slice
for v, i in s {
	fmt.println(v, i) // exactly the same as s[i]
	// NOTE: `v` is NOT a temporary value but has a specialized addressing mode
	// which means that when accessing v.a etc, it does the correct transformation
	// internally:
	//         s[i].a === s.a[i]
	fmt.println(v.a, v.b, v.c)
}

```

--------------------------------

### Implicit Type Conversion of Float Literal

Source: https://odin-lang.org/docs/overview

Shows an example where a float literal can be assigned to an integer variable if it can be represented without precision loss.

```odin
x: int = 1.0 // A float literal but it can be represented by an integer without precision loss
```

--------------------------------

### Built-in Quaternion Procedures

Source: https://odin-lang.org/docs/demo

Demonstrates the use of built-in procedures for quaternion operations such as getting real and imaginary parts, calculating the conjugate, and absolute value.

```odin
q := 1 + 2i + 3j + 4k
fmt.println("q =", q)
fmt.println("real(q) =", real(q))
fmt.println("imag(q) =", imag(q))
fmt.println("jmag(q) =", jmag(q))
fmt.println("kmag(q) =", kmag(q))
fmt.println("conj(q) =", conj(q))
fmt.println("abs(q)  =", abs(q))
```

--------------------------------

### Using `using` on Procedure Parameters

Source: https://odin-lang.org/docs/overview

Demonstrates applying the `using` statement directly to a procedure parameter, making its members accessible within the procedure scope.

```odin
foo :: proc(using entity: ^Entity) {
	fmt.println(position.x, position.y, position.z)
}
```

--------------------------------

### Check C++ Compiler Version

Source: https://odin-lang.org/docs/install

Determine the installed C++ compiler version using `clang++ -v` to identify the correct libstdc++ package for atomic.h.

```bash
clang++ -v
```

--------------------------------

### Bit Set Subset and Superset Comparisons

Source: https://odin-lang.org/docs/demo

Demonstrates subset and superset comparisons between bit sets. Shows how to check for strict and non-strict subset/superset relationships.

```odin
Letters :: bit_set['A'..='Z']
a := Letters{'A', 'B'}
b := Letters{'A', 'B', 'C', 'D', 'F'}
c := Letters{'A', 'B'}

assert(a <= b) // 'a' is a subset of 'b'
assert(b >= a) // 'b' is a superset of 'a'
assert(a < b)  // 'a' is a strict subset of 'b'
assert(b > a)  // 'b' is a strict superset of 'a'

assert(!(a < c)) // 'a' is a not strict subset of 'c'
assert(!(c > a)) // 'c' is a not strict superset of 'a'
```

--------------------------------

### Build Odin Release (Windows)

Source: https://odin-lang.org/docs/install

Compile the Odin compiler in release mode on Windows using the provided build script.

```batch
build.bat release
```

--------------------------------

### Declaring Foreign Procedures

Source: https://odin-lang.org/docs/overview

Associates entities within a foreign block using a foreign import name. This example declares the ExitProcess procedure from kernel32.

```odin
foreign import kernel32 "system:kernel32.lib"
foreign kernel32 {
	ExitProcess :: proc "stdcall" (exit_code:  u32) ---
```

--------------------------------

### Any Type Usage and Type Assertions

Source: https://odin-lang.org/docs/demo

Illustrates the usage of the `any` type, which is similar to unions but allows any type. Demonstrates value assignment, type assertions, and type switching.

```odin
val: any
val = 137
if i, ok := val.(int); ok {
	fmt.println(i)
}
val = true
fmt.println(val)

val = nil

switch v in val {
case int:  fmt.println("int",  v)
case bool: fmt.println("bool", v)
case:      fmt.println("nil")
}
```

--------------------------------

### Procedure with Named Return Values

Source: https://odin-lang.org/docs/overview

Illustrates named return values, which are treated as variables within the procedure. Includes an example of a 'naked' return statement.

```odin
do_math :: proc(input: int) -> (x, y: int) {
	x = 2*input + 1
	y = 3*input / 5
	return x, y
}
do_math_with_naked_return :: proc(input: int) -> (x, y: int) {
	x = 2*input + 1
	y = 3*input / 5
	return // A "naked" return statement, as no values are explicitly specified.
}

```

--------------------------------

### Odin Map Initialization with Literal

Source: https://odin-lang.org/docs/overview

Demonstrates how to initialize an Odin map using a map literal, providing key-value pairs directly during declaration.

```odin
m := map[string]int{
	"Bob" = 2,
	"Chloe" = 5,
}
```

--------------------------------

### Importing Packages

Source: https://odin-lang.org/docs/overview

Import packages using the `import` statement. The `core:` prefix specifies the library collection.

```odin
package main

import "core:fmt"
import "core:os"

main :: proc() {
}

```

--------------------------------

### Type Inference Example

Source: https://odin-lang.org/docs/faq

Illustrates Odin's type inference. The compiler deduces the type of a variable based on its initial value, reducing verbosity.

```odin
x: int = 1
x := 1 // x is deduced to be an int
```

--------------------------------

### Basic Test Logging

Source: https://odin-lang.org/docs/testing

Demonstrates how to use `log.info` within a test function. The test runner captures and displays log messages.

```odin
package tests

import "core:log"
import "core:testing"

@(test)
my_test :: proc(t: ^testing.T) {
	log.info("Hellope!")
}

```

--------------------------------

### Importing Entities with `using` Statement

Source: https://odin-lang.org/docs/overview

Shows how to use the `using` statement to bring exported entities from a package or scope into the current scope, simplifying access to imported names.

```odin
import "foo"
bar :: proc() {
	// imports all the exported entities from the `foo` package into this scope
	using foo
}
```

--------------------------------

### Skipping to the next loop iteration with 'continue'

Source: https://odin-lang.org/docs/overview

The 'continue' statement starts the next iteration of a loop prematurely, skipping any remaining code in the current iteration.

```odin
for cond {
	if get_foo() {
		continue
	}
	fmt.println("Hellope")
}

```

--------------------------------

### Get Array Length in Odin

Source: https://odin-lang.org/docs/overview

Use the built-in `len` procedure to retrieve the number of elements in a fixed-size array. This is essential for loop bounds and other size-dependent operations.

```odin
x: [5]int
#assert(len(x) == 5)
```

--------------------------------

### Emulating while loop with for

Source: https://odin-lang.org/docs/faq

Demonstrates how Odin's 'for' loop can emulate a 'while' loop using an optional condition and optional semicolons.

```odin
for cond {}
```

--------------------------------

### Explicit Context Definition

Source: https://odin-lang.org/docs/overview

Procedures not using the 'odin' calling convention must explicitly assign the context if required. This example shows setting the default context.

```odin
explicit_context_definition :: proc "c" () {
	// Try commenting the following statement out below
	context = runtime.default_context()

	fmt.println("\n#explicit context definition")
	dummy_procedure()
}

dummy_procedure :: proc() {
	fmt.println("dummy_procedure")
}
```

--------------------------------

### Initialize slice with `make`

Source: https://odin-lang.org/docs/faq

Use `make` to initialize slices, dynamic arrays, and maps. This allocates and initializes the underlying data structure.

```odin
slice: []int = make([]int, 16)
```

--------------------------------

### Conditional Compilation with `when` statement

Source: https://odin-lang.org/docs/overview

Use `when` statements to conditionally compile blocks of code based on compile-time expressions. This example shows how to include code specifically for Linux.

```odin
when ODIN_OS == .Linux {
	// Do Linux stuff
}

```

--------------------------------

### C vs Odin Declaration Syntax

Source: https://odin-lang.org/docs/faq

Illustrates the difference in declaration syntax between C and Odin, highlighting Odin's more regular approach where types apply to all declared variables.

```c
int *a, b;

```

```odin
a, b: ^int

```

--------------------------------

### Odin Procedure Type with Calling Conventions

Source: https://odin-lang.org/docs/overview

Demonstrates declaring procedure types with specific calling conventions like 'c' and 'contextless'.

```odin
proc "c" (n: i32, data: rawptr)
```

```odin
proc "contextless" (s: []int)
```

--------------------------------

### Structure of Arrays (SoA) Struct Array Example

Source: https://odin-lang.org/docs/overview

Defines and manipulates a Structure of Arrays (SoA) for Vector3 data. Demonstrates both SoA and AoS-like access syntax.

```odin
v_soa: #soa[N]Vector3

v_soa[0].x = 1
v_soa[0].y = 4
v_soa[0].z = 9


// Same syntax as AOS and treat as if it was an array
fmt.println(len(v_soa))
fmt.println(v_soa[0])
fmt.println(v_soa[0].x)
fmt.println(&v_soa[0].x)
v_soa[1] = {0, 3, 4}
v_soa[1].x = 2
fmt.println(v_soa[1])

// Can use SOA syntax if necessary
v_soa.x[0] = 1
v_soa.y[0] = 4
v_soa.z[0] = 9
fmt.println(v_soa.x[0])

// Same pointer addresses with both syntaxes
assert(&v_soa[0].x == &v_soa.x[0])


// Same fmt printing
fmt.println(v_aos)
fmt.println(v_soa)

```

--------------------------------

### Basic Enumeration Definition

Source: https://odin-lang.org/docs/overview

Defines a simple enumeration type 'Direction' with four ordered values. The example shows how to access integer representations of enum members.

```odin
Direction :: enum{North, East, South, West}
```

```odin
int(Direction.North) == 0
int(Direction.East)  == 1
int(Direction.South) == 2
int(Direction.West)  == 3
```

--------------------------------

### Address and Pointer Indirection Operators

Source: https://odin-lang.org/docs/overview

Use '&' to get a pointer to a variable and '^' to dereference a pointer. Ensure the operand is addressable for '&'. Dereferencing nil pointers can cause panics.

```odin
&x
&a[foo(123)]
&Foo{1, 2}

p^
pproc(a)^

x: ^int = nil
x^      // causes a runtime panic

```

--------------------------------

### Iterating Over Map Keys

Source: https://odin-lang.org/docs/demo

Shows how to iterate over the keys of a map. The order of iteration is not guaranteed.

```odin
some_map := map[string]int{"A" = 1, "C" = 9, "B" = 4}
defer delete(some_map)
for key in some_map {
	fmt.println(key)
}
```

--------------------------------

### Default Calling Convention Attribute

Source: https://odin-lang.org/docs/overview

Specifies the default calling convention for procedures within a `foreign` block. Example shows setting it to `std` for the `kernel32` foreign block.

```odin
@(default_calling_convention = "std")
foreign kernel32 {
	@(link_name="LoadLibraryA") load_library_a  :: proc(c_str: ^u8) -> Hmodule ---
}

```

--------------------------------

### Odin Procedure Type Declarations

Source: https://odin-lang.org/docs/overview

Illustrates the syntax for declaring procedure types with different parameter and return types.

```odin
proc(x: int) -> bool
```

```odin
proc(c: proc(x: int) -> bool) -> (i32, f32)
```

--------------------------------

### Parametric Polymorphic Union Example

Source: https://odin-lang.org/docs/demo

Illustrates a parametric polymorphic union in Odin, which can hold a value of a specified type `T` or an `Error` enum. Shows type introspection and assignment.

```odin
Error :: enum {
	Foo0,
	Foo1,
	Foo2,
	Foo3,
}
Para_Union :: union($T: typeid) {T, Error}
r: Para_Union(int)
fmt.println(typeid_of(type_of(r)))

fmt.println(r)
r = 123
fmt.println(r)
r = Error.Foo0 // r = .Foo0 is allow too, see implicit selector expressions below
fmt.println(r)

```

--------------------------------

### Map Type Usage in Odin

Source: https://odin-lang.org/docs/demo

Demonstrates the creation, insertion, retrieval, and deletion of elements in a map in Odin. It also shows how to check for the existence of a key.

```odin
m := make(map[string]int)
		defer delete(m)

		m["Bob"] = 2
		m["Ted"] = 5
		fmt.println(m["Bob"])

		delete_key(&m, "Ted")

		// If an element of a key does not exist, the zero value of the
		// element will be returned. To check to see if an element exists
		// can be done in two ways:
		elem, ok := m["Bob"]
		exists := "Bob" in m
		_, _ = elem, ok
		_ = exists
```

--------------------------------

### Odin Build and Run Commands

Source: https://odin-lang.org/docs/overview

Commands for compiling and running Odin programs. 'odin run .' compiles and runs the executable for the current directory. 'odin build <dir>' compiles without running.

```bash
odin run .

```

```bash
odin build <dir>

```

```bash
odin run hellope.odin -file

```

--------------------------------

### Raw String Literal Example

Source: https://odin-lang.org/docs/faq

Shows how to define raw string literals in Odin, which do not interpret escape sequences. Useful for strings containing special characters or verbatim text.

```odin
x := `what "the" string?`
```

--------------------------------

### Basic "Hellope!" Program in Odin

Source: https://odin-lang.org/docs/overview

A simple Odin program that prints "Hellope!" to the console. Save this code to a .odin file and compile/run using 'odin run <dir>'.

```odin
package main

import "core:fmt"

main :: proc() {
	fmt.println("Hellope!")
}

```

--------------------------------

### Build Odin Release (macOS/Unix)

Source: https://odin-lang.org/docs/install

Compile the Odin compiler in release mode on macOS and other Unix-like systems using make.

```makefile
make release-native
```

--------------------------------

### Odin Structs with 'using' for Polymorphism

Source: https://odin-lang.org/docs/faq

Demonstrates how to use the 'using' keyword in Odin structs to achieve subtype polymorphism and control memory layout, similar to C++ virtual tables but with more explicit control.

```odin
Base :: struct { ... }
Derived :: struct {
    using base: Base,
    name: string,
}
Derived_By_Ptr :: struct {
    name: string,
    // `using` can be applied anywhere and even to a pointer.
    // This allows for a huge amount of control over the memory
    // layout of the data structure.
    using base: ^Base,
}
```
Tokens:
Raw