C.CodeCompared.To/Odin

Odin's standard-library packages carry a core: prefix, and fmt.println appends the newline that printf makes you write every time. main returns nothing; the process exits 0 unless you call os.exit.

C compiles translation units separately and links object files, which is why makefiles exist. Because Odin sees the whole package at once, every .odin file beside this one is already in scope with no #include, no forward declarations, and no build system to configure.

That single rule removes header files, include guards, #pragma once, and the whole class of bugs where a header drifts out of sync with its implementation. There is exactly one declaration of anything, and the compiler sees the entire package at once.

Odin's block comments nest, so wrapping any region in /* … */ always does what you meant. In C the same edit terminates at the first inner */, leaving a stray */ and a confusing error somewhere below — which is why C programmers reach for #if 0 instead.

In C, int *a, b; declares a as a pointer and b as an int, because * binds to the declarator rather than the type. Putting the type on the right of a colon also removes C's spiral rule for reading declarations — there is no Odin equivalent of char *(*(*x[3])())[5].

That means arguments are evaluated exactly once (the C column shows the classic double-evaluation trap), the compiler type-checks the call, and a debugger can step into it. The things macros were genuinely needed for are covered by when, parametric polymorphism, and #force_inline.

#ifdef operates on text before the compiler runs, so a misspelled macro name silently takes the wrong branch and the untaken branch is never even parsed. In Odin a typo in the condition is a compile error, which is the whole point of moving this into the language.

The typedef struct Node Node; ritual disappears entirely. And because . works through any depth of pointer, first.next.value is what you write regardless of how many indirections are in the chain.

C's const is a read-only qualifier on a runtime object, which is why C programmers still reach for #define or an enum to size an array. Odin also has no const qualifier to propagate through signatures: procedure parameters are immutable by default, so const-correctness is the default rather than an annotation discipline.

Uninitialized locals are one of C's most reliable sources of heisenbugs, since reading one is undefined behavior that may look fine in a debug build. Making zeroing the default and = --- the explicit escape hatch inverts which choice is the easy one.

There is no <stdint.h> because there is nothing to work around: the sizes are in the names rather than being implementation-defined. The PRId32 format-macro dance goes too, since %d and %v handle any integer width.

C's usual arithmetic conversions produce its most famous gotcha: the left column's signed_value > unsigned_value converts -1 to a huge unsigned value, so the comparison is false. Odin has no conversion rules to get wrong, and constants are range-checked at each use site, so i8 = 300 is rejected rather than silently truncated.

C's typedef only ever creates an alias, so assigning a Celsius to a Fahrenheit compiles happily. distinct is how unit-mismatch and handle-mixup bugs — passing a file descriptor where a socket was expected, both being int — become compile errors rather than review comments.

Postfix dereference reads left to right in a chain — a.b^.c — and removes the parsing ambiguity between multiplication and dereference that makes C declarations hard to read.

Making raw pointer walking a named, greppable call rather than a + means it stops happening by accident. Nearly every C pointer-walking loop becomes a slice in Odin, which knows how many elements it has and is bounds-checked in debug builds.

Removing out-parameters removes a family of bugs with them: a null out-pointer, an uninitialized one, or forgetting that a function writes through it. When an Odin procedure does take a pointer it is because it genuinely mutates something, and &value at the call site announces that.

No int (*name)(int) spiral, and no typedef needed to make it legible. Procedure literals exist too, but they are not closures — they cannot capture locals, which keeps a procedure value a bare code pointer, exactly the machine-level thing a C function pointer is.

A C array parameter is a lie: it decays to a pointer, sizeof inside the function measures the pointer rather than the array, and the length must be passed alongside and kept in sync by hand. This is the root of more C bugs than any other single rule, and slices remove it outright. Odin arrays themselves never decay — [4]int is a value that copies on assignment.

Release builds (-o:speed) drop the checks entirely, so you pay for safety exactly where you have not proven you can do without it. In C the same access is undefined behavior with no diagnostic and no trap — it silently reads whatever is adjacent in memory.

Every C project eventually writes the left column, and every one writes it slightly differently. The dynamic array allocates from context.allocator, so an arena or pool applies to it automatically, and numbers[:] yields a slice for any []int procedure.

C has no hash map in its standard library, which is why every non-trivial C codebase carries uthash, stb_ds, or a hand-rolled table. Odin's allocates from context.allocator. Watch the naming: delete_key(&scores, key) removes one entry, while delete(scores) frees the whole map.

The arithmetic lowers to SIMD instructions where the target supports them. GLSL is listed among Odin's influences in its FAQ, and for the graphics and simulation work the language targets this replaces a pile of hand-written vector macros or a C++ operator-overloading layer.

This also means a string may safely contain a zero byte, and there is no strlen that can walk off the end of an unterminated buffer. The trade is that you cannot hand one directly to a C function — which is what the next row is about.

Because the two are different types, you cannot accidentally pass a length-carrying Odin string to a C function expecting a sentinel. That distinction is doing the work that strcpy/strcat/sprintf overflow bugs come from the absence of.

The C column has to track the write offset, recompute the remaining space, and check snprintf's return for truncation on every call — three chances to get it wrong per iteration. Neither Odin form can overflow, and neither needs you to compute a remaining length by hand.

That is possible precisely because Odin strings carry a length and need no terminator. strtok, by contrast, mutates the string you pass it and keeps hidden static state, which makes it neither reentrant nor thread-safe — a famous piece of C API design.

Three quiet improvements over malloc: no cast, no sizeof to get wrong, and no uninitialized bytes. Placing the defer beside the allocation makes an unmatched allocation visible at a glance — and the rows below show why you often will not write free at all.

The goto cleanup ladder is idiomatic C precisely because C has nothing better, and it scales badly: every new allocation means a new label and an audit of every earlier jump. With defer, adding a fourth allocation changes nothing about the first three. Note that a defer the compiler proves unreachable — after os.exit — is a compile error, not a silent leak.

This is the feature that most changes how you structure a program, and it has no C equivalent short of replacing malloc globally with a linker trick. Swapping in an arena, a pool, or a deliberately failing allocator for an entire subsystem is a one-line change, where the C column has to thread a function pointer through every frame in the call chain.

Arenas are not a new idea — good C codebases have used them for decades. What Odin changes is that the arena is plugged into the language, so library code you did not write still allocates from it. In C your hand-rolled arena is invisible to the standard library, and strdup and friends keep going to the heap regardless.

Leak detection in C is an external tool — Valgrind, ASan, or a custom malloc shim — none of it reachable from inside the language. Odin's version needs no special build, works in a release binary, and can be scoped to one subsystem while the rest of the program runs untracked.

Both of those last two are things C cannot do: memcmp is wrong for comparison in the presence of padding, so C makes you write a field-by-field comparison, and printing needs a hand-written function per type.

#pragma pack and __attribute__((packed)) differ between GCC, Clang, and MSVC, which is a portability headache for anyone parsing a binary format. Having the layout controls and the introspection in the language means you can assert the layout is what you think it is.

This is composition without the anonymous-struct-member extension that C compilers offer non-portably. The embedded field keeps a real name, so two embedded values of the same type do not collide, and it is still an ordinary field you can pass to a procedure expecting a Named.

A C union shares storage with no record of which member is live, so the kind field is a convention the compiler never verifies and reading the wrong member is undefined behavior. An Odin union also has a nil state meaning "no variant set", which a C tagged struct can only fake with an extra enum member.

The C version reuses fields a and b for different meanings per kind, a common compromise the compiler cannot help with. Adding a third variant to an Odin union turns every non-exhaustive switch into a compile error, where the C switch quietly falls through to return 0.

Three fixes over C. Members do not leak into the enclosing scope, so two enums may both have a Red. %v prints the member name, removing the parallel string table that always drifts out of sync. And the type is genuinely closed, so Color(99) has no Odin equivalent.

The C idiom works, but the shifts are yours to assign correctly, any integer can be assigned in, and printing the flags means writing a decoder. Pinning the backing type matters when the layout has to match a file or wire format.

C bit-fields are notoriously under-specified: the standard leaves bit ordering, whether a field may straddle a storage unit, and the permitted base types to the implementation. A struct that parses a packet correctly under GCC may not under MSVC, which is why serious C code masks and shifts by hand instead.

Inverting the default removes the missing-break bug entirely. Ranges have no C equivalent at all, and a case that declares a variable needs no braces around it.

Watch the loop-variable order when ranging over a collection: for value, index in numbers puts the element first and the index second. That is the reverse of most languages and the single easiest thing to get backwards when starting out.

The jump target is therefore always a loop boundary, which keeps the control flow local and readable. Between this and defer, the two legitimate uses of goto in C — escaping nested loops and cleanup ladders — both have first-class replacements.

C99 allows a declaration in a for initializer but not in an if, so the temporary leaks into the enclosing scope where it can be misused later. A small thing, but it measurably reduces the number of live names in a function.

This removes the C habit of shipping foo, foo_ex, and foo_ex2, or an options struct that has to be zero-initialized first. Named arguments may appear in any order, which makes a call with several boolean flags readable without a comment explaining which true is which.

va_list is one of the least safe things in C: neither the argument count nor the types are known to the compiler, which is why printf format-string mismatches are a security class of their own. For genuinely mixed types Odin uses ..any, which carries a typeid with each value.

This is const-correctness as the default rather than an annotation you have to remember and propagate through every signature. When a procedure genuinely must mutate, it takes a pointer, and &value at the call site announces it.

C error reporting is a patchwork — a sentinel return, a global errno, an out-parameter, or all three at once — and none of it is enforced. An error enum costs one integer, has no global state, is thread-safe by construction, and forms a closed set the compiler can check exhaustively in a switch.

This is what makes return-code error handling bearable at scale: the three-line manual check in the C column collapses to a suffix, and adding a layer to the call chain adds one word rather than a block. It is Rust's ? without the trait machinery.

Where or_return propagates a failure, or_else swallows it and substitutes a default. The C equivalent needs a temporary and a conditional, and the condition itself is easy to get subtly wrong — the left column has to check both end and what it points at.

Unlike a macro, arguments are evaluated exactly once (the C column shows the double-evaluation trap), types are checked, and a debugger can step in. Unlike the void *-plus-size_t-plus-comparator approach, there is no type erasure and no indirect call.

Compare the C column: void * plus a hand-carried element_size, a memcpy for every insert, and a cast on every read, none of it checked. Pushing a string onto a Stack(int) is a compile error here.

Odin's parametric polymorphism binds values as well as types, so doubled returns an array of exactly the length it received, checked at compile time. C's const int values[3] parameter is a fiction: it decays to const int * and the 3 is ignored entirely.

Signed overflow being undefined in C is not academic: compilers use it to delete overflow checks that programmers wrote deliberately, which has produced real security bugs. Odin has far less undefined behavior generally, though rawptr misuse and out-of-bounds writes in release builds remain unsafe.

C lets you ignore a return value silently, which is how failed calls get missed — warn_unused_result is a non-standard attribute applied function by function. Making the discard explicit means ignoring an error is something you type on purpose rather than something you forget.

The capabilities match C's assert and _Static_assert, with two conveniences: the compile-time form needs no separate keyword, and the runtime form takes an optional message and reports its source location. There is no NDEBUG equivalent that can disable panic.

There is no marshaling layer and no runtime cost — a foreign call is an ordinary call. The when wrapper is not decoration: a bare "system:c" works on Linux and fails on macOS, and this example is verified running on both.

#packed and #align are there when a specific layout is required. One catch worth knowing: a "c" procedure receives no implicit context, so it cannot allocate through context.allocator until you set one up with context = runtime.default_context().

Because the reading code does not change, the optimization becomes a one-keyword experiment rather than a refactor you have to justify in advance. In C it means a new type and touching every access site, which is why it usually does not happen until profiling forces it. Neither Rust nor Zig can express this without macros or code generation.