Update demo.odin

v0.8.1
Fix initialization values for variables
2026-07-05 11:11:37 -07:00 · 2018-02-11 11:16:17 +00:00 · 2018-02-11 11:15:53 +00:00 · 2018-02-11 11:13:52 +00:00 · 2018-02-09 18:03:06 +00:00 · 2018-02-07 18:55:01 +00:00
124 changed files with 51035 additions and 30016 deletions
@@ -251,7 +251,23 @@ paket-files/


 # Project Specific
+
+# - Windows
 *.sln
-!misc/llvm-bim/lli.exe
-!misc/llvm-bim/opt.exe
-builds
+builds/
+bin/
+*.exe
+*.obj
+*.pdb
+
+# - Linux/MacOS
+odin
+odin.dSYM
+
+
+# shared collection
+shared/
+
+# temp files
+* .ll
+*.bc
@@ -1,4 +1,4 @@
-Copyright (c) 2016 Ginger Bill. All rights reserved.
+Copyright (c) 2016-2017 Ginger Bill. All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
@@ -0,0 +1,24 @@
+DISABLED_WARNINGS=-Wno-switch -Wno-writable-strings -Wno-tautological-compare -Wno-macro-redefined #-Wno-pointer-sign -Wno-tautological-constant-out-of-range-compare  
+LDFLAGS=-pthread -ldl -lm -lstdc++
+CFLAGS=-std=c++11
+CC=clang
+
+OS=$(shell uname)
+
+ifeq ($(OS), DARWIN)
+	LDFLAGS=$(LDFLAGS) -liconv
+endif
+
+all: debug demo
+
+demo:
+	./odin run examples/demo.odin
+
+debug:
+	$(CC) src/main.cpp $(DISABLED_WARNINGS) $(CFLAGS) -g $(LDFLAGS) -o odin
+
+release:
+	$(CC) src/main.cpp $(DISABLED_WARNINGS) $(CFLAGS) -O3 -march=native $(LDFLAGS) -o odin
+	
+
+	
@@ -1,14 +1,39 @@
-<img src="logo-slim.png" alt="Odin logo" height="74">
+<img src="misc/logo-slim.png" alt="Odin logo" height="74">

 # The Odin Programming Language

-Odin is fast, concise, readable, pragmatic and open sourced. It is designed with the intent of replacing C with the following goals:
+The Odin programming language is fast, concise, readable, pragmatic and open sourced. It is designed with the intent of replacing C with the following goals:
 * simplicity
 * high performance
 * built for modern systems
 * joy of programming
 * metaprogramming
-* designed for good programmers
+
+Website: [https://odin.handmade.network/](https://odin.handmade.network/)
+
+```go
+import "core:fmt.odin"
+
+main :: proc() {
+	program := "+ + * 😃 - /";
+	accumulator := 0;
+
+	for token in program {
+		switch token {
+		case '+': accumulator += 1;
+		case '-': accumulator -= 1;
+		case '*': accumulator *= 2;
+		case '/': accumulator /= 2;
+		case '😃': accumulator *= accumulator;
+		case: // Ignore everything else
+		}
+	}
+
+	fmt.printf("The program \"%s\" calculates the value %d\n",
+	           program, accumulator);
+}
+
+```

 ## Demonstrations:
 * First Talk & Demo
@@ -18,39 +43,52 @@ Odin is fast, concise, readable, pragmatic and open sourced. It is designed with
 * [Composition & Refactorability](https://www.youtube.com/watch?v=n1wemZfcbXM)
 * [Introspection, Modules, and Record Layout](https://www.youtube.com/watch?v=UFq8rhWhx4s)
 * [push_allocator & Minimal Dependency Building](https://www.youtube.com/watch?v=f_LGVOAMb78)
+* [when, for & procedure overloading](https://www.youtube.com/watch?v=OzeOekzyZK8)
+* [Context Types, Unexported Entities, Labelled Branches](https://www.youtube.com/watch?v=CkHVwT1Qk-g)
+* [Bit Fields, i128 & u128, Syntax Changes](https://www.youtube.com/watch?v=NlTutcLyF64)

 ## Requirements to build and run

-* Windows
-* x86-64
-* MSVC 2015 installed (C99 support)
-* Requires MSVC's link.exe as the linker
-	- run `vcvarsall.bat` to setup the path
+- Windows
+	* x86-64
+	* MSVC 2015 installed (C++11 support)
+	* [LLVM binaries](https://github.com/gingerBill/Odin/releases/tag/llvm-4.0-windows) for `opt.exe` and `llc.exe`
+	* Requires MSVC's link.exe as the linker
+		* run `vcvarsall.bat` to setup the path
+
+- MacOS
+	* x86-64
+	* LLVM explicitly installed (`brew install llvm`)
+	* XCode installed (for the linker)
+
+- GNU/Linux
+	* x86-64
+	* Build tools (ld)
+	* LLVM installed
+	* Clang installed (temporary - this is Calling the linker for now)

 ## Warnings

 * This is still highly in development and the language's design is quite volatile.
-* Syntax is definitely not fixed
+* Syntax is not fixed.

 ## Roadmap

-Not in any particular order
+Not in any particular order and not be implemented

-* Custom backend to replace LLVM
-	- Improve SSA design to accommodate for lowering to a "bytecode"
-	- SSA optimizations
-	- COFF generation
-	- linker
-* Type safe "macros"
-* Documentation generator for "Entities"
-* Multiple architecture support
-* Inline assembly
-* Linking options
-	- Executable
-	- Static/Dynamic Library
-* Debug information
+* Compile Time Execution (CTE)
+	- More metaprogramming madness
+	- Compiler as a library
+	- AST inspection and modification
+* CTE-based build system
+* Replace LLVM backend with my own custom backend
+* Improve SSA design to accommodate for lowering to a "bytecode"
+* SSA optimizations
+* Documentation Generator for "Entities"
+* Multiple Architecture support
+* Debug Information
 	- pdb format too
-* Command line tooling
-* Compiler internals:
+* Command Line Tooling
+* Compiler Internals:
 	- Big numbers library
-
+	- Multithreading for performance increase
@@ -1,200 +0,0 @@
-This file is a list of the people responsible for ensuring that patches for a
-particular part of LLVM are reviewed, either by themself or by someone else.
-They are also the gatekeepers for their part of LLVM, with the final word on
-what goes in or not.
-
-The list is sorted by surname and formatted to allow easy grepping and
-beautification by scripts.  The fields are: name (N), email (E), web-address
-(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
-(S). Each entry should contain at least the (N), (E) and (D) fields.
-
-N: Joe Abbey
-E: jabbey@arxan.com
-D: LLVM Bitcode (lib/Bitcode/* include/llvm/Bitcode/*)
-
-N: Owen Anderson
-E: resistor@mac.com
-D: SelectionDAG (lib/CodeGen/SelectionDAG/*)
-
-N: Rafael Avila de Espindola
-E: rafael.espindola@gmail.com
-D: Gold plugin (tools/gold/*)
-
-N: Justin Bogner
-E: mail@justinbogner.com
-D: InstrProfiling and related parts of ProfileData
-
-N: Chandler Carruth
-E: chandlerc@gmail.com
-E: chandlerc@google.com
-D: Config, ADT, Support, inlining & related passes, SROA/mem2reg & related passes, CMake, library layering
-
-N: Evan Cheng
-E: evan.cheng@apple.com
-D: parts of code generator not covered by someone else
-
-N: Eric Christopher
-E: echristo@gmail.com
-D: Debug Information, autotools/configure/make build, inline assembly
-
-N: Greg Clayton
-E: gclayton@apple.com
-D: LLDB
-
-N: Marshall Clow
-E: mclow.lists@gmail.com
-D: libc++
-
-N: Peter Collingbourne
-E: peter@pcc.me.uk
-D: llgo
-
-N: Quentin Colombet
-E: qcolombet@apple.com
-D: Register allocators
-
-N: Duncan P. N. Exon Smith
-E: dexonsmith@apple.com
-D: Branch weights and BlockFrequencyInfo
-
-N: Hal Finkel
-E: hfinkel@anl.gov
-D: BBVectorize, the loop reroller, alias analysis and the PowerPC target
-
-N: Dan Gohman
-E: sunfish@mozilla.com
-D: WebAssembly Backend (lib/Target/WebAssembly/*)
-
-N: Renato Golin
-E: renato.golin@linaro.org
-D: ARM Linux support
-
-N: Venkatraman Govindaraju
-E: venkatra@cs.wisc.edu
-D: Sparc Backend (lib/Target/Sparc/*)
-
-N: Tobias Grosser
-E: tobias@grosser.es
-D: Polly
-
-N: James Grosbach
-E: grosbach@apple.com
-D: MC layer
-
-N: Justin Holewinski
-E: jholewinski@nvidia.com
-D: NVPTX Target (lib/Target/NVPTX/*)
-
-N: Lang Hames
-E: lhames@gmail.com
-D: MCJIT, RuntimeDyld and JIT event listeners
-
-N: Galina Kistanova
-E: gkistanova@gmail.com
-D: LLVM Buildbot
-
-N: Anton Korobeynikov
-E: anton@korobeynikov.info
-D: Exception handling, Windows codegen, ARM EABI
-
-N: Benjamin Kramer
-E: benny.kra@gmail.com
-D: DWARF Parser
-
-N: Sergei Larin
-E: slarin@codeaurora.org
-D: VLIW Instruction Scheduling, Packetization
-
-N: Chris Lattner
-E: sabre@nondot.org
-W: http://nondot.org/~sabre/
-D: Everything not covered by someone else
-
-N: David Majnemer
-E: david.majnemer@gmail.com
-D: IR Constant Folder, InstCombine
-
-N: Dylan McKay
-E: dylanmckay34@gmail.com
-D: AVR Backend
-
-N: Tim Northover
-E: t.p.northover@gmail.com
-D: AArch64 backend, misc ARM backend
-
-N: Diego Novillo
-E: dnovillo@google.com
-D: SampleProfile and related parts of ProfileData
-
-N: Jakob Olesen
-E: stoklund@2pi.dk
-D: TableGen
-
-N: Richard Osborne
-E: richard@xmos.com
-D: XCore Backend
-
-N: Krzysztof Parzyszek
-E: kparzysz@codeaurora.org
-D: Hexagon Backend
-
-N: Paul Robinson
-E: paul_robinson@playstation.sony.com
-D: Sony PlayStation®4 support
-
-N: Chad Rosier
-E: mcrosier@codeaurora.org
-D: Fast-Isel
-
-N: Nadav Rotem
-E: nrotem@apple.com
-D: X86 Backend, Loop Vectorizer
-
-N: Daniel Sanders
-E: daniel.sanders@imgtec.com
-D: MIPS Backend (lib/Target/Mips/*)
-
-N: Duncan Sands
-E: baldrick@free.fr
-D: DragonEgg
-
-N: Kostya Serebryany
-E: kcc@google.com
-D: AddressSanitizer, ThreadSanitizer (LLVM parts)
-
-N: Michael Spencer
-E: bigcheesegs@gmail.com
-D: Windows parts of Support, Object, ar, nm, objdump, ranlib, size
-
-N: Alexei Starovoitov
-E: alexei.starovoitov@gmail.com
-D: BPF backend
-
-N: Tom Stellard
-E: thomas.stellard@amd.com
-E: mesa-dev@lists.freedesktop.org
-D: Release manager for the 3.5 and 3.6 branches, R600 Backend, libclc
-
-N: Evgeniy Stepanov
-E: eugenis@google.com
-D: MemorySanitizer (LLVM part)
-
-N: Andrew Trick
-E: atrick@apple.com
-D: IndVar Simplify, Loop Strength Reduction, Instruction Scheduling
-
-N: Ulrich Weigand
-E: uweigand@de.ibm.com
-D: SystemZ Backend
-
-N: Bill Wendling
-E: isanbard@gmail.com
-D: libLTO, IR Linker
-
-N: Peter Zotov
-E: whitequark@whitequark.org
-D: OCaml bindings
-
-N: Andrey Churbanov
-E: andrey.churbanov@intel.com
-D: OpenMP runtime library
@@ -1,467 +0,0 @@
-This file is a partial list of people who have contributed to the LLVM
-project.  If you have contributed a patch or made some other contribution to
-LLVM, please submit a patch to this file to add yourself, and it will be
-done!
-
-The list is sorted by surname and formatted to allow easy grepping and
-beautification by scripts.  The fields are: name (N), email (E), web-address
-(W), PGP key ID and fingerprint (P), description (D), snail-mail address
-(S), and (I) IRC handle.
-
-
-N: Vikram Adve
-E: vadve@cs.uiuc.edu
-W: http://www.cs.uiuc.edu/~vadve/
-D: The Sparc64 backend, provider of much wisdom, and motivator for LLVM
-
-N: Owen Anderson
-E: resistor@mac.com
-D: LCSSA pass and related LoopUnswitch work
-D: GVNPRE pass, DataLayout refactoring, random improvements
-
-N: Henrik Bach
-D: MingW Win32 API portability layer
-
-N: Aaron Ballman
-E: aaron@aaronballman.com
-D: __declspec attributes, Windows support, general bug fixing
-
-N: Nate Begeman
-E: natebegeman@mac.com
-D: PowerPC backend developer
-D: Target-independent code generator and analysis improvements
-
-N: Daniel Berlin
-E: dberlin@dberlin.org
-D: ET-Forest implementation.
-D: Sparse bitmap
-
-N: David Blaikie
-E: dblaikie@gmail.com
-D: General bug fixing/fit & finish, mostly in Clang
-
-N: Neil Booth
-E: neil@daikokuya.co.uk
-D: APFloat implementation.
-
-N: Misha Brukman
-E: brukman+llvm@uiuc.edu
-W: http://misha.brukman.net
-D: Portions of X86 and Sparc JIT compilers, PowerPC backend
-D: Incremental bitcode loader
-
-N: Cameron Buschardt
-E: buschard@uiuc.edu
-D: The `mem2reg' pass - promotes values stored in memory to registers
-
-N: Brendon Cahoon
-E: bcahoon@codeaurora.org
-D: Loop unrolling with run-time trip counts.
-
-N: Chandler Carruth
-E: chandlerc@gmail.com
-E: chandlerc@google.com
-D: Hashing algorithms and interfaces
-D: Inline cost analysis
-D: Machine block placement pass
-D: SROA
-
-N: Casey Carter
-E: ccarter@uiuc.edu
-D: Fixes to the Reassociation pass, various improvement patches
-
-N: Evan Cheng
-E: evan.cheng@apple.com
-D: ARM and X86 backends
-D: Instruction scheduler improvements
-D: Register allocator improvements
-D: Loop optimizer improvements
-D: Target-independent code generator improvements
-
-N: Dan Villiom Podlaski Christiansen
-E: danchr@gmail.com
-E: danchr@cs.au.dk
-W: http://villiom.dk
-D: LLVM Makefile improvements
-D: Clang diagnostic & driver tweaks
-S: Aarhus, Denmark
-
-N: Jeff Cohen
-E: jeffc@jolt-lang.org
-W: http://jolt-lang.org
-D: Native Win32 API portability layer
-
-N: John T. Criswell
-E: criswell@uiuc.edu
-D: Original Autoconf support, documentation improvements, bug fixes
-
-N: Anshuman Dasgupta
-E: adasgupt@codeaurora.org
-D: Deterministic finite automaton based infrastructure for VLIW packetization
-
-N: Stefanus Du Toit
-E: stefanus.du.toit@intel.com
-D: Bug fixes and minor improvements
-
-N: Rafael Avila de Espindola
-E: rafael.espindola@gmail.com
-D: The ARM backend
-
-N: Dave Estes
-E: cestes@codeaurora.org
-D: AArch64 machine description for Cortex-A53
-
-N: Alkis Evlogimenos
-E: alkis@evlogimenos.com
-D: Linear scan register allocator, many codegen improvements, Java frontend
-
-N: Hal Finkel
-E: hfinkel@anl.gov
-D: Basic-block autovectorization, PowerPC backend improvements
-
-N: Eric Fiselier
-E: eric@efcs.ca
-D: LIT patches and documentation.
-
-N: Ryan Flynn
-E: pizza@parseerror.com
-D: Miscellaneous bug fixes
-
-N: Brian Gaeke
-E: gaeke@uiuc.edu
-W: http://www.students.uiuc.edu/~gaeke/
-D: Portions of X86 static and JIT compilers; initial SparcV8 backend
-D: Dynamic trace optimizer
-D: FreeBSD/X86 compatibility fixes, the llvm-nm tool
-
-N: Nicolas Geoffray
-E: nicolas.geoffray@lip6.fr
-W: http://www-src.lip6.fr/homepages/Nicolas.Geoffray/
-D: PPC backend fixes for Linux
-
-N: Louis Gerbarg
-E: lgg@apple.com
-D: Portions of the PowerPC backend
-
-N: Saem Ghani
-E: saemghani@gmail.com
-D: Callgraph class cleanups
-
-N: Mikhail Glushenkov
-E: foldr@codedgers.com
-D: Author of llvmc2
-
-N: Dan Gohman
-E: sunfish@mozilla.com
-D: Miscellaneous bug fixes
-D: WebAssembly Backend
-
-N: David Goodwin
-E: david@goodwinz.net
-D: Thumb-2 code generator
-
-N: David Greene
-E: greened@obbligato.org
-D: Miscellaneous bug fixes
-D: Register allocation refactoring
-
-N: Gabor Greif
-E: ggreif@gmail.com
-D: Improvements for space efficiency
-
-N: James Grosbach
-E: grosbach@apple.com
-I: grosbach
-D: SjLj exception handling support
-D: General fixes and improvements for the ARM back-end
-D: MCJIT
-D: ARM integrated assembler and assembly parser
-D: Led effort for the backend formerly known as ARM64
-
-N: Lang Hames
-E: lhames@gmail.com
-D: PBQP-based register allocator
-
-N: Gordon Henriksen
-E: gordonhenriksen@mac.com
-D: Pluggable GC support
-D: C interface
-D: Ocaml bindings
-
-N: Raul Fernandes Herbster
-E: raul@dsc.ufcg.edu.br
-D: JIT support for ARM
-
-N: Paolo Invernizzi
-E: arathorn@fastwebnet.it
-D: Visual C++ compatibility fixes
-
-N: Patrick Jenkins
-E: patjenk@wam.umd.edu
-D: Nightly Tester
-
-N: Dale Johannesen
-E: dalej@apple.com
-D: ARM constant islands improvements
-D: Tail merging improvements
-D: Rewrite X87 back end
-D: Use APFloat for floating point constants widely throughout compiler
-D: Implement X87 long double
-
-N: Brad Jones
-E: kungfoomaster@nondot.org
-D: Support for packed types
-
-N: Rod Kay
-E: rkay@auroraux.org
-D: Author of LLVM Ada bindings
-
-N: Eric Kidd
-W: http://randomhacks.net/
-D: llvm-config script
-
-N: Anton Korobeynikov
-E: asl@math.spbu.ru
-D: Mingw32 fixes, cross-compiling support, stdcall/fastcall calling conv.
-D: x86/linux PIC codegen, aliases, regparm/visibility attributes
-D: Switch lowering refactoring
-
-N: Sumant Kowshik
-E: kowshik@uiuc.edu
-D: Author of the original C backend
-
-N: Benjamin Kramer
-E: benny.kra@gmail.com
-D: Miscellaneous bug fixes
-
-N: Sundeep Kushwaha
-E: sundeepk@codeaurora.org
-D: Implemented DFA-based target independent VLIW packetizer
-
-N: Christopher Lamb
-E: christopher.lamb@gmail.com
-D: aligned load/store support, parts of noalias and restrict support
-D: vreg subreg infrastructure, X86 codegen improvements based on subregs
-D: address spaces
-
-N: Jim Laskey
-E: jlaskey@apple.com
-D: Improvements to the PPC backend, instruction scheduling
-D: Debug and Dwarf implementation
-D: Auto upgrade mangler
-D: llvm-gcc4 svn wrangler
-
-N: Chris Lattner
-E: sabre@nondot.org
-W: http://nondot.org/~sabre/
-D: Primary architect of LLVM
-
-N: Tanya Lattner (Tanya Brethour)
-E: tonic@nondot.org
-W: http://nondot.org/~tonic/
-D: The initial llvm-ar tool, converted regression testsuite to dejagnu
-D: Modulo scheduling in the SparcV9 backend
-D: Release manager (1.7+)
-
-N: Sylvestre Ledru
-E: sylvestre@debian.org
-W: http://sylvestre.ledru.info/
-W: http://llvm.org/apt/
-D: Debian and Ubuntu packaging
-D: Continuous integration with jenkins
-
-N: Andrew Lenharth
-E: alenhar2@cs.uiuc.edu
-W: http://www.lenharth.org/~andrewl/
-D: Alpha backend
-D: Sampling based profiling
-
-N: Nick Lewycky
-E: nicholas@mxc.ca
-D: PredicateSimplifier pass
-
-N: Tony Linthicum, et. al.
-E: tlinth@codeaurora.org
-D: Backend for Qualcomm's Hexagon VLIW processor.
-
-N: Bruno Cardoso Lopes
-E: bruno.cardoso@gmail.com
-I: bruno
-W: http://brunocardoso.cc
-D: Mips backend
-D: Random ARM integrated assembler and assembly parser improvements
-D: General X86 AVX1 support
-
-N: Duraid Madina
-E: duraid@octopus.com.au
-W: http://kinoko.c.u-tokyo.ac.jp/~duraid/
-D: IA64 backend, BigBlock register allocator
-
-N: John McCall
-E: rjmccall@apple.com
-D: Clang semantic analysis and IR generation
-
-N: Michael McCracken
-E: michael.mccracken@gmail.com
-D: Line number support for llvmgcc
-
-N: Vladimir Merzliakov
-E: wanderer@rsu.ru
-D: Test suite fixes for FreeBSD
-
-N: Scott Michel
-E: scottm@aero.org
-D: Added STI Cell SPU backend.
-
-N: Kai Nacke
-E: kai@redstar.de
-D: Support for implicit TLS model used with MS VC runtime
-D: Dumping of Win64 EH structures
-
-N: Takumi Nakamura
-E: geek4civic@gmail.com
-E: chapuni@hf.rim.or.jp
-D: Cygwin and MinGW support.
-D: Win32 tweaks.
-S: Yokohama, Japan
-
-N: Edward O'Callaghan
-E: eocallaghan@auroraux.org
-W: http://www.auroraux.org
-D: Add Clang support with various other improvements to utils/NewNightlyTest.pl
-D: Fix and maintain Solaris & AuroraUX support for llvm, various build warnings
-D: and error clean ups.
-
-N: Morten Ofstad
-E: morten@hue.no
-D: Visual C++ compatibility fixes
-
-N: Jakob Stoklund Olesen
-E: stoklund@2pi.dk
-D: Machine code verifier
-D: Blackfin backend
-D: Fast register allocator
-D: Greedy register allocator
-
-N: Richard Osborne
-E: richard@xmos.com
-D: XCore backend
-
-N: Devang Patel
-E: dpatel@apple.com
-D: LTO tool, PassManager rewrite, Loop Pass Manager, Loop Rotate
-D: GCC PCH Integration (llvm-gcc), llvm-gcc improvements
-D: Optimizer improvements, Loop Index Split
-
-N: Ana Pazos
-E: apazos@codeaurora.org
-D: Fixes and improvements to the AArch64 backend
-
-N: Wesley Peck
-E: peckw@wesleypeck.com
-W: http://wesleypeck.com/
-D: MicroBlaze backend
-
-N: Francois Pichet
-E: pichet2000@gmail.com
-D: MSVC support
-
-N: Vladimir Prus
-W: http://vladimir_prus.blogspot.com
-E: ghost@cs.msu.su
-D: Made inst_iterator behave like a proper iterator, LowerConstantExprs pass
-
-N: Kalle Raiskila
-E: kalle.rasikila@nokia.com
-D: Some bugfixes to CellSPU
-
-N: Xerxes Ranby
-E: xerxes@zafena.se
-D: Cmake dependency chain and various bug fixes
-
-N: Alex Rosenberg
-E: alexr@leftfield.org
-I: arosenberg
-D: ARM calling conventions rewrite, hard float support
-
-N: Chad Rosier
-E: mcrosier@codeaurora.org
-I: mcrosier
-D: AArch64 fast instruction selection pass
-D: Fixes and improvements to the ARM fast-isel pass
-D: Fixes and improvements to the AArch64 backend
-
-N: Nadav Rotem
-E: nrotem@apple.com
-D: X86 code generation improvements, Loop Vectorizer.
-
-N: Roman Samoilov
-E: roman@codedgers.com
-D: MSIL backend
-
-N: Duncan Sands
-E: baldrick@free.fr
-I: baldrick
-D: Ada support in llvm-gcc
-D: Dragonegg plugin
-D: Exception handling improvements
-D: Type legalizer rewrite
-
-N: Ruchira Sasanka
-E: sasanka@uiuc.edu
-D: Graph coloring register allocator for the Sparc64 backend
-
-N: Arnold Schwaighofer
-E: arnold.schwaighofer@gmail.com
-D: Tail call optimization for the x86 backend
-
-N: Shantonu Sen
-E: ssen@apple.com
-D: Miscellaneous bug fixes
-
-N: Anand Shukla
-E: ashukla@cs.uiuc.edu
-D: The `paths' pass
-
-N: Michael J. Spencer
-E: bigcheesegs@gmail.com
-D: Shepherding Windows COFF support into MC.
-D: Lots of Windows stuff.
-
-N: Reid Spencer
-E: rspencer@reidspencer.com
-W: http://reidspencer.com/
-D: Lots of stuff, see: http://wiki.llvm.org/index.php/User:Reid
-
-N: Alp Toker
-E: alp@nuanti.com
-W: http://atoker.com/
-D: C++ frontend next generation standards implementation
-
-N: Craig Topper
-E: craig.topper@gmail.com
-D: X86 codegen and disassembler improvements. AVX2 support.
-
-N: Edwin Torok
-E: edwintorok@gmail.com
-D: Miscellaneous bug fixes
-
-N: Adam Treat
-E: manyoso@yahoo.com
-D: C++ bugs filed, and C++ front-end bug fixes.
-
-N: Lauro Ramos Venancio
-E: lauro.venancio@indt.org.br
-D: ARM backend improvements
-D: Thread Local Storage implementation
-
-N: Bill Wendling
-I: wendling
-E: isanbard@gmail.com
-D: Release manager, IR Linker, LTO
-D: Bunches of stuff
-
-N: Bob Wilson
-E: bob.wilson@acm.org
-D: Advanced SIMD (NEON) support in the ARM backend.
-
@@ -1,70 +0,0 @@
-==============================================================================
-LLVM Release License
-==============================================================================
-University of Illinois/NCSA
-Open Source License
-
-Copyright (c) 2003-2015 University of Illinois at Urbana-Champaign.
-All rights reserved.
-
-Developed by:
-
-    LLVM Team
-
-    University of Illinois at Urbana-Champaign
-
-    http://llvm.org
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal with
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimers.
-
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimers in the
-      documentation and/or other materials provided with the distribution.
-
-    * Neither the names of the LLVM Team, University of Illinois at
-      Urbana-Champaign, nor the names of its contributors may be used to
-      endorse or promote products derived from this Software without specific
-      prior written permission.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-SOFTWARE.
-
-==============================================================================
-Copyrights and Licenses for Third Party Software Distributed with LLVM:
-==============================================================================
-The LLVM software contains code written by third parties.  Such software will
-have its own individual LICENSE.TXT file in the directory in which it appears.
-This file will describe the copyrights, license, and restrictions which apply
-to that code.
-
-The disclaimer of warranty in the University of Illinois Open Source License
-applies to all code in the LLVM Distribution, and nothing in any of the
-other licenses gives permission to use the names of the LLVM Team or the
-University of Illinois to endorse or promote products derived from this
-Software.
-
-The following pieces of software have additional or alternate copyrights,
-licenses, and/or restrictions:
-
-Program             Directory
-------             ---------
-Autoconf            llvm/autoconf
-                    llvm/projects/ModuleMaker/autoconf
-Google Test         llvm/utils/unittest/googletest
-OpenBSD regex       llvm/lib/Support/{reg*, COPYRIGHT.regex}
-pyyaml tests        llvm/test/YAMLParser/{*.data, LICENSE.TXT}
-ARM contributions   llvm/lib/Target/ARM/LICENSE.TXT
-md5 contributions   llvm/lib/Support/MD5.cpp llvm/include/llvm/Support/MD5.h
@@ -5,7 +5,7 @@ set exe_name=odin.exe

 :: Debug = 0, Release = 1
 set release_mode=0
-set compiler_flags= -nologo -Oi -TC -fp:fast -fp:except- -Gm- -MP -FC -GS- -EHsc- -GR-
+set compiler_flags= -nologo -Oi -TP -fp:fast -fp:except- -Gm- -MP -FC -GS- -EHsc- -GR-

 if %release_mode% EQU 0 ( rem Debug
 	set compiler_flags=%compiler_flags% -Od -MDd -Z7
@@ -38,21 +38,16 @@ if %release_mode% EQU 0 ( rem Debug
 set compiler_settings=%compiler_includes% %compiler_flags% %compiler_warnings%
 set linker_settings=%libs% %linker_flags%

-
 del *.pdb > NUL 2> NUL
 del *.ilk > NUL 2> NUL

-cl %compiler_settings% "src\main.c" ^
-	/link %linker_settings% -OUT:%exe_name% ^
-	&& odin run code/demo.odin
-	rem && odin build_dll code/example.odin ^
-	rem && odin run code/demo.odin

-rem pushd src\asm
-rem 	nasm hellope.asm -fwin64 -o hellope.obj ^
-rem 	&& cl /nologo hellope.obj /link kernel32.lib /entry:main  ^
-rem 	&& hellope.exe
-rem popd
+cl %compiler_settings% "src\main.cpp" ^
+	/link %linker_settings% -OUT:%exe_name% ^
+	&& odin run examples/demo.odin
+	rem && odin docs core/fmt.odin
+
+del *.obj > NUL 2> NUL

 :end_of_build

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+release_mode=$1
+
+warnings_to_disable="-std=c++11 -Wno-switch -Wno-pointer-sign -Wno-tautological-constant-out-of-range-compare -Wno-tautological-compare -Wno-macro-redefined -Wno-writable-strings"
+libraries="-pthread -ldl -lm -lstdc++"
+other_args=""
+compiler="clang"
+
+if [ -z "$release_mode" ]; then release_mode="0"; fi
+
+if [ "$release_mode" -eq "0" ]; then
+	other_args="${other_args} -g"
+fi
+if [ "$release_mode" -eq "1" ]; then
+	other_args="${other_args} -O3 -march=native"
+fi
+
+if [[ "$(uname)" == "Darwin" ]]; then
+
+	# Set compiler to clang on MacOS
+	# MacOS provides a symlink to clang called gcc, but it's nice to be explicit here.
+	compiler="clang"
+
+	other_args="${other_args} -liconv"
+fi
+
+${compiler} src/main.cpp ${warnings_to_disable} ${libraries} ${other_args} -o odin && ./odin run examples/demo.odin
@@ -1,7 +0,0 @@
-#import "fmt.odin";
-
-main :: proc() {
-	x := "-stats";
-	y := "-begin";
-	fmt.println(x == y);
-}
@@ -1,215 +0,0 @@
-#import "win32.odin" when ODIN_OS == "windows";
-#import "fmt.odin";
-#import "math.odin";
-#import "os.odin";
-#import gl "opengl.odin";
-
-TWO_HEARTS :: '💕';
-
-win32_perf_count_freq := win32.GetQueryPerformanceFrequency();
-time_now :: proc() -> f64 {
-	assert(win32_perf_count_freq != 0);
-
-	counter: i64;
-	win32.QueryPerformanceCounter(^counter);
-	result := counter as f64 / win32_perf_count_freq as f64;
-	return result;
-}
-win32_print_last_error :: proc() {
-	err_code := win32.GetLastError() as int;
-	if err_code != 0 {
-		fmt.println("GetLastError: %", err_code);
-	}
-}
-
-// Yuk!
-to_c_string :: proc(s: string) -> []u8 {
-	c_str := new_slice(u8, s.count+1);
-	copy(c_str, s as []byte);
-	c_str[s.count] = 0;
-	return c_str;
-}
-
-
-Window :: struct {
-	width, height:      int;
-	wc:                 win32.WNDCLASSEXA;
-	dc:                 win32.HDC;
-	hwnd:               win32.HWND;
-	opengl_context, rc: win32.HGLRC;
-	c_title:            []u8;
-}
-
-make_window :: proc(title: string, msg, height: int, window_proc: win32.WNDPROC) -> (Window, bool) {
-	using win32;
-
-	w: Window;
-	w.width, w.height = msg, height;
-
-	class_name := "Win32-Odin-Window\x00";
-	c_class_name := class_name.data;
-	if title[title.count-1] != 0 {
-		w.c_title = to_c_string(title);
-	} else {
-		w.c_title = title as []u8;
-	}
-
-	instance := GetModuleHandleA(nil);
-
-	w.wc = WNDCLASSEXA{
-		size       = size_of(WNDCLASSEXA) as u32,
-		style      = CS_VREDRAW | CS_HREDRAW,
-		instance   = instance as HINSTANCE,
-		class_name = c_class_name,
-		wnd_proc   = window_proc,
-	};
-
-	if RegisterClassExA(^w.wc) == 0 {
-		win32_print_last_error();
-		return w, false;
-	}
-
-	w.hwnd = CreateWindowExA(0,
-	                         c_class_name, w.c_title.data,
-	                         WS_VISIBLE | WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
-	                         CW_USEDEFAULT, CW_USEDEFAULT,
-	                         w.width as i32, w.height as i32,
-	                         nil, nil, instance, nil);
-
-	if w.hwnd == nil {
-		win32_print_last_error();
-		return w, false;
-	}
-
-	w.dc = GetDC(w.hwnd);
-
-	{
-		pfd := PIXELFORMATDESCRIPTOR{
-			size         = size_of(PIXELFORMATDESCRIPTOR) as u32,
-			version      = 1,
-			flags        = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
-			pixel_type   = PFD_TYPE_RGBA,
-			color_bits   = 32,
-			alpha_bits   = 8,
-			depth_bits   = 24,
-			stencil_bits = 8,
-			layer_type   = PFD_MAIN_PLANE,
-		};
-
-		SetPixelFormat(w.dc, ChoosePixelFormat(w.dc, ^pfd), nil);
-		w.opengl_context = wglCreateContext(w.dc);
-		wglMakeCurrent(w.dc, w.opengl_context);
-
-		attribs := [8]i32{
-			WGL_CONTEXT_MAJOR_VERSION_ARB, 2,
-			WGL_CONTEXT_MINOR_VERSION_ARB, 1,
-			WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
-			0, // NOTE(bill): tells the proc that this is the end of attribs
-		};
-
-		wglCreateContextAttribsARB := wglGetProcAddress(("wglCreateContextAttribsARB\x00" as string).data) as wglCreateContextAttribsARBType;
-		w.rc = wglCreateContextAttribsARB(w.dc, 0, ^attribs[0]);
-		wglMakeCurrent(w.dc, w.rc);
-		SwapBuffers(w.dc);
-	}
-
-	return w, true;
-}
-
-destroy_window :: proc(w: ^Window) {
-	free(w.c_title.data);
-}
-
-display_window :: proc(w: ^Window) {
-	win32.SwapBuffers(w.dc);
-}
-
-
-run :: proc() {
-	using win32;
-	using math;
-
-	win32_proc :: proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT #no_inline {
-		if msg == WM_DESTROY || msg == WM_CLOSE || msg == WM_QUIT {
-			os.exit(0);
-			return 0;
-		}
-		return DefWindowProcA(hwnd, msg, wparam, lparam);
-	}
-
-	window, window_success := make_window("Odin Language Demo", 854, 480, win32_proc);
-	if !window_success {
-		return;
-	}
-	defer destroy_window(^window);
-
-	gl.init();
-
-
-	prev_time := time_now();
-	running := true;
-
-	pos := Vec2{100, 100};
-
-	for running {
-		curr_time := time_now();
-		dt := (curr_time - prev_time) as f32;
-		prev_time = curr_time;
-
-		msg: MSG;
-		for PeekMessageA(^msg, nil, 0, 0, PM_REMOVE) > 0 {
-			if msg.message == WM_QUIT {
-				running = false;
-			}
-			TranslateMessage(^msg);
-			DispatchMessageA(^msg);
-		}
-
-		if is_key_down(Key_Code.ESCAPE) {
-			running = false;
-		}
-
-		{
-			SPEED :: 500;
-			v: Vec2;
-
-			if is_key_down(Key_Code.RIGHT) { v[0] += 1; }
-			if is_key_down(Key_Code.LEFT)  { v[0] -= 1; }
-			if is_key_down(Key_Code.UP)    { v[1] += 1; }
-			if is_key_down(Key_Code.DOWN)  { v[1] -= 1; }
-
-			v = vec2_norm0(v);
-
-			pos += v * Vec2{SPEED * dt};
-		}
-
-
-		gl.ClearColor(0.5, 0.7, 1.0, 1.0);
-		gl.Clear(gl.COLOR_BUFFER_BIT);
-
-		gl.LoadIdentity();
-		gl.Ortho(0, window.width as f64,
-		         0, window.height as f64, 0, 1);
-
-		draw_rect :: proc(x, y, w, h: f32) {
-			gl.Begin(gl.TRIANGLES);
-			defer gl.End();
-
-			gl.Color3f(1, 0, 0); gl.Vertex3f(x,   y,   0);
-			gl.Color3f(0, 1, 0); gl.Vertex3f(x+w, y,   0);
-			gl.Color3f(0, 0, 1); gl.Vertex3f(x+w, y+h, 0);
-
-			gl.Color3f(0, 0, 1); gl.Vertex3f(x+w, y+h, 0);
-			gl.Color3f(1, 1, 0); gl.Vertex3f(x,   y+h, 0);
-			gl.Color3f(1, 0, 0); gl.Vertex3f(x,   y,   0);
-		}
-
-		draw_rect(pos.x, pos.y, 50, 50);
-
-		display_window(^window);
-		ms_to_sleep := (16 - 1000*dt) as i32;
-		if ms_to_sleep > 0 {
-			win32.Sleep(ms_to_sleep);
-		}
-	}
-}
@@ -1,180 +0,0 @@
-#import "fmt.odin"
-
-#foreign_system_library "Ws2_32" when ODIN_OS == "windows"
-
-
-SOCKET :: type uint
-INVALID_SOCKET :: ~(0 as SOCKET)
-
-AF :: enum i32 {
-	UNSPEC    = 0,       // unspecified
-	UNIX      = 1,       // local to host (pipes, portals)
-	INET      = 2,       // internetwork: UDP, TCP, etc.
-	IMPLINK   = 3,       // arpanet imp addresses
-	PUP       = 4,       // pup protocols: e.g. BSP
-	CHAOS     = 5,       // mit CHAOS protocols
-	NS        = 6,       // XEROX NS protocols
-	ISO       = 7,       // ISO protocols
-	OSI       = ISO,     // OSI is ISO
-	ECMA      = 8,       // european computer manufacturers
-	DATAKIT   = 9,       // datakit protocols
-	CCITT     = 10,      // CCITT protocols, X.25 etc
-	SNA       = 11,      // IBM SNA
-	DECnet    = 12,      // DECnet
-	DLI       = 13,      // Direct data link interface
-	LAT       = 14,      // LAT
-	HYLINK    = 15,      // NSC Hyperchannel
-	APPLETALK = 16,      // AppleTalk
-	ROUTE     = 17,      // Internal Routing Protocol
-	LINK      = 18,      // Link layer interface
-	XTP       = 19,      // eXpress Transfer Protocol (no AF)
-	COIP      = 20,      // connection-oriented IP, aka ST II
-	CNT       = 21,      // Computer Network Technology
-	RTIP      = 22,      // Help Identify RTIP packets
-	IPX       = 23,      // Novell Internet Protocol
-	SIP       = 24,      // Simple Internet Protocol
-	PIP       = 25,      // Help Identify PIP packets
-	MAX       = 26,
-}
-
-SOCK_STREAM  :: 1
-SOCKET_ERROR :: -1
-IPPROTO_TCP  :: 6
-AI_PASSIVE   :: 0x0020
-SOMAXCONN    :: 128
-
-SD_RECEIVE :: 0
-SD_SEND    :: 1
-SD_BOTH    :: 2
-
-WSADESCRIPTION_LEN :: 256
-WSASYS_STATUS_LEN  :: 128
-WSADATA :: struct #ordered {
-	version:       i16
-	high_version:  i16
-
-
-// NOTE(bill): This is x64 ordering
-	max_sockets:   u16
-	max_udp_dg:    u16
-	vendor_info:   ^byte
-	description:   [WSADESCRIPTION_LEN+1]byte
-	system_status: [WSASYS_STATUS_LEN+1]byte
-}
-
-addrinfo :: struct #ordered {
-	flags:     i32
-	family:    i32
-	socktype:  i32
-	protocol:  i32
-	addrlen:   uint
-	canonname: ^u8
-	addr:      ^sockaddr
-	next:      ^addrinfo
-}
-
-sockaddr :: struct #ordered {
-	family: u16
-	data:   [14]byte
-}
-
-
-WSAStartup      :: proc(version_requested: i16, data: ^WSADATA) -> i32                             #foreign #dll_import
-WSACleanup      :: proc() -> i32                                                                   #foreign #dll_import
-getaddrinfo     :: proc(node_name, service_name: ^u8, hints: ^addrinfo, result: ^^addrinfo) -> i32 #foreign #dll_import
-freeaddrinfo    :: proc(ai: ^addrinfo)                                                             #foreign #dll_import
-socket          :: proc(af, type_, protocol: i32) -> SOCKET                                        #foreign #dll_import
-closesocket     :: proc(s: SOCKET) -> i32                                                          #foreign #dll_import
-bind            :: proc(s: SOCKET, name: ^sockaddr, name_len: i32) -> i32                          #foreign #dll_import
-listen          :: proc(s: SOCKET, back_log: i32) -> i32                                           #foreign #dll_import
-accept          :: proc(s: SOCKET, addr: ^sockaddr, addr_len: i32) -> SOCKET                       #foreign #dll_import
-recv            :: proc(s: SOCKET, buf: ^byte, len: i32, flags: i32) -> i32                        #foreign #dll_import
-send            :: proc(s: SOCKET, buf: ^byte, len: i32, flags: i32) -> i32                        #foreign #dll_import
-shutdown        :: proc(s: SOCKET, how: i32) -> i32                                                #foreign #dll_import
-WSAGetLastError :: proc() -> i32                                                                   #foreign #dll_import
-
-to_c_string :: proc(s: string) -> ^byte {
-	c_str := new_slice(byte, s.count+1)
-	assert(c_str.data != nil)
-	copy(c_str, s as []byte)
-	c_str[s.count] = 0
-	return c_str.data
-}
-
-run :: proc() {
-	wsa: WSADATA
-	res:  ^addrinfo = nil
-	hints: addrinfo
-	s, client: SOCKET
-
-	if WSAStartup(2 | (2 << 8), ^wsa) != 0 {
-		fmt.println("WSAStartup failed: ", WSAGetLastError())
-		return
-	}
-	defer WSACleanup()
-
-	hints.family   = AF.INET as i32
-	hints.socktype = SOCK_STREAM
-	hints.protocol = IPPROTO_TCP
-	hints.flags    = AI_PASSIVE
-
-	if getaddrinfo(nil, to_c_string("8080"), ^hints, ^res) != 0 {
-		fmt.println("getaddrinfo failed: ", WSAGetLastError())
-		return
-	}
-	defer freeaddrinfo(res)
-
-	s = socket(res.family, res.socktype, res.protocol)
-	if s == INVALID_SOCKET {
-		fmt.println("socket failed: ", WSAGetLastError())
-		return
-	}
-	defer closesocket(s)
-
-	bind(s, res.addr, res.addrlen as i32)
-	listen(s, SOMAXCONN)
-
-	client = accept(s, nil, 0)
-	if client == INVALID_SOCKET {
-		fmt.println("socket failed: ", WSAGetLastError())
-		return
-	}
-	defer closesocket(client)
-
-	html :=
-`HTTP/1.1 200 OK
-Connection: close
-Content-type: text/html
-
-<html>
-<head>
-	<title>Demo Title</title>
-</head>
-<body>
-	<h1 style="color: orange;">Odin Server Demo</h1>
-</body>
-</html>
-`
-
-	buf: [1024]byte
-	for {
-		bytes := recv(client, ^buf[0], buf.count as i32, 0)
-		if bytes > 0 {
-			// fmt.println(buf[:bytes] as string)
-			bytes_sent := send(client, html.data, (html.count-1) as i32, 0)
-			if bytes_sent == SOCKET_ERROR {
-				fmt.println("send failed: ", WSAGetLastError())
-				return
-			}
-			break
-		} else if bytes == 0 {
-			fmt.println("Connection closing...")
-			break
-		} else {
-			fmt.println("recv failed: ", WSAGetLastError())
-			return
-		}
-	}
-
-	shutdown(client, SD_SEND)
-}
@@ -1,900 +0,0 @@
-// Demo 002
-#include "basic.odin"
-#include "math.odin"
-// #include "game.odin"
-
-#thread_local tls_int: int
-
-main :: proc() {
-	// Forenotes
-
-	// Semicolons are now optional
-	// Rule for when a semicolon is expected after a statement
-	// - If the next token is not on the same line
-	// - if the next token is a closing brace }
-	// - Otherwise, a semicolon is needed
-	//
-	// Expections:
-	// for, if, match
-	// if x := thing(); x < 123 {}
-	// for i := 0; i < 123; i++ {}
-
-	// Q: Should I use the new rule or go back to the old one without optional semicolons?
-
-
-	// #thread_local - see runtime.odin and above at `tls_int`
-	// #foreign_system_library - see win32.odin
-
-	// struct_compound_literals()
-	// enumerations()
-	// variadic_procedures()
-	// new_builtins()
-	// match_statement()
-	// namespacing()
-	// subtyping()
-	// tagged_unions()
-}
-
-struct_compound_literals :: proc() {
-	Thing :: type struct {
-		id: int
-		x: f32
-		name: string
-	}
-	{
-		t1: Thing
-		t1.id = 1
-
-		t3 := Thing{}
-		t4 := Thing{1, 2, "Fred"}
-		// t5 := Thing{1, 2}
-
-		t6 := Thing{
-			name = "Tom",
-			x    = 23,
-		}
-	}
-}
-
-enumerations :: proc() {
-	{
-		Fruit :: type enum {
-			APPLE,  // 0
-			BANANA, // 1
-			PEAR,   // 2
-		}
-
-		f := Fruit.APPLE
-		// g12: int = Fruit.BANANA
-		g: int = Fruit.BANANA as int
-		// However, you can use enums are index values as _any_ integer allowed
-	}
-	{
-		Fruit1 :: type enum int {
-			APPLE,
-			BANANA,
-			PEAR,
-		}
-
-		Fruit2 :: type enum u8 {
-			APPLE,
-			BANANA,
-			PEAR,
-		}
-
-		Fruit3 :: type enum u8 {
-			APPLE = 1,
-			BANANA, // 2
-			PEAR  = 5,
-			TOMATO, // 6
-		}
-	}
-
-	// Q: remove the need for `type` if it's a record (struct/enum/raw_union/union)?
-}
-
-variadic_procedures :: proc() {
-	print_ints :: proc(args: ..int) {
-		for i := 0; i < len(args); i++ {
-			if i > 0 {
-				print_string(", ")
-			}
-			print_int(args[i])
-		}
-	}
-
-	print_ints(); // nl()
-	print_ints(1); nl()
-	print_ints(1, 2, 3); nl()
-
-	print_prefix_f32s :: proc(prefix: string, args: ..f32) {
-		print_string(prefix)
-		print_string(": ")
-		for i := 0; i < len(args); i++ {
-			if i > 0 {
-				print_string(", ")
-			}
-			print_f32(args[i])
-		}
-	}
-
-	print_prefix_f32s("a"); nl()
-	print_prefix_f32s("b", 1); nl()
-7	print_prefix_f32s("c", 1, 2, 3); nl()
-
-	// Internally, the variadic procedures get allocated to an array on the stack,
-	// and this array is passed a slice
-
-	// This is first step for a `print` procedure but I do not have an `any` type
-	// yet as this requires a few other things first - i.e. introspection
-
-	// NOTE(bill): I haven't yet added the feature of expanding a slice or array into
-	// a variadic a parameter but it's pretty trivial to add
-}
-
-new_builtins :: proc() {
-	{
-		a := new(int)
-		b := new_slice(int, 12)
-		c := new_slice(int, 12, 16)
-
-		defer delete(a)
-		defer delete(b)
-		defer delete(c)
-
-		// NOTE(bill): These use the current context's allocator not the default allocator
-		// see runtime.odin
-
-		// Q: Should this be `free` rather than `delete` and should I overload it for slices too?
-
-		{
-			prev_context := context
-			defer context = prev_context
-			// Q: Should I add a `push_context` feature to the language?
-
-			context.allocator = __default_allocator()
-
-			a := new(int)
-			defer delete(a)
-
-			// Do whatever
-
-		}
-	}
-
-	{
-		a: int = 123
-		b: type_of_val(a) = 321
-
-		// NOTE(bill): This matches the current naming scheme
-		// size_of
-		// align_of
-		// offset_of
-		//
-		// size_of_val
-		// align_of_val
-		// offset_of_val
-		// type_of_val
-	}
-
-	{
-		// Compile time assert
-		COND :: true
-		compile_assert(COND)
-		// compile_assert(!COND)
-
-		// Runtime assert
-		x := true
-		assert(x)
-		// assert(!x)
-	}
-
-	{
-		x: ^u32 = null;
-		y := ptr_offset(x, 100)
-		z := ptr_sub(y, x)
-		w := slice_ptr(x, 12)
-		t := slice_ptr(x, 12, 16)
-
-		// NOTE(bill): These are here because I've removed:
-		// pointer arithmetic
-		// pointer indexing
-		// pointer slicing
-
-		// Reason
-
-		a: [16]int
-		a[1] = 1;
-		b := ^a
-		// Auto pointer deref
-		// consistent with record members
-		assert(b[1] == 1)
-
-		// Q: Should I add them back in at the cost of inconsitency?
-	}
-
-	{
-		a, b := -1, 2
-		print_int(min(a, b)); nl()
-		print_int(max(a, b)); nl()
-		print_int(abs(a)); nl()
-
-		// These work at compile time too
-		A :: -1
-		B :: 2
-		C :: min(A, B)
-		D :: max(A, B)
-		E :: abs(A)
-
-		print_int(C); nl()
-		print_int(D); nl()
-		print_int(E); nl()
-	}
-}
-
-
-match_statement :: proc() {
-	// NOTE(bill): `match` statements are similar to `switch` statements
-	// in other languages but there are few differences
-
-	{
-		match x := 5; x {
-		case 1: // cases must be constant expression
-			print_string("1!\n")
-			// break by default
-
-		case 2:
-			s := "2!\n"; // Each case has its own scope
-			print_string(s)
-			break // explicit break
-
-		case 3, 4: // multiple cases
-			print_string("3 or 4!\n")
-
-		case 5:
-			print_string("5!\n")
-			fallthrough // explicit fallthrough
-
-		default:
-			print_string("default!\n")
-		}
-
-
-
-		match x := 1.5; x {
-		case 1.5:
-			print_string("1.5!\n")
-			// break by default
-		case MATH_TAU:
-			print_string("τ!\n")
-		default:
-			print_string("default!\n")
-		}
-
-
-
-		match x := "Hello"; x {
-		case "Hello":
-			print_string("greeting\n")
-			// break by default
-		case "Goodbye":
-			print_string("farewell\n")
-		default:
-			print_string("???\n")
-		}
-
-
-
-
-
-
-		a := 53
-		match {
-		case a == 1:
-			print_string("one\n")
-		case a == 2:
-			print_string("a couple\n")
-		case a < 7, a == 7:
-			print_string("a few\n")
-		case a < 12: // intentional bug
-			print_string("several\n")
-		case a >= 12 && a < 100:
-			print_string("dozens\n")
-		case a >= 100 && a < 1000:
-			print_string("hundreds\n")
-		default:
-			print_string("a fuck ton\n")
-		}
-
-		// Identical to this
-
-		b := 53
-		if b == 1 {
-			print_string("one\n")
-		} else if b == 2 {
-			print_string("a couple\n")
-		} else if b < 7 || b == 7 {
-			print_string("a few\n")
-		} else if b < 12 { // intentional bug
-			print_string("several\n")
-		} else if b >= 12 && b < 100 {
-			print_string("dozens\n")
-		} else if b >= 100 && b < 1000 {
-			print_string("hundreds\n")
-		} else {
-			print_string("a fuck ton\n")
-		}
-
-		// However, match statements allow for `break` and `fallthrough` unlike
-		// an if statement
-	}
-}
-
-Vector3 :: type struct {
-	x, y, z: f32
-}
-
-print_floats :: proc(args: ..f32) {
-	for i := 0; i < len(args); i++ {
-		if i > 0 {
-			print_string(", ")
-		}
-		print_f32(args[i])
-	}
-	print_nl()
-}
-
-namespacing :: proc() {
-	{
-		Thing :: type struct {
-			x: f32
-			name: string
-		}
-
-		a: Thing
-		a.x = 3
-		{
-			Thing :: type struct {
-				y: int
-				test: bool
-			}
-
-			b: Thing // Uses this scope's Thing
-			b.test = true
-		}
-	}
-
-	{
-		Entity :: type struct {
-			Guid :: type int
-			Nested :: type struct {
-				MyInt :: type int
-				i: int
-			}
-
-			CONSTANT :: 123
-
-
-			guid:   Guid
-			name:   string
-			pos:    Vector3
-			vel:    Vector3
-			nested: Nested
-		}
-
-		guid: Entity.Guid = Entity.CONSTANT
-		i: Entity.Nested.MyInt
-
-
-
-		{
-			using Entity
-			guid: Guid = CONSTANT
-			using Nested
-			i: MyInt
-		}
-
-
-		{
-			using Entity.Nested
-			guid: Entity.Guid = Entity.CONSTANT
-			i: MyInt
-		}
-
-
-		{
-			e: Entity
-			using e
-			guid = 27832
-			name = "Bob"
-
-			print_int(e.guid as int); nl()
-			print_string(e.name); nl()
-		}
-
-		{
-			using e: Entity
-			guid = 78456
-			name = "Thing"
-
-			print_int(e.guid as int); nl()
-			print_string(e.name); nl()
-		}
-	}
-
-	{
-		Entity :: type struct {
-			Guid :: type int
-			Nested :: type struct {
-				MyInt :: type int
-				i: int
-			}
-
-			CONSTANT :: 123
-
-
-			guid:      Guid
-			name:      string
-			using pos: Vector3
-			vel:       Vector3
-			using nested: ^Nested
-		}
-
-		e := Entity{nested = new(Entity.Nested)}
-		e.x = 123
-		e.i = Entity.CONSTANT
-	}
-
-
-
-	{
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		print_pos_1 :: proc(entity: ^Entity) {
-			print_string("print_pos_1: ")
-			print_floats(entity.position.x, entity.position.y, entity.position.z)
-		}
-
-		print_pos_2 :: proc(entity: ^Entity) {
-			using entity
-			print_string("print_pos_2: ")
-			print_floats(position.x, position.y, position.z)
-		}
-
-		print_pos_3 :: proc(using entity: ^Entity) {
-			print_string("print_pos_3: ")
-			print_floats(position.x, position.y, position.z)
-		}
-
-		print_pos_4 :: proc(using entity: ^Entity) {
-			using position
-			print_string("print_pos_4: ")
-			print_floats(x, y, z)
-		}
-
-		e := Entity{position = Vector3{1, 2, 3}}
-		print_pos_1(^e)
-		print_pos_2(^e)
-		print_pos_3(^e)
-		print_pos_4(^e)
-
-		// This is similar to C++'s `this` pointer that is implicit and only available in methods
-	}
-}
-
-subtyping :: proc() {
-	{
-		// C way for subtyping/subclassing
-
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		Frog :: type struct {
-			entity: Entity
-			jump_height: f32
-		}
-
-		f: Frog
-		f.entity.position = Vector3{1, 2, 3}
-
-		using f.entity
-		position = Vector3{1, 2, 3}
-
-	}
-
-	{
-		// C++ way for subtyping/subclassing
-
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		Frog :: type struct {
-			using entity: Entity
-			jump_height: f32
-		}
-
-		f: Frog
-		f.position = Vector3{1, 2, 3}
-
-
-		print_pos :: proc(using entity: Entity) {
-			print_string("print_pos: ")
-			print_floats(position.x, position.y, position.z)
-		}
-
-		print_pos(f.entity)
-		print_pos(f)
-
-		// Subtype Polymorphism
-	}
-
-	{
-		// More than C++ way for subtyping/subclassing
-
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		Frog :: type struct {
-			jump_height: f32
-			using entity: ^Entity // Doesn't have to be first member!
-		}
-
-		f: Frog
-		f.entity = new(Entity)
-		f.position = Vector3{1, 2, 3}
-
-
-		print_pos :: proc(using entity: ^Entity) {
-			print_string("print_pos: ")
-			print_floats(position.x, position.y, position.z)
-		}
-
-		print_pos(f.entity)
-		print_pos(^f)
-		print_pos(f)
-	}
-
-	{
-		// More efficient subtyping
-
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		Frog :: type struct {
-			jump_height: f32
-			using entity: ^Entity
-		}
-
-		MAX_ENTITES :: 64
-		entities: [MAX_ENTITES]Entity
-		entity_count := 0
-
-		next_entity :: proc(entities: []Entity, entity_count: ^int) -> ^Entity {
-			e := ^entities[entity_count^]
-			entity_count^++
-			return e
-		}
-
-		f: Frog
-		f.entity = next_entity(entities[:], ^entity_count)
-		f.position = Vector3{3, 4, 6}
-
-		using f.position
-		print_floats(x, y, z)
-	}
-
-	{
-		// Down casting
-
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		Frog :: type struct {
-			jump_height: f32
-			using entity: Entity
-		}
-
-		f: Frog
-		f.jump_height = 564
-		e := ^f.entity
-
-		frog := e down_cast ^Frog
-		print_string("down_cast: ")
-		print_f32(frog.jump_height); nl()
-
-		// NOTE(bill): `down_cast` is unsafe and there are not check are compile time or run time
-		// Q: Should I completely remove `down_cast` as I added it in about 30 minutes
-	}
-
-	{
-		// Multiple "inheritance"/subclassing
-
-		Entity :: type struct {
-			position: Vector3
-		}
-		Climber :: type struct {
-			speed: f32
-		}
-
-		Frog :: type struct {
-			using entity:  Entity
-			using climber: Climber
-		}
-	}
-}
-
-tagged_unions :: proc() {
-	{
-		EntityKind :: type enum {
-			INVALID,
-			FROG,
-			GIRAFFE,
-			HELICOPTER,
-		}
-
-		Entity :: type struct {
-			kind: EntityKind
-			using data: raw_union {
-				frog: struct {
-					jump_height: f32
-					colour: u32
-				}
-				giraffe: struct {
-					neck_length: f32
-					spot_count: int
-				}
-				helicopter: struct {
-					blade_count: int
-					weight: f32
-					pilot_name: string
-				}
-			}
-		}
-
-		e: Entity
-		e.kind = EntityKind.FROG
-		e.frog.jump_height = 12
-
-		f: type_of_val(e.frog);
-
-		// But this is very unsafe and extremely cumbersome to write
-		// In C++, I use macros to alleviate this but it's not a solution
-	}
-
-	{
-		Entity :: type union {
-			Frog: struct {
-				jump_height: f32
-				colour: u32
-			}
-			Giraffe: struct {
-				neck_length: f32
-				spot_count: int
-			}
-			Helicopter: struct {
-				blade_count: int
-				weight: f32
-				pilot_name: string
-			}
-		}
-
-		using Entity
-		f1: Frog = Frog{12, 0xff9900}
-		f2: Entity = Frog{12, 0xff9900} // Implicit cast
-		f3 := Frog{12, 0xff9900} as Entity // Explicit cast
-
-		// f3.Frog.jump_height = 12 // There are "members" of a union
-
-
-
-		e, f, g, h: Entity
-		f = Frog{12, 0xff9900}
-		g = Giraffe{2.1, 23}
-		h = Helicopter{4, 1000, "Frank"}
-
-
-
-
-		// Requires a pointer to the union
-		// `x` will be a pointer to type of the case
-
-		match type x : ^f {
-		case Frog:
-			print_string("Frog!\n")
-			print_f32(x.jump_height); nl()
-			x.jump_height = 3
-			print_f32(x.jump_height); nl()
-		case Giraffe:
-			print_string("Giraffe!\n")
-		case Helicopter:
-			print_string("ROFLCOPTER!\n")
-		default:
-			print_string("invalid entity\n")
-		}
-
-
-		// Q: Allow for a non pointer version with takes a copy instead?
-		// Or it takes the pointer the data and not a copy
-
-
-		fp := ^f as ^Frog // Unsafe
-		print_f32(fp.jump_height); nl()
-
-
-		// Internals of a tagged union
-		/*
-			struct {
-				data: [size_of_biggest_tag]u8
-				tag_index: int
-			}
-		*/
-		// This is to allow for pointer casting if needed
-
-
-		// Advantage over subtyping version
-		MAX_ENTITES :: 64
-		entities: [MAX_ENTITES]Entity
-
-		entities[0] = Frog{}
-		entities[1] = Helicopter{}
-		// etc.
-	}
-
-
-	{
-		// Transliteration of code from this actual compiler
-		// Some stuff is missing
-		Type       :: type struct {}
-		Scope      :: type struct {}
-		Token      :: type struct {}
-		AstNode    :: type struct {}
-		ExactValue :: type struct {}
-
-		EntityKind :: type enum {
-			Invalid,
-			Constant,
-			Variable,
-			UsingVariable,
-			TypeName,
-			Procedure,
-			Builtin,
-			Count,
-		}
-
-		Entity :: type struct {
-			Guid :: type i64
-
-			kind: EntityKind
-			guid: Guid
-
-			scope: ^Scope
-			token: Token
-			type_: ^Type
-
-			using data: raw_union {
-				Constant: struct {
-					value: ExactValue
-				}
-				Variable: struct {
-					visited:   bool // Cycle detection
-					used:      bool // Variable is used
-					is_field:  bool // Is struct field
-					anonymous: bool // Variable is an anonymous
-				}
-				UsingVariable: struct {
-				}
-				TypeName: struct {
-				}
-				Procedure: struct {
-					used: bool
-				}
-				Builtin: struct {
-					id: int
-				}
-			}
-		}
-
-		// Plus all the constructing procedures that go along with them!!!!
-		// It's a nightmare
-	}
-
-	{
-		Type       :: type struct {}
-		Scope      :: type struct {}
-		Token      :: type struct {}
-		AstNode    :: type struct {}
-		ExactValue :: type struct {}
-
-
-		Entity :: type union {
-			Base :: type struct {
-				Guid :: type i64
-				guid: Guid
-
-				scope: ^Scope
-				token: Token
-				type_: ^Type
-			}
-
-
-			Constant: struct {
-				using base: Base
-				value: ExactValue
-			}
-			Variable: struct {
-				using base: Base
-				visited:   bool // Cycle detection
-				used:      bool // Variable is used
-				is_field:  bool // Is struct field
-				anonymous: bool // Variable is an anonymous
-			}
-			UsingVariable: struct {
-				using base: Base
-			}
-			TypeName: struct {
-				using base: Base
-			}
-			Procedure: struct {
-				using base: Base
-				used: bool
-			}
-			Builtin: struct {
-				using base: Base
-				id: int
-			}
-		}
-
-		using Entity
-
-		e: Entity
-
-		e = Variable{
-			base = Base{},
-			used = true,
-			anonymous = false,
-		}
-
-
-
-		// Q: Allow a "base" type to be added to a union?
-		// Or even `using` on union to get the same properties?
-	}
-
-
-	{
-		// `Raw` unions still have uses, especially for mathematic types
-
-		Vector2 :: type raw_union {
-			using xy_: struct { x, y: f32 }
-			e: [2]f32
-			v: {2}f32
-		}
-
-		Vector3 :: type raw_union {
-			using xyz_: struct { x, y, z: f32 }
-			xy: Vector2
-			e: [3]f32
-			v: {3}f32
-		}
-
-		v2: Vector2
-		v2.x = 1
-		v2.e[0] = 1
-		v2.v[0] = 1
-
-		v3: Vector3
-		v3.x = 1
-		v3.e[0] = 1
-		v3.v[0] = 1
-		v3.xy.x = 1
-	}
-}
-
-nl :: proc() { print_nl() }
@@ -1,482 +0,0 @@
-#import "win32.odin"
-#import "fmt.odin"
-#import "os.odin"
-
-CANVAS_WIDTH  :: 128
-CANVAS_HEIGHT :: 128
-CANVAS_SCALE  :: 3
-FRAME_TIME    :: 1.0/30.0
-WINDOW_TITLE  :: "Punity\x00"
-
-_ := compile_assert(CANVAS_WIDTH % 16 == 0)
-
-WINDOW_WIDTH  :: CANVAS_WIDTH  * CANVAS_SCALE
-WINDOW_HEIGHT :: CANVAS_HEIGHT * CANVAS_SCALE
-
-
-STACK_CAPACITY   :: 1<<20
-STORAGE_CAPACITY :: 1<<20
-
-DRAW_LIST_RESERVE :: 128
-
-MAX_KEYS :: 256
-
-Core :: struct {
-	stack:   ^Bank
-	storage: ^Bank
-
-	running:       bool
-	key_modifiers: u32
-	key_states:    [MAX_KEYS]byte
-	key_deltas:    [MAX_KEYS]byte
-
-	perf_frame,
-	perf_frame_inner,
-	perf_step,
-	perf_audio,
-	perf_blit,
-	perf_blit_cvt,
-	perf_blit_gdi: Perf_Span
-
-	frame: i64
-
-	canvas:    Canvas
-	draw_list: ^Draw_List
-}
-
-Perf_Span :: struct {
-	stamp: f64
-	delta: f32
-}
-
-Bank :: struct {
-	memory: []byte
-	cursor: int
-}
-
-Bank_State :: struct {
-	state: Bank
-	bank: ^Bank
-}
-
-
-Color :: raw_union {
-	using channels: struct{ a, b, g, r: byte; }
-	rgba: u32
-}
-
-Palette :: struct {
-	colors: [256]Color
-	colors_count: byte
-}
-
-
-Rect :: raw_union {
-	using minmax: struct {
-		min_x, min_y, max_x, max_y: int
-	}
-	using pos: struct {
-		left, top, right, bottom: int
-	}
-	e: [4]int
-}
-
-Bitmap :: struct {
-	pixels: []byte
-	width:  int
-	height: int
-}
-
-Font :: struct {
-	using bitmap: Bitmap
-	char_width:   int
-	char_height:  int
-}
-
-Canvas :: struct {
-	using bitmap: ^Bitmap
-	palette:      Palette
-	translate_x:  int
-	translate_y:  int
-	clip:         Rect
-	font:         ^Font
-}
-
-DrawFlag :: enum {
-	NONE   = 0,
-	FLIP_H = 1<<0,
-	FLIP_V = 1<<1,
-	MASK   = 1<<2,
-}
-
-
-Draw_List :: struct {
-	Item :: struct {
-
-	}
-	items: []Item
-}
-
-Key :: enum {
-	MOD_SHIFT   = 0x0001,
-	MOD_CONTROL = 0x0002,
-	MOD_ALT     = 0x0004,
-	MOD_SUPER   = 0x0008,
-
-	UNKNOWN            =-1,
-	INVALID            =-2,
-
-	LBUTTON            = 1,
-	RBUTTON            = 2,
-	CANCEL             = 3,
-	MBUTTON            = 4,
-
-	BACK               = 8,
-	TAB                = 9,
-	CLEAR              = 12,
-	RETURN             = 13,
-	SHIFT              = 16,
-	CONTROL            = 17,
-	MENU               = 18,
-	PAUSE              = 19,
-	CAPITAL            = 20,
-	KANA               = 0x15,
-	HANGEUL            = 0x15,
-	HANGUL             = 0x15,
-	JUNJA              = 0x17,
-	FINAL              = 0x18,
-	HANJA              = 0x19,
-	KANJI              = 0x19,
-	ESCAPE             = 0x1B,
-	CONVERT            = 0x1C,
-	NONCONVERT         = 0x1D,
-	ACCEPT             = 0x1E,
-	MODECHANGE         = 0x1F,
-	SPACE              = 32,
-	PRIOR              = 33,
-	NEXT               = 34,
-	END                = 35,
-	HOME               = 36,
-	LEFT               = 37,
-	UP                 = 38,
-	RIGHT              = 39,
-	DOWN               = 40,
-	SELECT             = 41,
-	PRINT              = 42,
-	EXEC               = 43,
-	SNAPSHOT           = 44,
-	INSERT             = 45,
-	DELETE             = 46,
-	HELP               = 47,
-	LWIN               = 0x5B,
-	RWIN               = 0x5C,
-	APPS               = 0x5D,
-	SLEEP              = 0x5F,
-	NUMPAD0            = 0x60,
-	NUMPAD1            = 0x61,
-	NUMPAD2            = 0x62,
-	NUMPAD3            = 0x63,
-	NUMPAD4            = 0x64,
-	NUMPAD5            = 0x65,
-	NUMPAD6            = 0x66,
-	NUMPAD7            = 0x67,
-	NUMPAD8            = 0x68,
-	NUMPAD9            = 0x69,
-	MULTIPLY           = 0x6A,
-	ADD                = 0x6B,
-	SEPARATOR          = 0x6C,
-	SUBTRACT           = 0x6D,
-	DECIMAL            = 0x6E,
-	DIVIDE             = 0x6F,
-	F1                 = 0x70,
-	F2                 = 0x71,
-	F3                 = 0x72,
-	F4                 = 0x73,
-	F5                 = 0x74,
-	F6                 = 0x75,
-	F7                 = 0x76,
-	F8                 = 0x77,
-	F9                 = 0x78,
-	F10                = 0x79,
-	F11                = 0x7A,
-	F12                = 0x7B,
-	F13                = 0x7C,
-	F14                = 0x7D,
-	F15                = 0x7E,
-	F16                = 0x7F,
-	F17                = 0x80,
-	F18                = 0x81,
-	F19                = 0x82,
-	F20                = 0x83,
-	F21                = 0x84,
-	F22                = 0x85,
-	F23                = 0x86,
-	F24                = 0x87,
-	NUMLOCK            = 0x90,
-	SCROLL             = 0x91,
-	LSHIFT             = 0xA0,
-	RSHIFT             = 0xA1,
-	LCONTROL           = 0xA2,
-	RCONTROL           = 0xA3,
-	LMENU              = 0xA4,
-	RMENU              = 0xA5,
-
-	APOSTROPHE         = 39,  /* ' */
-	COMMA              = 44,  /* , */
-	MINUS              = 45,  /* - */
-	PERIOD             = 46,  /* . */
-	SLASH              = 47,  /* / */
-	NUM0               = 48,
-	NUM1               = 49,
-	NUM2               = 50,
-	NUM3               = 51,
-	NUM4               = 52,
-	NUM5               = 53,
-	NUM6               = 54,
-	NUM7               = 55,
-	NUM8               = 56,
-	NUM9               = 57,
-	SEMICOLON          = 59,  /* ; */
-	EQUAL              = 61,  /* = */
-	A                  = 65,
-	B                  = 66,
-	C                  = 67,
-	D                  = 68,
-	E                  = 69,
-	F                  = 70,
-	G                  = 71,
-	H                  = 72,
-	I                  = 73,
-	J                  = 74,
-	K                  = 75,
-	L                  = 76,
-	M                  = 77,
-	N                  = 78,
-	O                  = 79,
-	P                  = 80,
-	Q                  = 81,
-	R                  = 82,
-	S                  = 83,
-	T                  = 84,
-	U                  = 85,
-	V                  = 86,
-	W                  = 87,
-	X                  = 88,
-	Y                  = 89,
-	Z                  = 90,
-	LEFT_BRACKET       = 91,  /* [ */
-	BACKSLASH          = 92,  /* \ */
-	RIGHT_BRACKET      = 93,  /* ] */
-	GRAVE_ACCENT       = 96,  /* ` */
-}
-
-
-key_down :: proc(k: Key) -> bool {
-	return _core.key_states[k] != 0
-}
-
-key_pressed :: proc(k: Key) -> bool {
-	return (_core.key_deltas[k] != 0) && key_down(k)
-}
-
-
-
-
-win32_perf_count_freq := win32.GetQueryPerformanceFrequency()
-time_now :: proc() -> f64 {
-	assert(win32_perf_count_freq != 0)
-
-	counter: i64
-	win32.QueryPerformanceCounter(^counter)
-	result := counter as f64 / win32_perf_count_freq as f64
-	return result
-}
-
-_core: Core
-
-run :: proc(user_init, user_step: proc(c: ^Core)) {
-	using win32
-
-	_core.running = true
-
-	win32_proc :: proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT #no_inline #stdcall {
-		win32_app_key_mods :: proc() -> u32 {
-			mods: u32 = 0
-
-			if is_key_down(Key_Code.SHIFT) {
-				mods |= Key.MOD_SHIFT as u32
-			}
-			if is_key_down(Key_Code.CONTROL) {
-				mods |= Key.MOD_CONTROL as u32
-			}
-			if is_key_down(Key_Code.MENU) {
-				mods |= Key.MOD_ALT as u32
-			}
-			if is_key_down(Key_Code.LWIN) || is_key_down(Key_Code.RWIN) {
-				mods |= Key.MOD_SUPER as u32
-			}
-
-			return mods
-		}
-
-		match msg {
-		case WM_KEYDOWN:
-			_core.key_modifiers = win32_app_key_mods()
-			if wparam < MAX_KEYS {
-				_core.key_states[wparam] = 1
-				_core.key_deltas[wparam] = 1
-			}
-			return 0
-
-		case WM_KEYUP:
-			_core.key_modifiers = win32_app_key_mods()
-			if wparam < MAX_KEYS {
-				_core.key_states[wparam] = 0
-				_core.key_deltas[wparam] = 1
-			}
-			return 0
-
-		case WM_CLOSE:
-			PostQuitMessage(0)
-			_core.running = false
-			return 0
-		}
-
-		return DefWindowProcA(hwnd, msg, wparam, lparam)
-	}
-
-
-	window_class := WNDCLASSEXA{
-		class_name = ("Punity\x00" as string).data, // C-style string
-		size       = size_of(WNDCLASSEXA) as u32,
-		style      = CS_HREDRAW | CS_VREDRAW | CS_OWNDC,
-		instance   = GetModuleHandleA(nil) as HINSTANCE,
-		wnd_proc   = win32_proc,
-		// wnd_proc   = DefWindowProcA,
-		background = GetStockObject(BLACK_BRUSH) as HBRUSH,
-	}
-
-	if RegisterClassExA(^window_class) == 0 {
-		fmt.fprintln(os.stderr, "RegisterClassExA failed")
-		return
-	}
-
-	screen_width  := GetSystemMetrics(SM_CXSCREEN)
-	screen_height := GetSystemMetrics(SM_CYSCREEN)
-
-	rc: RECT
-	rc.left   = (screen_width - WINDOW_WIDTH)   / 2
-	rc.top    = (screen_height - WINDOW_HEIGHT) / 2
-	rc.right  = rc.left + WINDOW_WIDTH
-	rc.bottom = rc.top + WINDOW_HEIGHT
-
-	style: u32 = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX
-	assert(AdjustWindowRect(^rc, style, 0) != 0)
-
-	wt := WINDOW_TITLE
-
-	win32_window := CreateWindowExA(0,
-	                                window_class.class_name,
-	                                wt.data,
-	                                style,
-	                                rc.left, rc.top,
-	                                rc.right-rc.left, rc.bottom-rc.top,
-	                                nil, nil, window_class.instance,
-	                                nil)
-
-	if win32_window == nil {
-		fmt.fprintln(os.stderr, "CreateWindowExA failed")
-		return
-	}
-
-
-	window_bmi: BITMAPINFO
-	window_bmi.size        = size_of(BITMAPINFO.HEADER) as u32
-	window_bmi.width       = CANVAS_WIDTH
-	window_bmi.height      = CANVAS_HEIGHT
-	window_bmi.planes      = 1
-	window_bmi.bit_count   = 32
-	window_bmi.compression = BI_RGB
-
-
-	user_init(^_core)
-
-
-	ShowWindow(win32_window, SW_SHOW)
-
-	window_buffer := new_slice(u32, CANVAS_WIDTH * CANVAS_HEIGHT)
-	assert(window_buffer.data != nil)
-	defer free(window_buffer.data)
-
-	for i := 0; i < window_buffer.count; i++ {
-		window_buffer[i] = 0xff00ff
-	}
-
-
-	prev_time, curr_time,dt: f64
-	prev_time = time_now()
-	curr_time = time_now()
-	total_time : f64 = 0
-	offset_x := 0
-	offset_y := 0
-
-	message: MSG
-	for _core.running {
-		curr_time = time_now()
-		dt = curr_time - prev_time
-		prev_time = curr_time
-		total_time += dt
-
-		offset_x += 1
-		offset_y += 2
-
-		{
-			data: [128]byte
-			buf := data[:0]
-			fmt.bprintf(^buf, "Punity: % ms\x00", dt*1000)
-			win32.SetWindowTextA(win32_window, buf.data)
-		}
-
-
-		for y := 0; y < CANVAS_HEIGHT; y++ {
-			for x := 0; x < CANVAS_WIDTH; x++ {
-				g := (x % 32) * 8
-				b := (y % 32) * 8
-				window_buffer[x + y*CANVAS_WIDTH] = (g << 8 | b) as u32
-			}
-		}
-
-		_core.key_deltas = nil
-
-		for PeekMessageA(^message, nil, 0, 0, PM_REMOVE) != 0 {
-			if message.message == WM_QUIT {
-				_core.running = false
-			}
-			TranslateMessage(^message)
-			DispatchMessageA(^message)
-		}
-
-		user_step(^_core)
-
-		dc := GetDC(win32_window)
-		StretchDIBits(dc,
-		              0, 0, CANVAS_WIDTH * CANVAS_SCALE, CANVAS_HEIGHT * CANVAS_SCALE,
-		              0, 0, CANVAS_WIDTH, CANVAS_HEIGHT,
-		              window_buffer.data,
-		              ^window_bmi,
-		              DIB_RGB_COLORS,
-		              SRCCOPY)
-		ReleaseDC(win32_window, dc)
-
-
-		{
-			delta := time_now() - prev_time
-			ms := ((FRAME_TIME - delta) * 1000) as i32
-			if ms > 0 {
-				win32.Sleep(ms)
-			}
-		}
-
-		_core.frame++
-	}
-}
@@ -1,5 +0,0 @@
-#import "fmt.odin" as fmt
-
-thing :: proc() {
-	fmt.println("Sub Hello!")
-}
@@ -1,35 +0,0 @@
-/*#import "fmt.odin"
-
-thing :: proc() {
-	fmt.println("Hello1!")
-}*/
-
-
-#import "fmt.odin" as format
-
-thing :: proc() {
-	format.println("Hello2!")
-}
-
-
-/*#import "fmt.odin" as .
-
-thing :: proc() {
-	println("Hello3!")
-}
-
-
-*/
-/*#import "fmt.odin" as _
-
-thing :: proc() {
-	// println("Hello4!")
-}
-*/
-
-/*
-#include "fmt.odin"
-
-thing :: proc() {
-	println("Hello5!")
-}*/
@@ -1,158 +1,112 @@
-#shared_global_scope;
+#shared_global_scope
+
+/*
+@(link_name="__multi3")
+__multi3 :: proc "c" (a, b: u128) -> u128 {
+	bits_in_dword_2 :: size_of(i64) * 4;
+	lower_mask :: u128(~u64(0) >> bits_in_dword_2);


-// import "fmt.odin";
+	when ODIN_ENDIAN == "big" {
+		TWords :: struct #raw_union {
+			all: u128,
+			using _: struct {lo, hi: u64},
+		};
+	} else {
+		TWords :: struct #raw_union {
+			all: u128,
+			using _: struct {hi, lo: u64},
+		};
+	}

-// proc __u128_mod(a, b: u128) -> u128 #link_name "__umodti3" {
-// 	var _, r := __u128_quo_mod(a, b)
-// 	return r
-// }
+	r: TWords;
+	t: u64;

-// proc __u128_quo(a, b: u128) -> u128 #link_name "__udivti3" {
-// 	var n, _ := __u128_quo_mod(a, b)
-// 	return n
-// }
+	r.lo =  u64(a & lower_mask) * u64(b & lower_mask);
+	t    =  r.lo >> bits_in_dword_2;
+	r.lo &= u64(lower_mask);
+	t    += u64(a >> bits_in_dword_2) * u64(b & lower_mask);
+	r.lo += u64(t & u64(lower_mask)) << bits_in_dword_2;
+	r.hi =  t >> bits_in_dword_2;
+	t    =  r.lo >> bits_in_dword_2;
+	r.lo &= u64(lower_mask);
+	t    += u64(b >> bits_in_dword_2) * u64(a & lower_mask);
+	r.lo += u64(t & u64(lower_mask)) << bits_in_dword_2;
+	r.hi += t >> bits_in_dword_2;
+	r.hi += u64(a >> bits_in_dword_2) * u64(b >> bits_in_dword_2);
+	return r.all;
+}

-// proc __i128_mod(a, b: i128) -> i128 #link_name "__modti3" {
-// 	var _, r := __i128_quo_mod(a, b)
-// 	return r
-// }
+@(link_name="__umodti3")
+__u128_mod :: proc "c" (a, b: u128) -> u128 {
+	r: u128;
+	__u128_quo_mod(a, b, &r);
+	return r;
+}

-// proc __i128_quo(a, b: i128) -> i128 #link_name "__divti3" {
-// 	var n, _ := __i128_quo_mod(a, b)
-// 	return n
-// }
+@(link_name="__udivti3")
+__u128_quo :: proc "c" (a, b: u128) -> u128 {
+	return __u128_quo_mod(a, b, nil);
+}

-// proc __i128_quo_mod(a, b: i128) -> (i128, i128) #link_name "__divmodti4" {
-// 	var s := b >> 127
-// 	b = (b ~ s) - s
-// 	s = a >> 127
-// 	a = (a ~ s) - s
+@(link_name="__modti3")
+__i128_mod :: proc "c" (a, b: i128) -> i128 {
+	r: i128;
+	__i128_quo_mod(a, b, &r);
+	return r;
+}

-// 	var n, r := __u128_quo_mod(a as u128, b as u128)
-// 	return (n as i128 ~ s) - s, (r as i128 ~ s) - s
-// }
+@(link_name="__divti3")
+__i128_quo :: proc "c" (a, b: i128) -> i128 {
+	return __i128_quo_mod(a, b, nil);
+}
+
+@(link_name="__divmodti4")
+__i128_quo_mod :: proc "c" (a, b: i128, rem: ^i128) -> (quo: i128) {
+	s: i128;
+	s = b >> 127;
+	b = (b~s) - s;
+	s = a >> 127;
+	b = (a~s) - s;
+
+	uquo: u128;
+	urem := __u128_quo_mod(transmute(u128)a, transmute(u128)b, &uquo);
+	iquo := transmute(i128)uquo;
+	irem := transmute(i128)urem;
+
+	iquo = (iquo~s) - s;
+	irem = (irem~s) - s;
+	if rem != nil do rem^ = irem;
+	return iquo;
+}


-// proc __u128_quo_mod(a, b: u128) -> (u128, u128) #link_name "__udivmodti4" {
-// 	proc clz(x: u64) -> u64 {
-// 		proc clz_u64(x: u64, is_zero_undef: bool) -> u64 #foreign "llvm.ctlz.i64"
-// 		return clz_u64(x, false)
-// 	}
-// 	proc ctz(x: u64) -> u64 {
-// 		proc ctz_u64(x: u64, is_zero_undef: bool) -> u64 #foreign "llvm.cttz.i64"
-// 		return ctz_u64(x, false)
-// 	}
+@(link_name="__udivmodti4")
+__u128_quo_mod :: proc "c" (a, b: u128, rem: ^u128) -> (quo: u128) {
+	alo := u64(a);
+	blo := u64(b);
+	if b == 0 {
+		if rem != nil do rem^ = 0;
+		return u128(alo/blo);
+	}

+	r, d, x, q: u128 = a, b, 1, 0;

-// 	u128_lo_hi :: raw_union {
-// 		all: u128
-// 		using _lohi: struct {lo, hi: u64;}
-// 	}
+	for r >= d && (d>>127)&1 == 0 {
+		x <<= 1;
+		d <<= 1;
+	}

-// 	n, d, q, r: u128_lo_hi
-// 	sr: u64
-
-// 	n.all = a
-// 	d.all = b
-
-// 	if n.hi == 0 {
-// 		if d.hi == 0 {
-// 			return (n.lo / d.lo) as u128, (n.lo % d.lo) as u128
-// 		}
-// 		return 0, n.lo as u128
-// 	}
-// 	if d.lo == 0 {
-// 		if d.hi == 0 {
-// 			return (n.hi / d.lo) as u128, (n.hi % d.lo) as u128
-// 		}
-// 		if n.lo == 0 {
-// 			r.hi = n.hi % d.hi
-// 			r.lo = 0
-// 			return (n.hi / d.hi) as u128, r.all
-// 		}
-// 		if (d.hi & (d.hi-1)) == 0 {
-// 			r.lo = n.lo
-// 			r.hi = n.hi & (d.hi-1)
-// 			return (n.hi >> ctz(d.hi)) as u128, r.all
-// 		}
-
-// 		sr = clz(d.hi) - clz(n.hi)
-// 		if sr > 64 - 2 {
-// 			return 0, n.all
-// 		}
-// 		sr++
-// 		q.lo = 0
-// 		q.hi = n.lo << (64-sr)
-// 		r.hi = n.hi >> sr
-// 		r.lo = (n.hi << (64-sr)) | (n.lo >> sr)
-// 	} else {
-// 		if d.hi == 0 {
-// 			if (d.lo & (d.lo - 1)) == 0 {
-// 				var rem := (n.lo % (d.lo - 1)) as u128
-// 				if d.lo == 1 {
-// 					return n.all, rem
-// 				}
-// 				sr = ctz(d.lo)
-// 				q.hi = n.hi >> sr
-// 				q.lo = (n.hi << (64-sr)) | (n.lo >> sr)
-// 				return q.all, rem
-// 			}
-
-// 			sr = 1 + 64 + clz(d.lo) - clz(n.hi)
-
-// 			q.all = n.all << (128-sr)
-// 			r.all = n.all >> sr
-// 			if sr == 64 {
-// 				q.lo = 0
-// 				q.hi = n.lo
-// 				r.hi = 0
-// 				r.lo = n.hi
-// 			} else if sr < 64 {
-// 				q.lo = 0
-// 				q.hi = n.lo << (64-sr)
-// 				r.hi = n.hi >> sr
-// 				r.lo = (n.hi << (64-sr)) | (n.lo >> sr)
-// 			} else {
-// 				q.lo = n.lo << (128-sr)
-// 				q.hi = (n.hi << (128-sr)) | (n.lo >> (sr-64))
-// 				r.hi = 0
-// 				r.lo = n.hi >> (sr-64)
-// 			}
-// 		} else {
-// 			sr = clz(d.hi) - clz(n.hi)
-// 			if sr > 64-1 {
-// 				return 0, n.all
-// 			}
-// 			sr++
-// 			q.lo = 0
-// 			q.hi = n.lo << (64-sr)
-// 			r.all = n.all >> sr
-// 			if sr < 64 {
-// 				r.hi = n.hi >> sr
-// 				r.lo = (n.hi << (64-sr)) | (n.lo >> sr)
-// 			} else {
-// 				r.hi = 0
-// 				r.lo = n.hi
-// 			}
-// 		}
-// 	}
-
-// 	carry: u64
-// 	for ; sr > 0; sr-- {
-// 		r.hi = (r.hi << 1) | (r.lo >> (64-1))
-// 		r.lo = (r.lo << 1) | (r.hi >> (64-1))
-// 		q.hi = (q.hi << 1) | (q.lo >> (64-1))
-// 		q.lo = (q.lo << 1) | carry
-
-// 		carry = 0
-// 		if r.all >= d.all {
-// 			r.all -= d.all
-// 			carry = 1
-// 		}
-// 	}
-
-// 	q.all = (q.all << 1) | (carry as u128)
-// 	return q.all, r.all
-// }
+	for x != 0 {
+		if r >= d {
+			r -= d;
+			q |= x;
+		}
+		x >>= 1;
+		d >>= 1;
+	}

+	if rem != nil do rem^ = r;
+	return q;
+}
+*/
@@ -1,101 +0,0 @@
-// TODO(bill): Use assembly instead here to implement atomics
-// Inline vs external file?
-
-#import win32 "sys/windows.odin" when ODIN_OS == "windows";
-_ := compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
-
-
-yield_thread :: proc() { win32._mm_pause(); }
-mfence       :: proc() { win32.ReadWriteBarrier(); }
-sfence       :: proc() { win32.WriteBarrier(); }
-lfence       :: proc() { win32.ReadBarrier(); }
-
-
-load32 :: proc(a: ^i32) -> i32 {
-	return a^;
-}
-store32 :: proc(a: ^i32, value: i32) {
-	a^ = value;
-}
-compare_exchange32 :: proc(a: ^i32, expected, desired: i32) -> i32 {
-	return win32.InterlockedCompareExchange(a, desired, expected);
-}
-exchanged32 :: proc(a: ^i32, desired: i32) -> i32 {
-	return win32.InterlockedExchange(a, desired);
-}
-fetch_add32 :: proc(a: ^i32, operand: i32) -> i32 {
-	return win32.InterlockedExchangeAdd(a, operand);
-
-}
-fetch_and32 :: proc(a: ^i32, operand: i32) -> i32 {
-	return win32.InterlockedAnd(a, operand);
-
-}
-fetch_or32 :: proc(a: ^i32, operand: i32) -> i32 {
-	return win32.InterlockedOr(a, operand);
-}
-spin_lock32 :: proc(a: ^i32, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
-	old_value := compare_exchange32(a, 1, 0);
-	counter := 0;
-	while old_value != 0 && (time_out < 0 || counter < time_out) {
-		counter += 1;
-		yield_thread();
-		old_value = compare_exchange32(a, 1, 0);
-		mfence();
-	}
-	return old_value == 0;
-}
-spin_unlock32 :: proc(a: ^i32) {
-	store32(a, 0);
-	mfence();
-}
-try_acquire_lock32 :: proc(a: ^i32) -> bool {
-	yield_thread();
-	old_value := compare_exchange32(a, 1, 0);
-	mfence();
-	return old_value == 0;
-}
-
-
-load64 :: proc(a: ^i64) -> i64 {
-	return a^;
-}
-store64 :: proc(a: ^i64, value: i64) {
-	a^ = value;
-}
-compare_exchange64 :: proc(a: ^i64, expected, desired: i64) -> i64 {
-	return win32.InterlockedCompareExchange64(a, desired, expected);
-}
-exchanged64 :: proc(a: ^i64, desired: i64) -> i64 {
-	return win32.InterlockedExchange64(a, desired);
-}
-fetch_add64 :: proc(a: ^i64, operand: i64) -> i64 {
-	return win32.InterlockedExchangeAdd64(a, operand);
-}
-fetch_and64 :: proc(a: ^i64, operand: i64) -> i64 {
-	return win32.InterlockedAnd64(a, operand);
-}
-fetch_or64 :: proc(a: ^i64, operand: i64) -> i64 {
-	return win32.InterlockedOr64(a, operand);
-}
-spin_lock64 :: proc(a: ^i64, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
-	old_value := compare_exchange64(a, 1, 0);
-	counter := 0;
-	while old_value != 0 && (time_out < 0 || counter < time_out) {
-		counter += 1;
-		yield_thread();
-		old_value = compare_exchange64(a, 1, 0);
-		mfence();
-	}
-	return old_value == 0;
-}
-spin_unlock64 :: proc(a: ^i64) {
-	store64(a, 0);
-	mfence();
-}
-try_acquire_lock64 :: proc(a: ^i64) -> bool {
-	yield_thread();
-	old_value := compare_exchange64(a, 1, 0);
-	mfence();
-	return old_value == 0;
-}
@@ -0,0 +1,102 @@
+// TODO(bill): Use assembly instead here to implement atomics
+// Inline vs external file?
+
+when ODIN_OS == "windows" {
+	import win32 "core:sys/windows.odin"
+}
+_ :: compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
+
+
+yield_thread :: proc() { win32.mm_pause(); }
+mfence       :: proc() { win32.read_write_barrier(); }
+sfence       :: proc() { win32.write_barrier(); }
+lfence       :: proc() { win32.read_barrier(); }
+
+
+load_i32 :: proc(a: ^i32) -> i32 {
+	return a^;
+}
+store_i32 :: proc(a: ^i32, value: i32) {
+	a^ = value;
+}
+compare_exchange_i32 :: proc(a: ^i32, expected, desired: i32) -> i32 {
+	return win32.interlocked_compare_exchange(a, desired, expected);
+}
+exchanged_i32 :: proc(a: ^i32, desired: i32) -> i32 {
+	return win32.interlocked_exchange(a, desired);
+}
+fetch_add_i32 :: proc(a: ^i32, operand: i32) -> i32 {
+	return win32.interlocked_exchange_add(a, operand);
+
+}
+fetch_and_i32 :: proc(a: ^i32, operand: i32) -> i32 {
+	return win32.interlocked_and(a, operand);
+}
+fetch_or_i32 :: proc(a: ^i32, operand: i32) -> i32 {
+	return win32.interlocked_or(a, operand);
+}
+spin_lock_i32 :: proc(a: ^i32, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
+	old_value := compare_exchange_i32(a, 1, 0);
+	counter := 0;
+	for old_value != 0 && (time_out < 0 || counter < time_out) {
+		counter += 1;
+		yield_thread();
+		old_value = compare_exchange_i32(a, 1, 0);
+		mfence();
+	}
+	return old_value == 0;
+}
+spin_unlock_i32 :: proc(a: ^i32) {
+	store_i32(a, 0);
+	mfence();
+}
+try_acquire_lock_i32 :: proc(a: ^i32) -> bool {
+	yield_thread();
+	old_value := compare_exchange_i32(a, 1, 0);
+	mfence();
+	return old_value == 0;
+}
+
+
+load_i64 :: proc(a: ^i64) -> i64 {
+	return a^;
+}
+store_i64 :: proc(a: ^i64, value: i64) {
+	a^ = value;
+}
+compare_exchange_i64 :: proc(a: ^i64, expected, desired: i64) -> i64 {
+	return win32.interlocked_compare_exchange64(a, desired, expected);
+}
+exchanged_i64 :: proc(a: ^i64, desired: i64) -> i64 {
+	return win32.interlocked_exchange64(a, desired);
+}
+fetch_add_i64 :: proc(a: ^i64, operand: i64) -> i64 {
+	return win32.interlocked_exchange_add64(a, operand);
+}
+fetch_and_i64 :: proc(a: ^i64, operand: i64) -> i64 {
+	return win32.interlocked_and64(a, operand);
+}
+fetch_or_i64 :: proc(a: ^i64, operand: i64) -> i64 {
+	return win32.interlocked_or64(a, operand);
+}
+spin_lock_i64 :: proc(a: ^i64, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
+	old_value := compare_exchange_i64(a, 1, 0);
+	counter := 0;
+	for old_value != 0 && (time_out < 0 || counter < time_out) {
+		counter += 1;
+		yield_thread();
+		old_value = compare_exchange_i64(a, 1, 0);
+		mfence();
+	}
+	return old_value == 0;
+}
+spin_unlock_i64 :: proc(a: ^i64) {
+	store_i64(a, 0);
+	mfence();
+}
+try_acquire_lock_i64 :: proc(a: ^i64) -> bool {
+	yield_thread();
+	old_value := compare_exchange_i64(a, 1, 0);
+	mfence();
+	return old_value == 0;
+}
@@ -0,0 +1,244 @@
+U8_MIN   ::   u8(0);
+U16_MIN  ::  u16(0);
+U32_MIN  ::  u32(0);
+U64_MIN  ::  u64(0);
+
+U8_MAX   ::   ~u8(0);
+U16_MAX  ::  ~u16(0);
+U32_MAX  ::  ~u32(0);
+U64_MAX  ::  ~u64(0);
+
+I8_MIN   ::   i8(  ~u8(0) >> 1);
+I16_MIN  ::  i16( ~u16(0) >> 1);
+I32_MIN  ::  i32( ~u32(0) >> 1);
+I64_MIN  ::  i64( ~u64(0) >> 1);
+
+I8_MAX   ::   -I8_MIN - 1;
+I16_MAX  ::  -I16_MIN - 1;
+I32_MAX  ::  -I32_MIN - 1;
+I64_MAX  ::  -I64_MIN - 1;
+
+foreign __llvm_core {
+	@(link_name="llvm.ctpop.i8")        __llvm_ctpop8   :: proc(u8)   ->   u8 ---;
+	@(link_name="llvm.ctpop.i16")       __llvm_ctpop16  :: proc(u16)  ->  u16 ---;
+	@(link_name="llvm.ctpop.i32")       __llvm_ctpop32  :: proc(u32)  ->  u32 ---;
+	@(link_name="llvm.ctpop.i64")       __llvm_ctpop64  :: proc(u64)  ->  u64 ---;
+
+	@(link_name="llvm.ctlz.i8")         __llvm_ctlz8   :: proc(u8,   bool) ->   u8 ---;
+	@(link_name="llvm.ctlz.i16")        __llvm_ctlz16  :: proc(u16,  bool) ->  u16 ---;
+	@(link_name="llvm.ctlz.i32")        __llvm_ctlz32  :: proc(u32,  bool) ->  u32 ---;
+	@(link_name="llvm.ctlz.i64")        __llvm_ctlz64  :: proc(u64,  bool) ->  u64 ---;
+
+	@(link_name="llvm.cttz.i8")         __llvm_cttz8   :: proc(u8,   bool) ->   u8 ---;
+	@(link_name="llvm.cttz.i16")        __llvm_cttz16  :: proc(u16,  bool) ->  u16 ---;
+	@(link_name="llvm.cttz.i32")        __llvm_cttz32  :: proc(u32,  bool) ->  u32 ---;
+	@(link_name="llvm.cttz.i64")        __llvm_cttz64  :: proc(u64,  bool) ->  u64 ---;
+
+	@(link_name="llvm.bitreverse.i8")   __llvm_bitreverse8   :: proc(u8)   ->   u8 ---;
+	@(link_name="llvm.bitreverse.i16")  __llvm_bitreverse16  :: proc(u16)  ->  u16 ---;
+	@(link_name="llvm.bitreverse.i32")  __llvm_bitreverse32  :: proc(u32)  ->  u32 ---;
+	@(link_name="llvm.bitreverse.i64")  __llvm_bitreverse64  :: proc(u64)  ->  u64 ---;
+
+	@(link_name="llvm.bswap.i16")  byte_swap16  :: proc(u16)  ->  u16 ---;
+	@(link_name="llvm.bswap.i32")  byte_swap32  :: proc(u32)  ->  u32 ---;
+	@(link_name="llvm.bswap.i64")  byte_swap64  :: proc(u64)  ->  u64 ---;
+}
+
+byte_swap_uint :: proc(i: uint) -> uint {
+	when size_of(uint) == size_of(u32) {
+		return uint(byte_swap32(u32(i)));
+	} else {
+		return uint(byte_swap64(u64(i)));
+	}
+}
+
+byte_swap :: proc[byte_swap16, byte_swap32, byte_swap64, byte_swap_uint];
+
+count_ones8   :: proc(i:   u8) ->   u8 { return __llvm_ctpop8(i); }
+count_ones16  :: proc(i:  u16) ->  u16 { return __llvm_ctpop16(i); }
+count_ones32  :: proc(i:  u32) ->  u32 { return __llvm_ctpop32(i); }
+count_ones64  :: proc(i:  u64) ->  u64 { return __llvm_ctpop64(i); }
+
+count_zeros8   :: proc(i:   u8) ->   u8 { return   8 - count_ones8(i); }
+count_zeros16  :: proc(i:  u16) ->  u16 { return  16 - count_ones16(i); }
+count_zeros32  :: proc(i:  u32) ->  u32 { return  32 - count_ones32(i); }
+count_zeros64  :: proc(i:  u64) ->  u64 { return  64 - count_ones64(i); }
+
+
+rotate_left8   :: proc(i: u8,   s: uint) ->   u8 { return (i << s)|(i >> (8*size_of(u8)   - s)); }
+rotate_left16  :: proc(i: u16,  s: uint) ->  u16 { return (i << s)|(i >> (8*size_of(u16)  - s)); }
+rotate_left32  :: proc(i: u32,  s: uint) ->  u32 { return (i << s)|(i >> (8*size_of(u32)  - s)); }
+rotate_left64  :: proc(i: u64,  s: uint) ->  u64 { return (i << s)|(i >> (8*size_of(u64)  - s)); }
+
+
+rotate_right8   :: proc(i: u8,   s: uint) ->   u8 { return (i >> s)|(i << (8*size_of(u8)   - s)); }
+rotate_right16  :: proc(i: u16,  s: uint) ->  u16 { return (i >> s)|(i << (8*size_of(u16)  - s)); }
+rotate_right32  :: proc(i: u32,  s: uint) ->  u32 { return (i >> s)|(i << (8*size_of(u32)  - s)); }
+rotate_right64  :: proc(i: u64,  s: uint) ->  u64 { return (i >> s)|(i << (8*size_of(u64)  - s)); }
+
+leading_zeros8   :: proc(i:   u8) ->   u8 { return __llvm_ctlz8(i, false); }
+leading_zeros16  :: proc(i:  u16) ->  u16 { return __llvm_ctlz16(i, false); }
+leading_zeros32  :: proc(i:  u32) ->  u32 { return __llvm_ctlz32(i, false); }
+leading_zeros64  :: proc(i:  u64) ->  u64 { return __llvm_ctlz64(i, false); }
+
+trailing_zeros8   :: proc(i:   u8) ->   u8 { return __llvm_cttz8(i, false); }
+trailing_zeros16  :: proc(i:  u16) ->  u16 { return __llvm_cttz16(i, false); }
+trailing_zeros32  :: proc(i:  u32) ->  u32 { return __llvm_cttz32(i, false); }
+trailing_zeros64  :: proc(i:  u64) ->  u64 { return __llvm_cttz64(i, false); }
+
+
+reverse_bits8   :: proc(i:   u8) ->   u8 { return __llvm_bitreverse8(i); }
+reverse_bits16  :: proc(i:  u16) ->  u16 { return __llvm_bitreverse16(i); }
+reverse_bits32  :: proc(i:  u32) ->  u32 { return __llvm_bitreverse32(i); }
+reverse_bits64  :: proc(i:  u64) ->  u64 { return __llvm_bitreverse64(i); }
+
+from_be_u8   :: proc(i:   u8) ->   u8 { return i; }
+from_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+from_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+from_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+
+from_le_u8   :: proc(i:   u8) ->   u8 { return i; }
+from_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+from_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+from_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+
+to_be_u8   :: proc(i:   u8) ->   u8 { return i; }
+to_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+to_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+to_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+
+
+to_le_u8   :: proc(i:   u8) ->   u8 { return i; }
+to_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+to_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+to_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+
+
+overflowing_add_u8   :: proc(lhs, rhs:   u8) -> (u8, bool)   { foreign __llvm_core @(link_name="llvm.uadd.with.overflow.i8")   op :: proc(u8, u8)     -> (u8, bool)   ---; return op(lhs, rhs); }
+overflowing_add_i8   :: proc(lhs, rhs:   i8) -> (i8, bool)   { foreign __llvm_core @(link_name="llvm.sadd.with.overflow.i8")   op :: proc(i8, i8)     -> (i8, bool)   ---; return op(lhs, rhs); }
+overflowing_add_u16  :: proc(lhs, rhs:  u16) -> (u16, bool)  { foreign __llvm_core @(link_name="llvm.uadd.with.overflow.i16")  op :: proc(u16, u16)   -> (u16, bool)  ---; return op(lhs, rhs); }
+overflowing_add_i16  :: proc(lhs, rhs:  i16) -> (i16, bool)  { foreign __llvm_core @(link_name="llvm.sadd.with.overflow.i16")  op :: proc(i16, i16)   -> (i16, bool)  ---; return op(lhs, rhs); }
+overflowing_add_u32  :: proc(lhs, rhs:  u32) -> (u32, bool)  { foreign __llvm_core @(link_name="llvm.uadd.with.overflow.i32")  op :: proc(u32, u32)   -> (u32, bool)  ---; return op(lhs, rhs); }
+overflowing_add_i32  :: proc(lhs, rhs:  i32) -> (i32, bool)  { foreign __llvm_core @(link_name="llvm.sadd.with.overflow.i32")  op :: proc(i32, i32)   -> (i32, bool)  ---; return op(lhs, rhs); }
+overflowing_add_u64  :: proc(lhs, rhs:  u64) -> (u64, bool)  { foreign __llvm_core @(link_name="llvm.uadd.with.overflow.i64")  op :: proc(u64, u64)   -> (u64, bool)  ---; return op(lhs, rhs); }
+overflowing_add_i64  :: proc(lhs, rhs:  i64) -> (i64, bool)  { foreign __llvm_core @(link_name="llvm.sadd.with.overflow.i64")  op :: proc(i64, i64)   -> (i64, bool)  ---; return op(lhs, rhs); }
+overflowing_add_uint :: proc(lhs, rhs: uint) -> (uint, bool) {
+	when size_of(uint) == size_of(u32) {
+		x, ok := overflowing_add_u32(u32(lhs), u32(rhs));
+		return uint(x), ok;
+	} else {
+		x, ok := overflowing_add_u64(u64(lhs), u64(rhs));
+		return uint(x), ok;
+	}
+}
+overflowing_add_int :: proc(lhs, rhs: int) -> (int, bool) {
+	when size_of(int) == size_of(i32) {
+		x, ok := overflowing_add_i32(i32(lhs), i32(rhs));
+		return int(x), ok;
+	} else {
+		x, ok := overflowing_add_i64(i64(lhs), i64(rhs));
+		return int(x), ok;
+	}
+}
+
+overflowing_add :: proc[
+	overflowing_add_u8,   overflowing_add_i8,
+	overflowing_add_u16,  overflowing_add_i16,
+	overflowing_add_u32,  overflowing_add_i32,
+	overflowing_add_u64,  overflowing_add_i64,
+	overflowing_add_uint, overflowing_add_int,
+];
+
+overflowing_sub_u8   :: proc(lhs, rhs:   u8) -> (u8, bool)   { foreign __llvm_core @(link_name="llvm.usub.with.overflow.i8")   op :: proc(u8, u8)     -> (u8, bool)   ---; return op(lhs, rhs); }
+overflowing_sub_i8   :: proc(lhs, rhs:   i8) -> (i8, bool)   { foreign __llvm_core @(link_name="llvm.ssub.with.overflow.i8")   op :: proc(i8, i8)     -> (i8, bool)   ---; return op(lhs, rhs); }
+overflowing_sub_u16  :: proc(lhs, rhs:  u16) -> (u16, bool)  { foreign __llvm_core @(link_name="llvm.usub.with.overflow.i16")  op :: proc(u16, u16)   -> (u16, bool)  ---; return op(lhs, rhs); }
+overflowing_sub_i16  :: proc(lhs, rhs:  i16) -> (i16, bool)  { foreign __llvm_core @(link_name="llvm.ssub.with.overflow.i16")  op :: proc(i16, i16)   -> (i16, bool)  ---; return op(lhs, rhs); }
+overflowing_sub_u32  :: proc(lhs, rhs:  u32) -> (u32, bool)  { foreign __llvm_core @(link_name="llvm.usub.with.overflow.i32")  op :: proc(u32, u32)   -> (u32, bool)  ---; return op(lhs, rhs); }
+overflowing_sub_i32  :: proc(lhs, rhs:  i32) -> (i32, bool)  { foreign __llvm_core @(link_name="llvm.ssub.with.overflow.i32")  op :: proc(i32, i32)   -> (i32, bool)  ---; return op(lhs, rhs); }
+overflowing_sub_u64  :: proc(lhs, rhs:  u64) -> (u64, bool)  { foreign __llvm_core @(link_name="llvm.usub.with.overflow.i64")  op :: proc(u64, u64)   -> (u64, bool)  ---; return op(lhs, rhs); }
+overflowing_sub_i64  :: proc(lhs, rhs:  i64) -> (i64, bool)  { foreign __llvm_core @(link_name="llvm.ssub.with.overflow.i64")  op :: proc(i64, i64)   -> (i64, bool)  ---; return op(lhs, rhs); }
+overflowing_sub_uint :: proc(lhs, rhs: uint) -> (uint, bool) {
+	when size_of(uint) == size_of(u32) {
+		x, ok := overflowing_sub_u32(u32(lhs), u32(rhs));
+		return uint(x), ok;
+	} else {
+		x, ok := overflowing_sub_u64(u64(lhs), u64(rhs));
+		return uint(x), ok;
+	}
+}
+overflowing_sub_int :: proc(lhs, rhs: int) -> (int, bool) {
+	when size_of(int) == size_of(i32) {
+		x, ok := overflowing_sub_i32(i32(lhs), i32(rhs));
+		return int(x), ok;
+	} else {
+		x, ok := overflowing_sub_i64(i64(lhs), i64(rhs));
+		return int(x), ok;
+	}
+}
+
+overflowing_sub :: proc[
+	overflowing_sub_u8,   overflowing_sub_i8,
+	overflowing_sub_u16,  overflowing_sub_i16,
+	overflowing_sub_u32,  overflowing_sub_i32,
+	overflowing_sub_u64,  overflowing_sub_i64,
+	overflowing_sub_uint, overflowing_sub_int,
+];
+
+
+overflowing_mul_u8   :: proc(lhs, rhs:   u8) -> (u8, bool)   { foreign __llvm_core @(link_name="llvm.umul.with.overflow.i8")   op :: proc(u8, u8)     -> (u8, bool)   ---; return op(lhs, rhs); }
+overflowing_mul_i8   :: proc(lhs, rhs:   i8) -> (i8, bool)   { foreign __llvm_core @(link_name="llvm.smul.with.overflow.i8")   op :: proc(i8, i8)     -> (i8, bool)   ---; return op(lhs, rhs); }
+overflowing_mul_u16  :: proc(lhs, rhs:  u16) -> (u16, bool)  { foreign __llvm_core @(link_name="llvm.umul.with.overflow.i16")  op :: proc(u16, u16)   -> (u16, bool)  ---; return op(lhs, rhs); }
+overflowing_mul_i16  :: proc(lhs, rhs:  i16) -> (i16, bool)  { foreign __llvm_core @(link_name="llvm.smul.with.overflow.i16")  op :: proc(i16, i16)   -> (i16, bool)  ---; return op(lhs, rhs); }
+overflowing_mul_u32  :: proc(lhs, rhs:  u32) -> (u32, bool)  { foreign __llvm_core @(link_name="llvm.umul.with.overflow.i32")  op :: proc(u32, u32)   -> (u32, bool)  ---; return op(lhs, rhs); }
+overflowing_mul_i32  :: proc(lhs, rhs:  i32) -> (i32, bool)  { foreign __llvm_core @(link_name="llvm.smul.with.overflow.i32")  op :: proc(i32, i32)   -> (i32, bool)  ---; return op(lhs, rhs); }
+overflowing_mul_u64  :: proc(lhs, rhs:  u64) -> (u64, bool)  { foreign __llvm_core @(link_name="llvm.umul.with.overflow.i64")  op :: proc(u64, u64)   -> (u64, bool)  ---; return op(lhs, rhs); }
+overflowing_mul_i64  :: proc(lhs, rhs:  i64) -> (i64, bool)  { foreign __llvm_core @(link_name="llvm.smul.with.overflow.i64")  op :: proc(i64, i64)   -> (i64, bool)  ---; return op(lhs, rhs); }
+overflowing_mul_uint :: proc(lhs, rhs: uint) -> (uint, bool) {
+	when size_of(uint) == size_of(u32) {
+		x, ok := overflowing_mul_u32(u32(lhs), u32(rhs));
+		return uint(x), ok;
+	} else {
+		x, ok := overflowing_mul_u64(u64(lhs), u64(rhs));
+		return uint(x), ok;
+	}
+}
+overflowing_mul_int :: proc(lhs, rhs: int) -> (int, bool) {
+	when size_of(int) == size_of(i32) {
+		x, ok := overflowing_mul_i32(i32(lhs), i32(rhs));
+		return int(x), ok;
+	} else {
+		x, ok := overflowing_mul_i64(i64(lhs), i64(rhs));
+		return int(x), ok;
+	}
+}
+
+overflowing_mul :: proc[
+	overflowing_mul_u8,   overflowing_mul_i8,
+	overflowing_mul_u16,  overflowing_mul_i16,
+	overflowing_mul_u32,  overflowing_mul_i32,
+	overflowing_mul_u64,  overflowing_mul_i64,
+	overflowing_mul_uint, overflowing_mul_int,
+];
+
+is_power_of_two_u8   :: proc(i:   u8) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_i8   :: proc(i:   i8) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_u16  :: proc(i:  u16) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_i16  :: proc(i:  i16) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_u32  :: proc(i:  u32) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_i32  :: proc(i:  i32) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_u64  :: proc(i:  u64) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_i64  :: proc(i:  i64) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_uint :: proc(i: uint) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_int  :: proc(i:  int) -> bool { return i > 0 && (i & (i-1)) == 0; }
+
+is_power_of_two :: proc[
+	is_power_of_two_u8,   is_power_of_two_i8,
+	is_power_of_two_u16,  is_power_of_two_i16,
+	is_power_of_two_u32,  is_power_of_two_i32,
+	is_power_of_two_u64,  is_power_of_two_i64,
+	is_power_of_two_uint, is_power_of_two_int,
+]
@@ -0,0 +1,38 @@
+CHAR_BIT :: 8;
+
+c_bool   :: bool;
+c_char   :: u8;
+c_byte   :: u8;
+c_schar  :: i8;
+c_uchar  :: u8;
+c_short  :: i16;
+c_ushort :: u16;
+c_int    :: i32;
+c_uint   :: u32;
+
+when ODIN_OS == "windows" || size_of(rawptr) == 4 {
+	c_long :: i32;
+} else {
+	c_long :: i64;
+}
+
+when ODIN_OS == "windows" || size_of(rawptr) == 4 {
+	c_ulong :: u32;
+} else {
+	c_ulong :: u64;
+}
+
+c_longlong       :: i64;
+c_ulonglong      :: u64;
+c_float          :: f32;
+c_double         :: f64;
+c_complex_float  :: complex64;
+c_complex_double :: complex128;
+
+_ :: compile_assert(size_of(uintptr) == size_of(int));
+
+c_size_t    :: uint;
+c_ssize_t   :: int;
+c_ptrdiff_t :: int;
+c_uintptr_t :: uintptr;
+c_intptr_t  :: int;
@@ -0,0 +1,254 @@
+// Multiple precision decimal numbers
+// NOTE: This is only for floating point printing and nothing else
+
+Decimal :: struct {
+	digits:        [384]byte, // big-endian digits
+	count:         int,
+	decimal_point: int,
+	neg, trunc:    bool,
+}
+
+decimal_to_string :: proc(buf: []byte, a: ^Decimal) -> string {
+	digit_zero :: proc(buf: []byte) -> int {
+		for _, i in buf do buf[i] = '0';
+		return len(buf);
+	}
+
+
+	n := 10 + a.count + abs(a.decimal_point);
+
+	// TODO(bill): make this work with a buffer that's not big enough
+	assert(len(buf) >= n);
+	buf = buf[0..n];
+
+	if a.count == 0 {
+		buf[0] = '0';
+		return string(buf[0..1]);
+	}
+
+	w := 0;
+	if a.decimal_point <= 0 {
+		buf[w] = '0'; w += 1;
+		buf[w] = '.'; w += 1;
+		w += digit_zero(buf[w .. w-a.decimal_point]);
+		w += copy(buf[w..], a.digits[0..a.count]);
+	} else if a.decimal_point < a.count {
+		w += copy(buf[w..], a.digits[0..a.decimal_point]);
+		buf[w] = '.'; w += 1;
+		w += copy(buf[w..], a.digits[a.decimal_point .. a.count]);
+	} else {
+		w += copy(buf[w..], a.digits[0..a.count]);
+		w += digit_zero(buf[w .. w+a.decimal_point-a.count]);
+	}
+
+	return string(buf[0..w]);
+}
+
+// trim trailing zeros
+trim :: proc(a: ^Decimal) {
+	for a.count > 0 && a.digits[a.count-1] == '0' {
+		a.count -= 1;
+	}
+	if a.count == 0 {
+		a.decimal_point = 0;
+	}
+}
+
+
+assign :: proc(a: ^Decimal, i: u64) {
+	buf: [64]byte;
+	n := 0;
+	for i > 0 {
+		j := i/10;
+		i -= 10*j;
+		buf[n] = byte('0'+i);
+		n += 1;
+		i = j;
+	}
+
+	a.count = 0;
+	for n -= 1; n >= 0; n -= 1 {
+		a.digits[a.count] = buf[n];
+		a.count += 1;
+	}
+	a.decimal_point = a.count;
+	trim(a);
+}
+
+
+
+shift_right :: proc(a: ^Decimal, k: uint) {
+	r := 0; // read index
+	w := 0; // write index
+
+	n: uint;
+	for ; n>>k == 0; r += 1 {
+		if r >= a.count {
+			if n == 0 {
+				// Just in case
+				a.count = 0;
+				return;
+			}
+			for n>>k == 0 {
+				n = n * 10;
+				r += 1;
+			}
+			break;
+		}
+		c := uint(a.digits[r]);
+		n = n*10 + c - '0';
+	}
+	a.decimal_point -= r-1;
+
+	mask: uint = (1<<k) - 1;
+
+	for ; r < a.count; r += 1 {
+		c := uint(a.digits[r]);
+		dig := n>>k;
+		n &= mask;
+		a.digits[w] = byte('0' + dig);
+		w += 1;
+		n = n*10 + c - '0';
+	}
+
+	for n > 0 {
+		dig := n>>k;
+		n &= mask;
+		if w < len(a.digits) {
+			a.digits[w] = byte('0' + dig);
+			w += 1;
+		} else if dig > 0 {
+			a.trunc = true;
+		}
+		n *= 10;
+	}
+
+
+	a.count = w;
+	trim(a);
+}
+
+shift_left :: proc(a: ^Decimal, k: uint) {
+	delta := int(k/4);
+
+	r := a.count;       // read index
+	w := a.count+delta; // write index
+
+	n: uint;
+	for r -= 1; r >= 0; r -= 1 {
+		n += (uint(a.digits[r]) - '0') << k;
+		quo := n/10;
+		rem := n - 10*quo;
+		w -= 1;
+		if w < len(a.digits) {
+			a.digits[w] = byte('0' + rem);
+		} else if rem != 0 {
+			a.trunc = true;
+		}
+		n = quo;
+	}
+
+	for n > 0 {
+		quo := n/10;
+		rem := n - 10*quo;
+		w -= 1;
+		if 0 <= w && w < len(a.digits) {
+			a.digits[w] = byte('0' + rem);
+		} else if rem != 0 {
+			a.trunc = true;
+		}
+		n = quo;
+	}
+
+	a.count += delta;
+	a.count = min(a.count, len(a.digits));
+	a.decimal_point += delta;
+	trim(a);
+}
+
+shift :: proc(a: ^Decimal, k: int) {
+	uint_size :: 8*size_of(uint);
+	max_shift :: uint_size-4;
+
+	switch {
+	case a.count == 0:
+		// no need to update
+	case k > 0:
+		for k > max_shift {
+			shift_left(a, max_shift);
+			k -= max_shift;
+		}
+		shift_left(a, uint(k));
+
+
+	case k < 0:
+		for k < -max_shift {
+			shift_right(a, max_shift);
+			k += max_shift;
+		}
+		shift_right(a, uint(-k));
+	}
+}
+
+can_round_up :: proc(a: ^Decimal, nd: int) -> bool {
+	if nd < 0 || nd >= a.count { return false ; }
+	if a.digits[nd] == '5' && nd+1 == a.count {
+		if a.trunc do return true;
+		return nd > 0 && (a.digits[nd-1]-'0')%2 != 0;
+	}
+
+	return a.digits[nd] >= '5';
+}
+
+round :: proc(a: ^Decimal, nd: int) {
+	if nd < 0 || nd >= a.count { return; }
+	if can_round_up(a, nd) {
+		round_up(a, nd);
+	} else {
+		round_down(a, nd);
+	}
+}
+
+round_up :: proc(a: ^Decimal, nd: int) {
+	if nd < 0 || nd >= a.count { return; }
+
+	for i := nd-1; i >= 0; i -= 1 {
+		if c := a.digits[i]; c < '9' {
+			a.digits[i] += 1;
+			a.count = i+1;
+			return;
+		}
+	}
+
+	// Number is just 9s
+	a.digits[0] = '1';
+	a.count = 1;
+	a.decimal_point += 1;
+}
+
+round_down :: proc(a: ^Decimal, nd: int) {
+	if nd < 0 || nd >= a.count { return; }
+	a.count = nd;
+	trim(a);
+}
+
+
+// Extract integer part, rounded appropriately. There are no guarantees about overflow.
+rounded_integer :: proc(a: ^Decimal) -> u64 {
+	if a.decimal_point > 20 {
+		return 0xffff_ffff_ffff_ffff;
+	}
+	i: int = 0;
+	n: u64 = 0;
+	m := min(a.decimal_point, a.count);
+	for ; i < m; i += 1 {
+		n = n*10 + u64(a.digits[i]-'0');
+	}
+	for ; i < a.decimal_point; i += 1 {
+		n *= 10;
+	}
+	if can_round_up(a, a.decimal_point) {
+		n += 1;
+	}
+	return n;
+}
@@ -1,77 +1,123 @@
-crc32 :: proc(data: rawptr, len: int) -> u32 {
-	result := ~(0 as u32);
-	s := slice_ptr(data as ^u8, len);
-	for i : 0..<len {
-		b := s[i] as u32;
-		result = result>>8 ~ __CRC32_TABLE[(result ~ b) & 0xff];
+import "core:mem.odin"
+
+adler32 :: proc(data: []byte) -> u32 {
+	ADLER_CONST :: 65521;
+	a, b: u32 = 1, 0;
+	for x in data {
+		a = (a + u32(x)) % ADLER_CONST;
+		b = (b + a) % ADLER_CONST;
+	}
+	return (b << 16) | a;
+}
+
+crc32 :: proc(data: []byte) -> u32 {
+	result := ~u32(0);
+	for b in data {
+		result = result>>8 ~ _crc32_table[(result ~ u32(b)) & 0xff];
 	}
 	return ~result;
 }
-crc64 :: proc(data: rawptr, len: int) -> u64 {
-	result := ~(0 as u64);
-	s := slice_ptr(data as ^u8, len);
-	for i : 0..<len {
-		b := s[i] as u64;
-		result = result>>8 ~ __CRC64_TABLE[(result ~ b) & 0xff];
+crc64 :: proc(data: []byte) -> u64 {
+	result := ~u64(0);
+	for b in data {
+		result = result>>8 ~ _crc64_table[(result ~ u64(b)) & 0xff];
 	}
 	return ~result;
 }

-fnv32 :: proc(data: rawptr, len: int) -> u32 {
-	s := slice_ptr(data as ^u8, len);
-
+fnv32 :: proc(data: []byte) -> u32 {
 	h: u32 = 0x811c9dc5;
-	for i : 0..<len {
-		h = (h * 0x01000193) ~ s[i] as u32;
+	for b in data {
+		h = (h * 0x01000193) ~ u32(b);
 	}
 	return h;
 }

-fnv64 :: proc(data: rawptr, len: int) -> u64 {
-	s := slice_ptr(data as ^u8, len);
-
+fnv64 :: proc(data: []byte) -> u64 {
 	h: u64 = 0xcbf29ce484222325;
-	for i : 0..<len {
-		h = (h * 0x100000001b3) ~ s[i] as u64;
+	for b in data {
+		h = (h * 0x100000001b3) ~ u64(b);
 	}
 	return h;
 }

-fnv32a :: proc(data: rawptr, len: int) -> u32 {
-	s := slice_ptr(data as ^u8, len);
-
+fnv32a :: proc(data: []byte) -> u32 {
 	h: u32 = 0x811c9dc5;
-	for i : 0..<len {
-		h = (h ~ s[i] as u32) * 0x01000193;
+	for b in data {
+		h = (h ~ u32(b)) * 0x01000193;
 	}
 	return h;
 }

-fnv64a :: proc(data: rawptr, len: int) -> u64 {
-	s := slice_ptr(data as ^u8, len);
-
-	h :u64 = 0xcbf29ce484222325;
-	for i : 0..<len {
-		h = (h ~ s[i] as u64) * 0x100000001b3;
+fnv64a :: proc(data: []byte) -> u64 {
+	h: u64 = 0xcbf29ce484222325;
+	for b in data {
+		h = (h ~ u64(b)) * 0x100000001b3;
 	}
 	return h;
 }

+murmur32 :: proc(data: []byte) -> u32 {
+	c1_32: u32 : 0xcc9e2d51;
+	c2_32: u32 : 0x1b873593;

-murmur64 :: proc(data_: rawptr, len: int) -> u64 {
+	h1: u32 = 0;
+	nblocks := len(data)/4;
+	p := &data[0];
+	p1 := p + 4*nblocks;
+
+	for ; p < p1; p += 4 {
+		k1 := (cast(^u32)p)^;
+
+		k1 *= c1_32;
+		k1 = (k1 << 15) | (k1 >> 17);
+		k1 *= c2_32;
+
+		h1 ~= k1;
+		h1 = (h1 << 13) | (h1 >> 19);
+		h1 = h1*5 + 0xe6546b64;
+	}
+
+	tail := data[nblocks*4 ..];
+	k1: u32;
+	switch len(tail)&3 {
+	case 3:
+		k1 ~= u32(tail[2]) << 16;
+		fallthrough;
+	case 2:
+		k1 ~= u32(tail[2]) << 8;
+		fallthrough;
+	case 1:
+		k1 ~= u32(tail[0]);
+		k1 *= c1_32;
+		k1 = (k1 << 15) | (k1 >> 17) ;
+		k1 *= c2_32;
+		h1 ~= k1;
+	}
+
+	h1 ~= u32(len(data));
+
+	h1 ~= h1 >> 16;
+	h1 *= 0x85ebca6b;
+	h1 ~= h1 >> 13;
+	h1 *= 0xc2b2ae35;
+	h1 ~= h1 >> 16;
+
+	return h1;
+}
+
+murmur64 :: proc(data: []byte) -> u64 {
 	SEED :: 0x9747b28c;

 	when size_of(int) == 8 {
 		m :: 0xc6a4a7935bd1e995;
 		r :: 47;

-		h: u64 = SEED ~ (len as u64 * m);
+		h: u64 = SEED ~ (u64(len(data)) * m);
+		data64 := mem.slice_ptr(cast(^u64)&data[0], len(data)/size_of(u64));

-		data := slice_ptr(data_ as ^u64, len/size_of(u64));
-		data2 := slice_ptr(data_ as ^u8, len);
-
-		for i : 0 ..< data.count {
-			k := data[i];
+		for _, i in data64 {
+			k := data64[i];

 			k *= m;
 			k ~= k>>r;
@@ -81,15 +127,15 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
 			h *= m;
 		}

-		match len & 7 {
-		case 7: h ~= data2[6] as u64 << 48; fallthrough;
-		case 6: h ~= data2[5] as u64 << 40; fallthrough;
-		case 5: h ~= data2[4] as u64 << 32; fallthrough;
-		case 4: h ~= data2[3] as u64 << 24; fallthrough;
-		case 3: h ~= data2[2] as u64 << 16; fallthrough;
-		case 2: h ~= data2[1] as u64 << 8;  fallthrough;
+		switch len(data)&7 {
+		case 7: h ~= u64(data[6]) << 48; fallthrough;
+		case 6: h ~= u64(data[5]) << 40; fallthrough;
+		case 5: h ~= u64(data[4]) << 32; fallthrough;
+		case 4: h ~= u64(data[3]) << 24; fallthrough;
+		case 3: h ~= u64(data[2]) << 16; fallthrough;
+		case 2: h ~= u64(data[1]) << 8;  fallthrough;
 		case 1:
-			h ~= data2[0] as u64;
+			h ~= u64(data[0]);
 			h *= m;
 		}

@@ -102,15 +148,15 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
 		m :: 0x5bd1e995;
 		r :: 24;

-		h1: u32 = SEED as u32 ~ len as u32;
-		h2: u32 = SEED >> 32;
-
-		data := slice_ptr(data_ as ^u32, len/size_of(u32));
-
+		h1 := u32(SEED) ~ u32(len(data));
+		h2 := u32(SEED) >> 32;
+		data32 := mem.slice_ptr(cast(^u32)&data[0], len(data)/size_of(u32));
+		len := len(data);
 		i := 0;
-		while len >= 8 {
+
+		for len >= 8 {
 			k1, k2: u32;
-			k1 = data[i]; i += 1;
+			k1 = data32[i]; i += 1;
 			k1 *= m;
 			k1 ~= k1>>r;
 			k1 *= m;
@@ -118,7 +164,7 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
 			h1 ~= k1;
 			len -= 4;

-			k2 = data[i]; i += 1;
+			k2 = data32[i]; i += 1;
 			k2 *= m;
 			k2 ~= k2>>r;
 			k2 *= m;
@@ -129,7 +175,7 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {

 		if len >= 4 {
 			k1: u32;
-			k1 = data[i]; i += 1;
+			k1 = data32[i]; i += 1;
 			k1 *= m;
 			k1 ~= k1>>r;
 			k1 *= m;
@@ -138,13 +184,17 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
 			len -= 4;
 		}

-		data8 := slice_ptr((data.data+i) as ^u8, 3); // NOTE(bill): This is unsafe
-
-		match len {
-		case 3: h2 ~= data8[2] as u32 << 16; fallthrough;
-		case 2: h2 ~= data8[1] as u32 << 8;  fallthrough;
+		// TODO(bill): Fix this
+		#no_bounds_check data8 := slice_to_bytes(data32[i..])[..3];
+		switch len {
+		case 3:
+			h2 ~= u32(data8[2]) << 16;
+			fallthrough;
+		case 2:
+			h2 ~= u32(data8[1]) << 8;
+			fallthrough;
 		case 1:
-			h2 ~= data8[0] as u32;
+			h2 ~= u32(data8[0]);
 			h2 *= m;
 		}

@@ -157,14 +207,12 @@ murmur64 :: proc(data_: rawptr, len: int) -> u64 {
 		h2 ~= h1>>19;
 		h2 *= m;

-		h := (h1 as u64)<<32 | h2 as u64;
-		return h;
+		return u64(h1)<<32 | u64(h2);
 	}
 }


-
-__CRC32_TABLE := [256]u32{
+_crc32_table := [256]u32{
 	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
 	0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
 	0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
@@ -230,7 +278,7 @@ __CRC32_TABLE := [256]u32{
 	0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 };
-__CRC64_TABLE := [256]u64{
+_crc64_table := [256]u64{
 	0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5,
 	0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a,
 	0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b,
@@ -1,7 +1,5 @@
 TAU          :: 6.28318530717958647692528676655900576;
 PI           :: 3.14159265358979323846264338327950288;
-ONE_OVER_TAU :: 0.636619772367581343075535053490057448;
-ONE_OVER_PI  :: 0.159154943091895335768883763372514362;

 E            :: 2.71828182845904523536;
 SQRT_TWO     :: 1.41421356237309504880168872420969808;
@@ -16,72 +14,120 @@ EPSILON      :: 1.19209290e-7;
 τ :: TAU;
 π :: PI;

-Vec2 :: [vector 2]f32;
-Vec3 :: [vector 3]f32;
-Vec4 :: [vector 4]f32;
+Vec2 :: distinct [2]f32;
+Vec3 :: distinct [3]f32;
+Vec4 :: distinct [4]f32;

-Mat2 :: [2]Vec2;
-Mat3 :: [3]Vec3;
-Mat4 :: [4]Vec4;
+// Column major
+Mat2 :: distinct [2][2]f32;
+Mat3 :: distinct [3][3]f32;
+Mat4 :: distinct [4][4]f32;

-sqrt32 :: proc(x: f32) -> f32 #foreign "llvm.sqrt.f32"
-sqrt64 :: proc(x: f64) -> f64 #foreign "llvm.sqrt.f64"
+Quat :: struct {x, y, z: f32, w: f32 = 1};

-sin32 :: proc(x: f32) -> f32 #foreign "llvm.sin.f32"
-sin64 :: proc(x: f64) -> f64 #foreign "llvm.sin.f64"
+@(default_calling_convention="c")
+foreign __llvm_core {
+	@(link_name="llvm.sqrt.f32")
+	sqrt_f32 :: proc(x: f32) -> f32 ---;
+	@(link_name="llvm.sqrt.f64")
+	sqrt_f64 :: proc(x: f64) -> f64 ---;

-cos32 :: proc(x: f32) -> f32 #foreign "llvm.cos.f32"
-cos64 :: proc(x: f64) -> f64 #foreign "llvm.cos.f64"
+	@(link_name="llvm.sin.f32")
+	sin_f32 :: proc(θ: f32) -> f32 ---;
+	@(link_name="llvm.sin.f64")
+	sin_f64 :: proc(θ: f64) -> f64 ---;

-tan32 :: proc(x: f32) -> f32 #inline { return sin32(x)/cos32(x); }
-tan64 :: proc(x: f64) -> f64 #inline { return sin64(x)/cos64(x); }
+	@(link_name="llvm.cos.f32")
+	cos_f32 :: proc(θ: f32) -> f32 ---;
+	@(link_name="llvm.cos.f64")
+	cos_f64 :: proc(θ: f64) -> f64 ---;

-lerp32 :: proc(a, b, t: f32) -> f32 { return a*(1-t) + b*t; }
-lerp64 :: proc(a, b, t: f64) -> f64 { return a*(1-t) + b*t; }
+	@(link_name="llvm.pow.f32")
+	pow_f32 :: proc(x, power: f32) -> f32 ---;
+	@(link_name="llvm.pow.f64")
+	pow_f64 :: proc(x, power: f64) -> f64 ---;

-sign32 :: proc(x: f32) -> f32 { if x >= 0 { return +1; } return -1; }
-sign64 :: proc(x: f64) -> f64 { if x >= 0 { return +1; } return -1; }
-
-
-
-copy_sign32 :: proc(x, y: f32) -> f32 {
-	ix := x transmute u32;
-	iy := y transmute u32;
-	ix &= 0x7fffffff;
-	ix |= iy & 0x80000000;
-	return ix transmute f32;
-}
-round32 :: proc(x: f32) -> f32 {
-	if x >= 0 {
-		return floor32(x + 0.5);
-	}
-	return ceil32(x - 0.5);
-}
-floor32 :: proc(x: f32) -> f32 {
-	if x >= 0 {
-		return x as int as f32;
-	}
-	return (x-0.5) as int as f32;
-}
-ceil32 :: proc(x: f32) -> f32 {
-	if x < 0 {
-		return x as int as f32;
-	}
-	return ((x as int)+1) as f32;
+	@(link_name="llvm.fmuladd.f32")
+	fmuladd_f32 :: proc(a, b, c: f32) -> f32 ---;
+	@(link_name="llvm.fmuladd.f64")
+	fmuladd_f64 :: proc(a, b, c: f64) -> f64 ---;
 }

-remainder32 :: proc(x, y: f32) -> f32 {
-	return x - round32(x/y) * y;
+tan_f32 :: proc "c" (θ: f32) -> f32 { return sin(θ)/cos(θ); }
+tan_f64 :: proc "c" (θ: f64) -> f64 { return sin(θ)/cos(θ); }
+
+lerp :: proc(a, b: $T, t: $E) -> (x: T) { return a*(1-t) + b*t; }
+
+unlerp_f32 :: proc(a, b, x: f32) -> (t: f32) { return (x-a)/(b-a); }
+unlerp_f64 :: proc(a, b, x: f64) -> (t: f64) { return (x-a)/(b-a); }
+
+
+sign_f32 :: proc(x: f32) -> f32 { return x >= 0 ? +1 : -1; }
+sign_f64 :: proc(x: f64) -> f64 { return x >= 0 ? +1 : -1; }
+
+copy_sign_f32 :: proc(x, y: f32) -> f32 {
+	ix := transmute(u32)x;
+	iy := transmute(u32)y;
+	ix &= 0x7fff_ffff;
+	ix |= iy & 0x8000_0000;
+	return transmute(f32)ix;
 }

-fmod32 :: proc(x, y: f32) -> f32 {
+copy_sign_f64 :: proc(x, y: f64) -> f64 {
+	ix := transmute(u64)x;
+	iy := transmute(u64)y;
+	ix &= 0x7fff_ffff_ffff_ff;
+	ix |= iy & 0x8000_0000_0000_0000;
+	return transmute(f64)ix;
+}
+
+
+sqrt      :: proc[sqrt_f32, sqrt_f64];
+sin       :: proc[sin_f32, sin_f64];
+cos       :: proc[cos_f32, cos_f64];
+tan       :: proc[tan_f32, tan_f64];
+pow       :: proc[pow_f32, pow_f64];
+fmuladd   :: proc[fmuladd_f32, fmuladd_f64];
+sign      :: proc[sign_f32, sign_f64];
+copy_sign :: proc[copy_sign_f32, copy_sign_f64];
+
+
+round_f32 :: proc(x: f32) -> f32 { return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5); }
+round_f64 :: proc(x: f64) -> f64 { return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5); }
+round :: proc[round_f32, round_f64];
+
+floor_f32 :: proc(x: f32) -> f32 { return x >= 0 ? f32(i64(x)) : f32(i64(x-0.5)); } // TODO: Get accurate versions
+floor_f64 :: proc(x: f64) -> f64 { return x >= 0 ? f64(i64(x)) : f64(i64(x-0.5)); } // TODO: Get accurate versions
+floor :: proc[floor_f32, floor_f64];
+
+ceil_f32 :: proc(x: f32) -> f32 { return x < 0 ? f32(i64(x)) : f32(i64(x+1)); }// TODO: Get accurate versions
+ceil_f64 :: proc(x: f64) -> f64 { return x < 0 ? f64(i64(x)) : f64(i64(x+1)); }// TODO: Get accurate versions
+ceil :: proc[ceil_f32, ceil_f64];
+
+remainder_f32 :: proc(x, y: f32) -> f32 { return x - round(x/y) * y; }
+remainder_f64 :: proc(x, y: f64) -> f64 { return x - round(x/y) * y; }
+remainder :: proc[remainder_f32, remainder_f64];
+
+mod_f32 :: proc(x, y: f32) -> f32 {
+	result: f32;
 	y = abs(y);
-	result := remainder32(abs(x), y);
-	if sign32(result) < 0 {
+	result = remainder(abs(x), y);
+	if sign(result) < 0 {
 		result += y;
 	}
-	return copy_sign32(result, x);
+	return copy_sign(result, x);
 }
+mod_f64 :: proc(x, y: f64) -> f64 {
+	result: f64;
+	y = abs(y);
+	result = remainder(abs(x), y);
+	if sign(result) < 0 {
+		result += y;
+	}
+	return copy_sign(result, x);
+}
+mod :: proc[mod_f32, mod_f64];
+


 to_radians :: proc(degrees: f32) -> f32 { return degrees * TAU / 360; }
@@ -90,63 +136,58 @@ to_degrees :: proc(radians: f32) -> f32 { return radians * 360 / TAU; }



-dot2 :: proc(a, b: Vec2) -> f32 { c := a*b; return c.x + c.y; }
-dot3 :: proc(a, b: Vec3) -> f32 { c := a*b; return c.x + c.y + c.z; }
-dot4 :: proc(a, b: Vec4) -> f32 { c := a*b; return c.x + c.y + c.z + c.w; }
+mul :: proc[
+	mat4_mul, mat4_mul_vec4,
+	quat_mul, quat_mulf,
+];

-cross3 :: proc(x, y: Vec3) -> Vec3 {
-	a := swizzle(x, 1, 2, 0) * swizzle(y, 2, 0, 1);
-	b := swizzle(x, 2, 0, 1) * swizzle(y, 1, 2, 0);
-	return a - b;
-}
+div :: proc[
+	quat_div, quat_divf,
+];

+inverse :: proc[mat4_inverse, quat_inverse];
+dot     :: proc[vec_dot, quat_dot];
+cross   :: proc[cross2, cross3];

-vec2_mag :: proc(v: Vec2) -> f32 { return sqrt32(dot2(v, v)); }
-vec3_mag :: proc(v: Vec3) -> f32 { return sqrt32(dot3(v, v)); }
-vec4_mag :: proc(v: Vec4) -> f32 { return sqrt32(dot4(v, v)); }
-
-vec2_norm :: proc(v: Vec2) -> Vec2 { return v / Vec2{vec2_mag(v)}; }
-vec3_norm :: proc(v: Vec3) -> Vec3 { return v / Vec3{vec3_mag(v)}; }
-vec4_norm :: proc(v: Vec4) -> Vec4 { return v / Vec4{vec4_mag(v)}; }
-
-vec2_norm0 :: proc(v: Vec2) -> Vec2 {
-	m := vec2_mag(v);
-	if m == 0 {
-		return Vec2{0};
+vec_dot :: proc(a, b: $T/[$N]$E) -> E {
+	res: E;
+	for i in 0..N {
+		res += a[i] * b[i];
 	}
-	return v / Vec2{m};
+	return res;
 }

-vec3_norm0 :: proc(v: Vec3) -> Vec3 {
-	m := vec3_mag(v);
-	if m == 0 {
-		return Vec3{0};
-	}
-	return v / Vec3{m};
+cross2 :: proc(a, b: $T/[2]$E) -> E {
+	return a[0]*b[1] - a[1]*b[0];
 }

-vec4_norm0 :: proc(v: Vec4) -> Vec4 {
-	m := vec4_mag(v);
-	if m == 0 {
-		return Vec4{0};
-	}
-	return v / Vec4{m};
+cross3 :: proc(a, b: $T/[3]$E) -> T {
+	i := swizzle(a, 1, 2, 0) * swizzle(b, 2, 0, 1);
+	j := swizzle(a, 2, 0, 1) * swizzle(b, 1, 2, 0);
+	return T(i - j);
+}
+
+
+length :: proc(v: $T/[$N]$E) -> E { return sqrt(dot(v, v)); }
+
+norm :: proc(v: $T/[$N]$E) -> T { return v / length(v); }
+
+norm0 :: proc(v: $T/[$N]$E) -> T {
+	m := length(v);
+	return m == 0 ? 0 : v/m;
 }



-mat4_identity :: proc() -> Mat4 {
-	return Mat4{
-		{1, 0, 0, 0},
-		{0, 1, 0, 0},
-		{0, 0, 1, 0},
-		{0, 0, 0, 1},
-	};
+identity :: proc(T: type/[$N][N]$E) -> T {
+	m: T;
+	for i in 0..N do m[i][i] = E(1);
+	return m;
 }

-mat4_transpose :: proc(m: Mat4) -> Mat4 {
-	for j : 0..<4 {
-		for i : 0..<4 {
+transpose :: proc(m: Mat4) -> Mat4 {
+	for j in 0..4 {
+		for i in 0..4 {
 			m[i][j], m[j][i] = m[j][i], m[i][j];
 		}
 	}
@@ -155,8 +196,8 @@ mat4_transpose :: proc(m: Mat4) -> Mat4 {

 mat4_mul :: proc(a, b: Mat4) -> Mat4 {
 	c: Mat4;
-	for j : 0..<4 {
-		for i : 0..<4 {
+	for j in 0..4 {
+		for i in 0..4 {
 			c[j][i] = a[0][i]*b[j][0] +
 			          a[1][i]*b[j][1] +
 			          a[2][i]*b[j][2] +
@@ -168,13 +209,14 @@ mat4_mul :: proc(a, b: Mat4) -> Mat4 {

 mat4_mul_vec4 :: proc(m: Mat4, v: Vec4) -> Vec4 {
 	return Vec4{
-		m[0][0]*v.x + m[1][0]*v.y + m[2][0]*v.z + m[3][0]*v.w,
-		m[0][1]*v.x + m[1][1]*v.y + m[2][1]*v.z + m[3][1]*v.w,
-		m[0][2]*v.x + m[1][2]*v.y + m[2][2]*v.z + m[3][2]*v.w,
-		m[0][3]*v.x + m[1][3]*v.y + m[2][3]*v.z + m[3][3]*v.w,
+		m[0][0]*v[0] + m[1][0]*v[1] + m[2][0]*v[2] + m[3][0]*v[3],
+		m[0][1]*v[0] + m[1][1]*v[1] + m[2][1]*v[2] + m[3][1]*v[3],
+		m[0][2]*v[0] + m[1][2]*v[1] + m[2][2]*v[2] + m[3][2]*v[3],
+		m[0][3]*v[0] + m[1][3]*v[1] + m[2][3]*v[2] + m[3][3]*v[3],
 	};
 }

+
 mat4_inverse :: proc(m: Mat4) -> Mat4 {
 	o: Mat4;

@@ -198,6 +240,7 @@ mat4_inverse :: proc(m: Mat4) -> Mat4 {
 	sf17 := m[1][0] * m[2][2] - m[2][0] * m[1][2];
 	sf18 := m[1][0] * m[2][1] - m[2][0] * m[1][1];

+
 	o[0][0] = +(m[1][1] * sf00 - m[1][2] * sf01 + m[1][3] * sf02);
 	o[0][1] = -(m[1][0] * sf00 - m[1][2] * sf03 + m[1][3] * sf04);
 	o[0][2] = +(m[1][0] * sf01 - m[1][1] * sf03 + m[1][3] * sf05);
@@ -245,73 +288,75 @@ mat4_inverse :: proc(m: Mat4) -> Mat4 {


 mat4_translate :: proc(v: Vec3) -> Mat4 {
-	m := mat4_identity();
-	m[3][0] = v.x;
-	m[3][1] = v.y;
-	m[3][2] = v.z;
+	m := identity(Mat4);
+	m[3][0] = v[0];
+	m[3][1] = v[1];
+	m[3][2] = v[2];
 	m[3][3] = 1;
 	return m;
 }

 mat4_rotate :: proc(v: Vec3, angle_radians: f32) -> Mat4 {
-	c := cos32(angle_radians);
-	s := sin32(angle_radians);
+	c := cos(angle_radians);
+	s := sin(angle_radians);

-	a := vec3_norm(v);
-	t := a * Vec3{1-c};
+	a := norm(v);
+	t := a * (1-c);

-	rot := mat4_identity();
+	rot := identity(Mat4);

-	rot[0][0] = c + t.x*a.x;
-	rot[0][1] = 0 + t.x*a.y + s*a.z;
-	rot[0][2] = 0 + t.x*a.z - s*a.y;
+	rot[0][0] = c + t[0]*a[0];
+	rot[0][1] = 0 + t[0]*a[1] + s*a[2];
+	rot[0][2] = 0 + t[0]*a[2] - s*a[1];
 	rot[0][3] = 0;

-	rot[1][0] = 0 + t.y*a.x - s*a.z;
-	rot[1][1] = c + t.y*a.y;
-	rot[1][2] = 0 + t.y*a.z + s*a.x;
+	rot[1][0] = 0 + t[1]*a[0] - s*a[2];
+	rot[1][1] = c + t[1]*a[1];
+	rot[1][2] = 0 + t[1]*a[2] + s*a[0];
 	rot[1][3] = 0;

-	rot[2][0] = 0 + t.z*a.x + s*a.y;
-	rot[2][1] = 0 + t.z*a.y - s*a.x;
-	rot[2][2] = c + t.z*a.z;
+	rot[2][0] = 0 + t[2]*a[0] + s*a[1];
+	rot[2][1] = 0 + t[2]*a[1] - s*a[0];
+	rot[2][2] = c + t[2]*a[2];
 	rot[2][3] = 0;

 	return rot;
 }

-mat4_scale :: proc(m: Mat4, v: Vec3) -> Mat4 {
-	m[0][0] *= v.x;
-	m[1][1] *= v.y;
-	m[2][2] *= v.z;
+scale_vec3 :: proc(m: Mat4, v: Vec3) -> Mat4 {
+	m[0][0] *= v[0];
+	m[1][1] *= v[1];
+	m[2][2] *= v[2];
 	return m;
 }

-mat4_scalef :: proc(m: Mat4, s: f32) -> Mat4 {
+scale_f32 :: proc(m: Mat4, s: f32) -> Mat4 {
 	m[0][0] *= s;
 	m[1][1] *= s;
 	m[2][2] *= s;
 	return m;
 }

+scale :: proc[scale_vec3, scale_f32];

-mat4_look_at :: proc(eye, centre, up: Vec3) -> Mat4 {
-	f := vec3_norm(centre - eye);
-	s := vec3_norm(cross3(f, up));
-	u := cross3(s, f);

-	m: Mat4;
+look_at :: proc(eye, centre, up: Vec3) -> Mat4 {
+	f := norm(centre - eye);
+	s := norm(cross(f, up));
+	u := cross(s, f);

-	m[0] = Vec4{+s.x, +s.y, +s.z, 0};
-	m[1] = Vec4{+u.x, +u.y, +u.z, 0};
-	m[2] = Vec4{-f.x, -f.y, -f.z, 0};
-	m[3] = Vec4{dot3(s, eye), dot3(u, eye), dot3(f, eye), 1};
-
-	return m;
+	return Mat4{
+		{+s.x, +u.x, -f.x, 0},
+		{+s.y, +u.y, -f.y, 0},
+		{+s.z, +u.z, -f.z, 0},
+		{-dot(s, eye), -dot(u, eye), dot(f, eye), 1},
+	};
 }
-mat4_perspective :: proc(fovy, aspect, near, far: f32) -> Mat4 {
+
+perspective :: proc(fovy, aspect, near, far: f32) -> Mat4 {
 	m: Mat4;
-	tan_half_fovy := tan32(0.5 * fovy);
+	tan_half_fovy := tan(0.5 * fovy);
+
 	m[0][0] = 1.0 / (aspect*tan_half_fovy);
 	m[1][1] = 1.0 / (tan_half_fovy);
 	m[2][2] = -(far + near) / (far - near);
@@ -321,8 +366,8 @@ mat4_perspective :: proc(fovy, aspect, near, far: f32) -> Mat4 {
 }


-mat4_ortho3d :: proc(left, right, bottom, top, near, far: f32) -> Mat4 {
-	m := mat4_identity();
+ortho3d :: proc(left, right, bottom, top, near, far: f32) -> Mat4 {
+	m := identity(Mat4);
 	m[0][0] = +2.0 / (right - left);
 	m[1][1] = +2.0 / (top - bottom);
 	m[2][2] = -2.0 / (far - near);
@@ -333,6 +378,68 @@ mat4_ortho3d :: proc(left, right, bottom, top, near, far: f32) -> Mat4 {
 }


+// Quaternion operations
+
+conj :: proc(q: Quat) -> Quat {
+	return Quat{-q.x, -q.y, -q.z, q.w};
+}
+
+quat_mul :: proc(q0, q1: Quat) -> Quat {
+	d: Quat;
+	d.x = q0.w * q1.x + q0.x * q1.w + q0.y * q1.z - q0.z * q1.y;
+	d.y = q0.w * q1.y - q0.x * q1.z + q0.y * q1.w + q0.z * q1.x;
+	d.z = q0.w * q1.z + q0.x * q1.y - q0.y * q1.x + q0.z * q1.w;
+	d.w = q0.w * q1.w - q0.x * q1.x - q0.y * q1.y - q0.z * q1.z;
+	return d;
+}
+
+quat_mulf :: proc(q: Quat, f: f32) -> Quat { return Quat{q.x*f, q.y*f, q.z*f, q.w*f}; }
+quat_divf :: proc(q: Quat, f: f32) -> Quat { return Quat{q.x/f, q.y/f, q.z/f, q.w/f}; }
+
+quat_div     :: proc(q0, q1: Quat) -> Quat { return mul(q0, quat_inverse(q1)); }
+quat_inverse :: proc(q: Quat) -> Quat { return div(conj(q), dot(q, q)); }
+quat_dot     :: proc(q0, q1: Quat) -> f32 { return q0.x*q1.x + q0.y*q1.y + q0.z*q1.z + q0.w*q1.w; }
+
+quat_norm :: proc(q: Quat) -> Quat {
+	m := sqrt(dot(q, q));
+	return div(q, m);
+}
+
+axis_angle :: proc(axis: Vec3, angle_radians: f32) -> Quat {
+	v := norm(axis) * sin(0.5*angle_radians);
+	w := cos(0.5*angle_radians);
+	return Quat{v.x, v.y, v.z, w};
+}
+
+euler_angles :: proc(pitch, yaw, roll: f32) -> Quat {
+	p := axis_angle(Vec3{1, 0, 0}, pitch);
+	y := axis_angle(Vec3{0, 1, 0}, pitch);
+	r := axis_angle(Vec3{0, 0, 1}, pitch);
+	return mul(mul(y, p), r);
+}
+
+quat_to_mat4 :: proc(q: Quat) -> Mat4 {
+	a := quat_norm(q);
+	xx := a.x*a.x; yy := a.y*a.y; zz := a.z*a.z;
+	xy := a.x*a.y; xz := a.x*a.z; yz := a.y*a.z;
+	wx := a.w*a.x; wy := a.w*a.y; wz := a.w*a.z;
+
+	m := identity(Mat4);
+
+	m[0][0] = 1 - 2*(yy + zz);
+	m[0][1] =     2*(xy + wz);
+	m[0][2] =     2*(xz - wy);
+
+	m[1][0] =     2*(xy - wz);
+	m[1][1] = 1 - 2*(xx + zz);
+	m[1][2] =     2*(yz + wx);
+
+	m[2][0] =     2*(xz + wy);
+	m[2][1] =     2*(yz - wx);
+	m[2][2] = 1 - 2*(xx + yy);
+	return m;
+}
+



@@ -361,6 +468,3 @@ F64_MIN_10_EXP :: -307;                     // min decimal exponent
 F64_MIN_EXP    :: -1021;                    // min binary exponent
 F64_RADIX      :: 2;                        // exponent radix
 F64_ROUNDS     :: 1;                        // addition rounding: near
-
-
-
@@ -0,0 +1,60 @@
+Rand :: struct {
+	state: u64,
+	inc:   u64,
+}
+
+init :: proc(r: ^Rand, seed: u64 = 8675309) {
+	r.state = 0;
+	r.inc = (seed << 1) | 1;
+	_random(r);
+	r.state += seed;
+	_random(r);
+}
+
+_random :: proc(r: ^Rand) -> u32 {
+	old_state := r.state;
+	r.state = old_state * 6364136223846793005 + (r.inc|1);
+	xor_shifted := u32(((old_state>>18) ~ old_state) >> 27);
+	rot := u32(old_state >> 59);
+	return (xor_shifted >> rot) | (xor_shifted << ((-rot) & 31));
+}
+
+uint32 :: proc(r: ^Rand) -> u32 { return _random(r); }
+
+uint64 :: proc(r: ^Rand) -> u64 {
+	a := u64(_random(r));
+	b := u64(_random(r));
+	return (a<<32) | b;
+}
+
+int31 :: proc(r: ^Rand) -> i32 { return i32(uint32(r) << 1 >> 1); }
+int63 :: proc(r: ^Rand) -> i64 { return i64(uint64(r) << 1 >> 1); }
+
+int31_max :: proc(r: ^Rand, n: i32) -> i32 {
+	if n <= 0 do panic("Invalid argument to int31_max");
+	if n&(n-1) == 0 {
+		return int31(r) & (n-1);
+	}
+	max := i32((1<<31) - 1 - (1<<31)&u32(n));
+	v := int31(r);
+	for v > max {
+		v = int31(r);
+	}
+	return v % n;
+}
+
+int63_max :: proc(r: ^Rand, n: i64) -> i64 {
+	if n <= 0 do panic("Invalid argument to int63_max");
+	if n&(n-1) == 0 {
+		return int63(r) & (n-1);
+	}
+	max := i64((1<<63) - 1 - (1<<63)&u64(n));
+	v := int63(r);
+	for v > max {
+		v = int63(r);
+	}
+	return v % n;
+}
+
+float64 :: proc(r: ^Rand) -> f64 { return f64(int63_max(r, 1<<53)) / (1 << 53); }
+float32 :: proc(r: ^Rand) -> f32 { return f32(float64(r)); }
@@ -1,108 +1,114 @@
-#import "fmt.odin";
-#import "os.odin";
+import "core:raw.odin"

-set :: proc(data: rawptr, value: i32, len: int) -> rawptr #link_name "__mem_set" {
-	llvm_memset_64bit :: proc(dst: rawptr, val: byte, len: int, align: i32, is_volatile: bool) #foreign "llvm.memset.p0i8.i64"
-	llvm_memset_64bit(data, value as byte, len, 1, false);
-	return data;
+foreign __llvm_core {
+	@(link_name = "llvm.bswap.i16") swap16 :: proc(b: u16) -> u16 ---;
+	@(link_name = "llvm.bswap.i32") swap32 :: proc(b: u32) -> u32 ---;
+	@(link_name = "llvm.bswap.i64") swap64 :: proc(b: u64) -> u64 ---;
 }
+swap :: proc[swap16, swap32, swap64];

-zero :: proc(data: rawptr, len: int) -> rawptr #link_name "__mem_zero" {
-	return set(data, 0, len);
+
+set :: proc "contextless" (data: rawptr, value: i32, len: int) -> rawptr {
+	return __mem_set(data, value, len);
 }
-
-copy :: proc(dst, src: rawptr, len: int) -> rawptr #link_name "__mem_copy" {
-	// NOTE(bill): This _must_ implemented like C's memmove
-	llvm_memmove_64bit :: proc(dst, src: rawptr, len: int, align: i32, is_volatile: bool) #foreign "llvm.memmove.p0i8.p0i8.i64"
-	llvm_memmove_64bit(dst, src, len, 1, false);
-	return dst;
+zero :: proc "contextless" (data: rawptr, len: int) -> rawptr {
+	return __mem_zero(data, len);
 }
-
-copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr #link_name "__mem_copy_non_overlapping" {
-	// NOTE(bill): This _must_ implemented like C's memcpy
-	llvm_memcpy_64bit :: proc(dst, src: rawptr, len: int, align: i32, is_volatile: bool) #foreign "llvm.memcpy.p0i8.p0i8.i64"
-	llvm_memcpy_64bit(dst, src, len, 1, false);
-	return dst;
+copy :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
+	return __mem_copy(dst, src, len);
 }
-
-compare :: proc(dst, src: rawptr, n: int) -> int #link_name "__mem_compare" {
-	a := slice_ptr(dst as ^byte, n);
-	b := slice_ptr(src as ^byte, n);
-	for i : 0..<n {
-		match {
-		case a[i] < b[i]:
-			return -1;
-		case a[i] > b[i]:
-			return +1;
-		}
-	}
-	return 0;
+copy_non_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
+	return __mem_copy_non_overlapping(dst, src, len);
+}
+compare :: proc "contextless" (a, b: []byte) -> int {
+	return __mem_compare(&a[0], &b[0], min(len(a), len(b)));
 }


+slice_ptr :: proc "contextless" (ptr: ^$T, len: int) -> []T {
+	assert(len >= 0);
+	slice := raw.Slice{data = ptr, len = len};
+	return transmute([]T)slice;
+}

-kilobytes :: proc(x: int) -> int #inline { return          (x) * 1024; }
-megabytes :: proc(x: int) -> int #inline { return kilobytes(x) * 1024; }
-gigabytes :: proc(x: int) -> int #inline { return gigabytes(x) * 1024; }
-terabytes :: proc(x: int) -> int #inline { return terabytes(x) * 1024; }
+slice_to_bytes :: proc "contextless" (slice: $E/[]$T) -> []byte {
+	s := transmute(raw.Slice)slice;
+	s.len *= size_of(T);
+	return transmute([]byte)s;
+}

-is_power_of_two :: proc(x: int) -> bool {
-	if x <= 0 {
-		return false;
-	}
+ptr_to_bytes :: proc "contextless" (ptr: ^$T, len := 1) -> []byte {
+    assert(len >= 0);
+    return transmute([]byte)raw.Slice{ptr, len*size_of(T)};
+}
+
+
+kilobytes :: inline proc "contextless" (x: int) -> int do return          (x) * 1024;
+megabytes :: inline proc "contextless" (x: int) -> int do return kilobytes(x) * 1024;
+gigabytes :: inline proc "contextless" (x: int) -> int do return megabytes(x) * 1024;
+terabytes :: inline proc "contextless" (x: int) -> int do return gigabytes(x) * 1024;
+
+is_power_of_two :: proc(x: uintptr) -> bool {
+	if x <= 0 do return false;
 	return (x & (x-1)) == 0;
 }

-align_forward :: proc(ptr: rawptr, align: int) -> rawptr {
+align_forward :: proc(ptr: rawptr, align: uintptr) -> rawptr {
 	assert(is_power_of_two(align));

-	a := align as uint;
-	p := ptr as uint;
+	a := uintptr(align);
+	p := uintptr(ptr);
 	modulo := p & (a-1);
-	if modulo != 0 {
-		p += a - modulo;
-	}
-	return p as rawptr;
+	if modulo != 0 do p += a - modulo;
+	return rawptr(p);
 }



-Allocation_Header :: struct {
-	size: int;
-}
+AllocationHeader :: struct {size: int};

-allocation_header_fill :: proc(header: ^Allocation_Header, data: rawptr, size: int) {
+allocation_header_fill :: proc(header: ^AllocationHeader, data: rawptr, size: int) {
 	header.size = size;
-	ptr := (header+1) as ^int;
+	ptr := cast(^uint)(header+1);
+	n := cast(^uint)data - ptr;

-	while i := 0; ptr as rawptr < data {
-		(ptr+i)^ = -1;
-		i += 1;
+	for i in 0..n {
+		(ptr+i)^ = ~uint(0);
 	}
 }
-allocation_header :: proc(data: rawptr) -> ^Allocation_Header {
-	p := data as ^int;
-	while (p-1)^ == -1 {
-		p = (p-1);
-	}
-	return (p as ^Allocation_Header)-1;
+allocation_header :: proc(data: rawptr) -> ^AllocationHeader {
+	if data == nil do return nil;
+	p := cast(^uint)data;
+	for (p-1)^ == ~uint(0) do p = (p-1);
+	return cast(^AllocationHeader)(p-1);
 }


+Fixed_Byte_Buffer :: distinct [dynamic]byte;
+
+make_fixed_byte_buffer :: proc(backing: []byte) -> Fixed_Byte_Buffer {
+	s := transmute(raw.Slice)backing;
+	d: raw.Dynamic_Array;
+	d.data = s.data;
+	d.len = 0;
+	d.cap = s.len;
+	d.allocator = nil_allocator();
+	return transmute(Fixed_Byte_Buffer)d;
+}



 // Custom allocators
+
 Arena :: struct {
-	backing:    Allocator;
-	offset:     int;
-	memory:     []byte;
-	temp_count: int;
+	backing:    Allocator,
+	memory:     Fixed_Byte_Buffer,
+	temp_count: int,
 }

-Arena_Temp_Memory :: struct {
-	arena:          ^Arena;
-	original_count: int;
+ArenaTempMemory :: struct {
+	arena:          ^Arena,
+	original_count: int,
 }


@@ -111,22 +117,30 @@ Arena_Temp_Memory :: struct {

 init_arena_from_memory :: proc(using a: ^Arena, data: []byte) {
 	backing    = Allocator{};
-	memory     = data[:0];
+	memory     = make_fixed_byte_buffer(data);
 	temp_count = 0;
 }

 init_arena_from_context :: proc(using a: ^Arena, size: int) {
 	backing = context.allocator;
-	memory = new_slice(byte, size);
+	memory = make_fixed_byte_buffer(make([]byte, size));
 	temp_count = 0;
 }

-free_arena :: proc(using a: ^Arena) {
+
+context_from_allocator :: proc(a: Allocator) -> Context {
+	c := context;
+	c.allocator = a;
+	return c;
+}
+
+destroy_arena :: proc(using a: ^Arena) {
 	if backing.procedure != nil {
-		push_allocator backing {
-			free(memory.data);
-			memory = memory[0:0];
-			offset = 0;
+		context <- context_from_allocator(backing) {
+			if memory != nil {
+				free(&memory[0]);
+			}
+			memory = nil;
 		}
 	}
 }
@@ -139,52 +153,52 @@ arena_allocator :: proc(arena: ^Arena) -> Allocator {
 }

 arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
-                          size, alignment: int,
-                          old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
+                             size, alignment: int,
+                             old_memory: rawptr, old_size: int, flags: u64, location := #caller_location) -> rawptr {
 	using Allocator_Mode;
-	arena := allocator_data as ^Arena;
+	arena := cast(^Arena)allocator_data;

-	match mode {
-	case ALLOC:
+
+	switch mode {
+	case Alloc:
 		total_size := size + alignment;

-		if arena.offset + total_size > arena.memory.count {
-			fmt.fprintln(os.stderr, "Arena out of memory");
+		if len(arena.memory) + total_size > cap(arena.memory) {
 			return nil;
 		}

-		#no_bounds_check end := ^arena.memory[arena.offset];
+		#no_bounds_check end := &arena.memory[len(arena.memory)];

-		ptr := align_forward(end, alignment);
-		arena.offset += total_size;
+		ptr := align_forward(end, uintptr(alignment));
+		(^raw.Slice)(&arena.memory).len += total_size;
 		return zero(ptr, size);

-	case FREE:
+	case Free:
 		// NOTE(bill): Free all at once
-		// Use Arena_Temp_Memory if you want to free a block
+		// Use ArenaTempMemory if you want to free a block

-	case FREE_ALL:
-		arena.offset = 0;
+	case FreeAll:
+		(^raw.Slice)(&arena.memory).len = 0;

-	case RESIZE:
+	case Resize:
 		return default_resize_align(old_memory, old_size, size, alignment);
 	}

 	return nil;
 }

-begin_arena_temp_memory :: proc(a: ^Arena) -> Arena_Temp_Memory {
-	tmp: Arena_Temp_Memory;
+begin_arena_temp_memory :: proc(a: ^Arena) -> ArenaTempMemory {
+	tmp: ArenaTempMemory;
 	tmp.arena = a;
-	tmp.original_count = a.memory.count;
+	tmp.original_count = len(a.memory);
 	a.temp_count += 1;
 	return tmp;
 }

-end_arena_temp_memory :: proc(using tmp: Arena_Temp_Memory) {
-	assert(arena.memory.count >= original_count);
+end_arena_temp_memory :: proc(using tmp: ArenaTempMemory) {
+	assert(len(arena.memory) >= original_count);
 	assert(arena.temp_count > 0);
-	arena.memory.count = original_count;
+	(^raw.Dynamic_Array)(&arena.memory).len = original_count;
 	arena.temp_count -= 1;
 }

@@ -196,9 +210,7 @@ end_arena_temp_memory :: proc(using tmp: Arena_Temp_Memory) {

 align_of_type_info :: proc(type_info: ^Type_Info) -> int {
 	prev_pow2 :: proc(n: i64) -> i64 {
-		if n <= 0 {
-			return 0;
-		}
+		if n <= 0 do return 0;
 		n |= n >> 1;
 		n |= n >> 2;
 		n |= n >> 4;
@@ -209,41 +221,42 @@ align_of_type_info :: proc(type_info: ^Type_Info) -> int {
 	}

 	WORD_SIZE :: size_of(int);
-	MAX_ALIGN :: size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
-	using Type_Info;
-
-	match type info : type_info {
-	case Named:
+	MAX_ALIGN :: 2*align_of(rawptr); // TODO(bill): Should these constants be builtin constants?
+	switch info in type_info.variant {
+	case Type_Info_Named:
 		return align_of_type_info(info.base);
-	case Integer:
-		return info.size;
-	case Float:
-		return info.size;
-	case String:
+	case Type_Info_Integer:
+		return type_info.align;
+	case Type_Info_Rune:
+		return type_info.align;
+	case Type_Info_Float:
+		return type_info.align;
+	case Type_Info_String:
 		return WORD_SIZE;
-	case Boolean:
+	case Type_Info_Boolean:
 		return 1;
-	case Pointer:
+	case Type_Info_Any:
 		return WORD_SIZE;
-	case Maybe:
-		return max(align_of_type_info(info.elem), 1);
-	case Procedure:
+	case Type_Info_Pointer:
 		return WORD_SIZE;
-	case Array:
+	case Type_Info_Procedure:
+		return WORD_SIZE;
+	case Type_Info_Array:
 		return align_of_type_info(info.elem);
-	case Slice:
+	case Type_Info_Dynamic_Array:
 		return WORD_SIZE;
-	case Vector:
-		size := size_of_type_info(info.elem);
-		count := max(prev_pow2(info.count as i64), 1) as int;
-		total := size * count;
-		return clamp(total, 1, MAX_ALIGN);
-	case Struct:
-		return info.align;
-	case Union:
-		return info.align;
-	case Raw_Union:
-		return info.align;
+	case Type_Info_Slice:
+		return WORD_SIZE;
+	case Type_Info_Tuple:
+		return type_info.align;
+	case Type_Info_Struct:
+		return type_info.align;
+	case Type_Info_Union:
+		return type_info.align;
+	case Type_Info_Enum:
+		return align_of_type_info(info.base);
+	case Type_Info_Map:
+		return align_of_type_info(info.generated_struct);
 	}

 	return 0;
@@ -256,68 +269,44 @@ align_formula :: proc(size, align: int) -> int {

 size_of_type_info :: proc(type_info: ^Type_Info) -> int {
 	WORD_SIZE :: size_of(int);
-	using Type_Info;
-	match type info : type_info {
-	case Named:
+	switch info in type_info.variant {
+	case Type_Info_Named:
 		return size_of_type_info(info.base);
-	case Integer:
-		return info.size;
-	case Float:
-		return info.size;
-	case Any:
+	case Type_Info_Integer:
+		return type_info.size;
+	case Type_Info_Rune:
+		return type_info.size;
+	case Type_Info_Float:
+		return type_info.size;
+	case Type_Info_String:
 		return 2*WORD_SIZE;
-	case String:
-		return 2*WORD_SIZE;
-	case Boolean:
+	case Type_Info_Boolean:
 		return 1;
-	case Pointer:
+	case Type_Info_Any:
+		return 2*WORD_SIZE;
+	case Type_Info_Pointer:
 		return WORD_SIZE;
-	case Maybe:
-		return size_of_type_info(info.elem) + 1;
-	case Procedure:
+	case Type_Info_Procedure:
 		return WORD_SIZE;
-	case Array:
+	case Type_Info_Array:
 		count := info.count;
-		if count == 0 {
-			return 0;
-		}
+		if count == 0 do return 0;
 		size      := size_of_type_info(info.elem);
 		align     := align_of_type_info(info.elem);
 		alignment := align_formula(size, align);
 		return alignment*(count-1) + size;
-	case Slice:
-		return 3*WORD_SIZE;
-	case Vector:
-		is_bool :: proc(type_info: ^Type_Info) -> bool {
-			match type info : type_info {
-			case Named:
-				return is_bool(info.base);
-			case Boolean:
-				return true;
-			}
-			return false;
-		}
-
-		count := info.count;
-		if count == 0 {
-			return 0;
-		}
-		bit_size := 8*size_of_type_info(info.elem);
-		if is_bool(info.elem) {
-			// NOTE(bill): LLVM can store booleans as 1 bit because a boolean _is_ an `i1`
-			// Silly LLVM spec
-			bit_size = 1;
-		}
-		total_size_in_bits := bit_size * count;
-		total_size := (total_size_in_bits+7)/8;
-		return total_size;
-
-	case Struct:
-		return info.size;
-	case Union:
-		return info.size;
-	case Raw_Union:
-		return info.size;
+	case Type_Info_Dynamic_Array:
+		return size_of(rawptr) + 2*size_of(int) + size_of(Allocator);
+	case Type_Info_Slice:
+		return 2*WORD_SIZE;
+	case Type_Info_Struct:
+		return type_info.size;
+	case Type_Info_Union:
+		return type_info.size;
+	case Type_Info_Enum:
+		return size_of_type_info(info.base);
+	case Type_Info_Map:
+		return size_of_type_info(info.generated_struct);
 	}

 	return 0;
@@ -1,154 +1,179 @@
-#foreign_system_library "opengl32" when ODIN_OS == "windows";
-#import win32 "sys/windows.odin" when ODIN_OS == "windows";
-#include "opengl_constants.odin";
-
-Clear         :: proc(mask: u32)                                #foreign "glClear"
-ClearColor    :: proc(r, g, b, a: f32)                          #foreign "glClearColor"
-Begin         :: proc(mode: i32)                                #foreign "glBegin"
-End           :: proc()                                         #foreign "glEnd"
-Finish        :: proc()                                         #foreign "glFinish"
-BlendFunc     :: proc(sfactor, dfactor: i32)                    #foreign "glBlendFunc"
-Enable        :: proc(cap: i32)                                 #foreign "glEnable"
-Disable       :: proc(cap: i32)                                 #foreign "glDisable"
-GenTextures   :: proc(count: i32, result: ^u32)                 #foreign "glGenTextures"
-DeleteTextures:: proc(count: i32, result: ^u32)                 #foreign "glDeleteTextures"
-TexParameteri :: proc(target, pname, param: i32)                #foreign "glTexParameteri"
-TexParameterf :: proc(target: i32, pname: i32, param: f32)      #foreign "glTexParameterf"
-BindTexture   :: proc(target: i32, texture: u32)                #foreign "glBindTexture"
-LoadIdentity  :: proc()                                         #foreign "glLoadIdentity"
-Viewport      :: proc(x, y, width, height: i32)                 #foreign "glViewport"
-Ortho         :: proc(left, right, bottom, top, near, far: f64) #foreign "glOrtho"
-Color3f       :: proc(r, g, b: f32)                             #foreign "glColor3f"
-Vertex3f      :: proc(x, y, z: f32)                             #foreign "glVertex3f"
-TexImage2D    :: proc(target, level, internal_format,
-                      width, height, border,
-                      format, _type: i32, pixels: rawptr) #foreign "glTexImage2D"
-
-GetError    :: proc() -> i32            #foreign "glGetError"
-GetString   :: proc(name: i32) -> ^byte #foreign "glGetString"
-GetIntegerv :: proc(name: i32, v: ^i32) #foreign "glGetIntegerv"
-
-
-
-_libgl := win32.LoadLibraryA(("opengl32.dll\x00" as string).data);
-
-GetProcAddress :: proc(name: string) -> proc() #cc_c {
-	assert(name[name.count-1] == 0);
-	res := win32.wglGetProcAddress(name.data);
-	if res == nil {
-		res = win32.GetProcAddress(_libgl, name.data);
-	}
-	return res;
+when ODIN_OS == "windows" {
+	foreign import lib "system:opengl32.lib"
+	import win32 "core:sys/windows.odin"
+	import "core:sys/wgl.odin"
+} else when ODIN_OS == "linux" {
+	foreign import lib "system:gl"
 }

-GenBuffers:       proc(count: i32, buffers: ^u32) #cc_c;
-GenVertexArrays:  proc(count: i32, buffers: ^u32) #cc_c;
-GenSamplers:      proc(count: i32, buffers: ^u32) #cc_c;
-BindBuffer:       proc(target: i32, buffer: u32) #cc_c;
-BindVertexArray:  proc(buffer: u32) #cc_c;
-BindSampler:      proc(position: i32, sampler: u32) #cc_c;
-BufferData:       proc(target: i32, size: int, data: rawptr, usage: i32) #cc_c;
-BufferSubData:    proc(target: i32, offset, size: int, data: rawptr) #cc_c;
+export "core:opengl_constants.odin"

-DrawArrays:       proc(mode, first: i32, count: u32) #cc_c;
-DrawElements:     proc(mode: i32, count: u32, type_: i32, indices: rawptr) #cc_c;
+_ := compile_assert(ODIN_OS != "osx");

-MapBuffer:        proc(target, access: i32) -> rawptr #cc_c;
-UnmapBuffer:      proc(target: i32) #cc_c;
-
-VertexAttribPointer:  proc(index: u32, size, type_: i32, normalized: i32, stride: u32, pointer: rawptr) #cc_c;
-EnableVertexAttribArray:  proc(index: u32) #cc_c;
-
-CreateShader:   proc(shader_type: i32) -> u32 #cc_c;
-ShaderSource:   proc(shader: u32, count: u32, str: ^^byte, length: ^i32) #cc_c;
-CompileShader:  proc(shader: u32) #cc_c;
-CreateProgram:  proc() -> u32 #cc_c;
-AttachShader:   proc(program, shader: u32) #cc_c;
-DetachShader:   proc(program, shader: u32) #cc_c;
-DeleteShader:   proc(shader:  u32) #cc_c;
-LinkProgram:    proc(program: u32) #cc_c;
-UseProgram:     proc(program: u32) #cc_c;
-DeleteProgram:  proc(program: u32) #cc_c;
+@(default_calling_convention="c", link_prefix="gl")
+foreign lib {
+	Clear          :: proc(mask: u32) ---;
+	ClearColor     :: proc(r, g, b, a: f32) ---;
+	Begin          :: proc(mode: i32) ---;
+	End            :: proc() ---;
+	Finish         :: proc() ---;
+	BlendFunc      :: proc(sfactor, dfactor: i32) ---;
+	Enable         :: proc(cap: i32) ---;
+	Disable        :: proc(cap: i32) ---;
+	GenTextures    :: proc(count: i32, result: ^u32) ---;
+	DeleteTextures :: proc(count: i32, result: ^u32) ---;
+	TexParameteri  :: proc(target, pname, param: i32) ---;
+	TexParameterf  :: proc(target: i32, pname: i32, param: f32) ---;
+	BindTexture    :: proc(target: i32, texture: u32) ---;
+	LoadIdentity   :: proc() ---;
+	Viewport       :: proc(x, y, width, height: i32) ---;
+	Ortho          :: proc(left, right, bottom, top, near, far: f64) ---;
+	Color3f        :: proc(r, g, b: f32) ---;
+	Vertex3f       :: proc(x, y, z: f32) ---;
+	GetError       :: proc() -> i32 ---;
+	GetString      :: proc(name: i32) -> ^u8 ---;
+	GetIntegerv    :: proc(name: i32, v: ^i32) ---;
+	TexCoord2f     :: proc(x, y: f32) ---;
+	TexImage2D     :: proc(target, level, internal_format: i32,
+	                       width, height, border: i32,
+	                       format, type_: i32, pixels: rawptr) ---;
+}


-GetShaderiv:        proc(shader:  u32, pname: i32, params: ^i32) #cc_c;
-GetProgramiv:       proc(program: u32, pname: i32, params: ^i32) #cc_c;
-GetShaderInfoLog:   proc(shader:  u32, max_length: u32, length: ^u32, info_long: ^byte) #cc_c;
-GetProgramInfoLog:  proc(program: u32, max_length: u32, length: ^u32, info_long: ^byte) #cc_c;
+_string_data :: inline proc(s: string) -> ^u8 do return &s[0];

-ActiveTexture:   proc(texture: i32) #cc_c;
-GenerateMipmap:  proc(target:  i32) #cc_c;
+_libgl := win32.load_library_a(_string_data("opengl32.dll\x00"));

-SamplerParameteri:     proc(sampler: u32, pname: i32, param: i32) #cc_c;
-SamplerParameterf:     proc(sampler: u32, pname: i32, param: f32) #cc_c;
-SamplerParameteriv:    proc(sampler: u32, pname: i32, params: ^i32) #cc_c;
-SamplerParameterfv:    proc(sampler: u32, pname: i32, params: ^f32) #cc_c;
-SamplerParameterIiv:   proc(sampler: u32, pname: i32, params: ^i32) #cc_c;
-SamplerParameterIuiv:  proc(sampler: u32, pname: i32, params: ^u32) #cc_c;
+get_gl_proc_address :: proc(name: string) -> rawptr {
+	if name[len(name)-1] == 0 {
+		name = name[..len(name)-1];
+	}
+	// NOTE(bill): null terminated
+	assert((&name[0] + len(name))^ == 0);
+	res := wgl.get_gl_proc_address(&name[0]);
+	if res == nil {
+		res = win32.get_proc_address(_libgl, &name[0]);
+	}
+	return rawptr(res);
+}
+
+// Procedures
+	GenBuffers:               proc "c" (count: i32, buffers: ^u32);
+	GenVertexArrays:          proc "c" (count: i32, buffers: ^u32);
+	GenSamplers:              proc "c" (count: i32, buffers: ^u32);
+	DeleteBuffers:            proc "c" (count: i32, buffers: ^u32);
+	BindBuffer:               proc "c" (target: i32, buffer: u32);
+	BindVertexArray:          proc "c" (buffer: u32);
+	DeleteVertexArrays:       proc "c" (count: i32, arrays: ^u32);
+	BindSampler:              proc "c" (position: i32, sampler: u32);
+	BufferData:               proc "c" (target: i32, size: int, data: rawptr, usage: i32);
+	BufferSubData:            proc "c" (target: i32, offset, size: int, data: rawptr);
+
+	DrawArrays:               proc "c" (mode, first: i32, count: u32);
+	DrawElements:             proc "c" (mode: i32, count: u32, type_: i32, indices: rawptr);
+
+	MapBuffer:                proc "c" (target, access: i32) -> rawptr;
+	UnmapBuffer:              proc "c" (target: i32);
+
+	VertexAttribPointer:      proc "c" (index: u32, size, type_: i32, normalized: i32, stride: u32, pointer: rawptr);
+	EnableVertexAttribArray:  proc "c" (index: u32);
+
+	CreateShader:             proc "c" (shader_type: i32) -> u32;
+	ShaderSource:             proc "c" (shader: u32, count: u32, str: ^^u8, length: ^i32);
+	CompileShader:            proc "c" (shader: u32);
+	CreateProgram:            proc "c" () -> u32;
+	AttachShader:             proc "c" (program, shader: u32);
+	DetachShader:             proc "c" (program, shader: u32);
+	DeleteShader:             proc "c" (shader:  u32);
+	LinkProgram:              proc "c" (program: u32);
+	UseProgram:               proc "c" (program: u32);
+	DeleteProgram:            proc "c" (program: u32);


-Uniform1i:         proc(loc: i32, v0: i32) #cc_c;
-Uniform2i:         proc(loc: i32, v0, v1: i32) #cc_c;
-Uniform3i:         proc(loc: i32, v0, v1, v2: i32) #cc_c;
-Uniform4i:         proc(loc: i32, v0, v1, v2, v3: i32) #cc_c;
-Uniform1f:         proc(loc: i32, v0: f32) #cc_c;
-Uniform2f:         proc(loc: i32, v0, v1: f32) #cc_c;
-Uniform3f:         proc(loc: i32, v0, v1, v2: f32) #cc_c;
-Uniform4f:         proc(loc: i32, v0, v1, v2, v3: f32) #cc_c;
-UniformMatrix4fv:  proc(loc: i32, count: u32, transpose: i32, value: ^f32) #cc_c;
+	GetShaderiv:              proc "c" (shader:  u32, pname: i32, params: ^i32);
+	GetProgramiv:             proc "c" (program: u32, pname: i32, params: ^i32);
+	GetShaderInfoLog:         proc "c" (shader:  u32, max_length: u32, length: ^u32, info_long: ^u8);
+	GetProgramInfoLog:        proc "c" (program: u32, max_length: u32, length: ^u32, info_long: ^u8);
+
+	ActiveTexture:            proc "c" (texture: i32);
+	GenerateMipmap:           proc "c" (target:  i32);
+
+	SamplerParameteri:        proc "c" (sampler: u32, pname: i32, param: i32);
+	SamplerParameterf:        proc "c" (sampler: u32, pname: i32, param: f32);
+	SamplerParameteriv:       proc "c" (sampler: u32, pname: i32, params: ^i32);
+	SamplerParameterfv:       proc "c" (sampler: u32, pname: i32, params: ^f32);
+	SamplerParameterIiv:      proc "c" (sampler: u32, pname: i32, params: ^i32);
+	SamplerParameterIuiv:     proc "c" (sampler: u32, pname: i32, params: ^u32);
+
+
+	Uniform1i:                proc "c" (loc: i32, v0: i32);
+	Uniform2i:                proc "c" (loc: i32, v0, v1: i32);
+	Uniform3i:                proc "c" (loc: i32, v0, v1, v2: i32);
+	Uniform4i:                proc "c" (loc: i32, v0, v1, v2, v3: i32);
+	Uniform1f:                proc "c" (loc: i32, v0: f32);
+	Uniform2f:                proc "c" (loc: i32, v0, v1: f32);
+	Uniform3f:                proc "c" (loc: i32, v0, v1, v2: f32);
+	Uniform4f:                proc "c" (loc: i32, v0, v1, v2, v3: f32);
+	UniformMatrix4fv:         proc "c" (loc: i32, count: u32, transpose: i32, value: ^f32);
+
+	GetUniformLocation:       proc "c" (program: u32, name: ^u8) -> i32;

-GetUniformLocation:  proc(program: u32, name: ^byte) -> i32 #cc_c;

 init :: proc() {
-	set_proc_address :: proc(p: rawptr, name: string) #inline { (p as ^(proc() #cc_c))^ = GetProcAddress(name); }
+	set_proc_address :: proc(p: rawptr, name: string) {
+		x := cast(^rawptr)p;
+		x^ = get_gl_proc_address(name);
+	}

-	set_proc_address(^GenBuffers,      "glGenBuffers\x00");
-	set_proc_address(^GenVertexArrays, "glGenVertexArrays\x00");
-	set_proc_address(^GenSamplers,     "glGenSamplers\x00");
-	set_proc_address(^BindBuffer,      "glBindBuffer\x00");
-	set_proc_address(^BindSampler,     "glBindSampler\x00");
-	set_proc_address(^BindVertexArray, "glBindVertexArray\x00");
-	set_proc_address(^BufferData,      "glBufferData\x00");
-	set_proc_address(^BufferSubData,   "glBufferSubData\x00");
+	set_proc_address(&GenBuffers,              "glGenBuffers\x00");
+	set_proc_address(&GenVertexArrays,         "glGenVertexArrays\x00");
+	set_proc_address(&GenSamplers,             "glGenSamplers\x00");
+	set_proc_address(&DeleteBuffers,           "glDeleteBuffers\x00");
+	set_proc_address(&BindBuffer,              "glBindBuffer\x00");
+	set_proc_address(&BindSampler,             "glBindSampler\x00");
+	set_proc_address(&BindVertexArray,         "glBindVertexArray\x00");
+	set_proc_address(&DeleteVertexArrays,      "glDeleteVertexArrays\x00");
+	set_proc_address(&BufferData,              "glBufferData\x00");
+	set_proc_address(&BufferSubData,           "glBufferSubData\x00");

-	set_proc_address(^DrawArrays,      "glDrawArrays\x00");
-	set_proc_address(^DrawElements,    "glDrawElements\x00");
+	set_proc_address(&DrawArrays,              "glDrawArrays\x00");
+	set_proc_address(&DrawElements,            "glDrawElements\x00");

-	set_proc_address(^MapBuffer,   "glMapBuffer\x00");
-	set_proc_address(^UnmapBuffer, "glUnmapBuffer\x00");
+	set_proc_address(&MapBuffer,               "glMapBuffer\x00");
+	set_proc_address(&UnmapBuffer,             "glUnmapBuffer\x00");

-	set_proc_address(^VertexAttribPointer,     "glVertexAttribPointer\x00");
-	set_proc_address(^EnableVertexAttribArray, "glEnableVertexAttribArray\x00");
+	set_proc_address(&VertexAttribPointer,     "glVertexAttribPointer\x00");
+	set_proc_address(&EnableVertexAttribArray, "glEnableVertexAttribArray\x00");

-	set_proc_address(^CreateShader,  "glCreateShader\x00");
-	set_proc_address(^ShaderSource,  "glShaderSource\x00");
-	set_proc_address(^CompileShader, "glCompileShader\x00");
-	set_proc_address(^CreateProgram, "glCreateProgram\x00");
-	set_proc_address(^AttachShader,  "glAttachShader\x00");
-	set_proc_address(^DetachShader,  "glDetachShader\x00");
-	set_proc_address(^DeleteShader,  "glDeleteShader\x00");
-	set_proc_address(^LinkProgram,   "glLinkProgram\x00");
-	set_proc_address(^UseProgram,    "glUseProgram\x00");
-	set_proc_address(^DeleteProgram, "glDeleteProgram\x00");
+	set_proc_address(&CreateShader,            "glCreateShader\x00");
+	set_proc_address(&ShaderSource,            "glShaderSource\x00");
+	set_proc_address(&CompileShader,           "glCompileShader\x00");
+	set_proc_address(&CreateProgram,           "glCreateProgram\x00");
+	set_proc_address(&AttachShader,            "glAttachShader\x00");
+	set_proc_address(&DetachShader,            "glDetachShader\x00");
+	set_proc_address(&DeleteShader,            "glDeleteShader\x00");
+	set_proc_address(&LinkProgram,             "glLinkProgram\x00");
+	set_proc_address(&UseProgram,              "glUseProgram\x00");
+	set_proc_address(&DeleteProgram,           "glDeleteProgram\x00");

-	set_proc_address(^GetShaderiv,       "glGetShaderiv\x00");
-	set_proc_address(^GetProgramiv,      "glGetProgramiv\x00");
-	set_proc_address(^GetShaderInfoLog,  "glGetShaderInfoLog\x00");
-	set_proc_address(^GetProgramInfoLog, "glGetProgramInfoLog\x00");
+	set_proc_address(&GetShaderiv,             "glGetShaderiv\x00");
+	set_proc_address(&GetProgramiv,            "glGetProgramiv\x00");
+	set_proc_address(&GetShaderInfoLog,        "glGetShaderInfoLog\x00");
+	set_proc_address(&GetProgramInfoLog,       "glGetProgramInfoLog\x00");

-	set_proc_address(^ActiveTexture,  "glActiveTexture\x00");
-	set_proc_address(^GenerateMipmap, "glGenerateMipmap\x00");
+	set_proc_address(&ActiveTexture,           "glActiveTexture\x00");
+	set_proc_address(&GenerateMipmap,          "glGenerateMipmap\x00");

-	set_proc_address(^Uniform1i,        "glUniform1i\x00");
-	set_proc_address(^UniformMatrix4fv, "glUniformMatrix4fv\x00");
+	set_proc_address(&Uniform1i,               "glUniform1i\x00");
+	set_proc_address(&UniformMatrix4fv,        "glUniformMatrix4fv\x00");

-	set_proc_address(^GetUniformLocation, "glGetUniformLocation\x00");
+	set_proc_address(&GetUniformLocation,      "glGetUniformLocation\x00");

-	set_proc_address(^SamplerParameteri,    "glSamplerParameteri\x00");
-	set_proc_address(^SamplerParameterf,    "glSamplerParameterf\x00");
-	set_proc_address(^SamplerParameteriv,   "glSamplerParameteriv\x00");
-	set_proc_address(^SamplerParameterfv,   "glSamplerParameterfv\x00");
-	set_proc_address(^SamplerParameterIiv,  "glSamplerParameterIiv\x00");
-	set_proc_address(^SamplerParameterIuiv, "glSamplerParameterIuiv\x00");
+	set_proc_address(&SamplerParameteri,       "glSamplerParameteri\x00");
+	set_proc_address(&SamplerParameterf,       "glSamplerParameterf\x00");
+	set_proc_address(&SamplerParameteriv,      "glSamplerParameteriv\x00");
+	set_proc_address(&SamplerParameterfv,      "glSamplerParameterfv\x00");
+	set_proc_address(&SamplerParameterIiv,     "glSamplerParameterIiv\x00");
+	set_proc_address(&SamplerParameterIuiv,    "glSamplerParameterIuiv\x00");
 }

@@ -1,4 +1,3 @@
-
 FALSE                          :: 0;
 TRUE                           :: 1;

@@ -1383,3 +1382,26 @@ DEBUG_SEVERITY_HIGH_ARB        :: 0x9146;
 DEBUG_SEVERITY_MEDIUM_ARB      :: 0x9147;
 DEBUG_SEVERITY_LOW_ARB         :: 0x9148;

+
+SHADER_BINARY_FORMAT_SPIR_V    :: 0x9551;
+SPIR_V_BINARY                  :: 0x9552;
+PARAMETER_BUFFER               :: 0x80EE;
+PARAMETER_BUFFER_BINDING       :: 0x80EF;
+CONTEXT_FLAG_NO_ERROR_BIT      :: 0x00000008;
+VERTICES_SUBMITTED             :: 0x82EE;
+PRIMITIVES_SUBMITTED           :: 0x82EF;
+VERTEX_SHADER_INVOCATIONS      :: 0x82F0;
+TESS_CONTROL_SHADER_PATCHES    :: 0x82F1;
+TESS_EVALUATION_SHADER_INVOCATIONS :: 0x82F2;
+GEOMETRY_SHADER_PRIMITIVES_EMITTED :: 0x82F3;
+FRAGMENT_SHADER_INVOCATIONS    :: 0x82F4;
+COMPUTE_SHADER_INVOCATIONS     :: 0x82F5;
+CLIPPING_INPUT_PRIMITIVES      :: 0x82F6;
+CLIPPING_OUTPUT_PRIMITIVES     :: 0x82F7;
+POLYGON_OFFSET_CLAMP           :: 0x8E1B;
+SPIR_V_EXTENSIONS              :: 0x9553;
+NUM_SPIR_V_EXTENSIONS          :: 0x9554;
+TEXTURE_MAX_ANISOTROPY         :: 0x84FE;
+MAX_TEXTURE_MAX_ANISOTROPY     :: 0x84FF;
+TRANSFORM_FEEDBACK_OVERFLOW    :: 0x82EC;
+TRANSFORM_FEEDBACK_STREAM_OVERFLOW :: 0x82ED;
@@ -1,2 +1,67 @@
-#include "os_windows.odin" when ODIN_OS == "windows"
+when ODIN_OS == "windows" do export "core:os_windows.odin";
+when ODIN_OS == "osx"     do export "core:os_x.odin";
+when ODIN_OS == "linux"   do export "core:os_linux.odin";
+when ODIN_OS == "essence" do export "core:os_essence.odin";

+import "mem.odin";
+
+write_string :: proc(fd: Handle, str: string) -> (int, Errno) {
+	return write(fd, cast([]byte)str);
+}
+
+write_byte :: proc(fd: Handle, b: byte) -> (int, Errno) {
+	return write(fd, []byte{b});
+}
+
+
+read_entire_file :: proc(name: string) -> (data: []byte, success: bool) {
+	fd, err := open(name, O_RDONLY, 0);
+	if err != 0 {
+		return nil, false;
+	}
+	defer close(fd);
+
+	length: i64;
+	if length, err = file_size(fd); err != 0 {
+		return nil, false;
+	}
+
+	if length <= 0 {
+		return nil, true;
+	}
+
+	data = make([]byte, int(length));
+	if data == nil {
+		return nil, false;
+	}
+
+	bytes_read, read_err := read(fd, data);
+	if read_err != 0 {
+		free(data);
+		return nil, false;
+	}
+	return data[0..bytes_read], true;
+}
+
+write_entire_file :: proc(name: string, data: []byte, truncate := true) -> (success: bool) {
+	flags: int = O_WRONLY|O_CREATE;
+	if truncate {
+		flags |= O_TRUNC;
+	}
+	fd, err := open(name, flags, 0);
+	if err != 0 {
+		return false;
+	}
+	defer close(fd);
+
+	_, write_err := write(fd, data);
+	return write_err == 0;
+}
+
+write_ptr :: proc(fd: Handle, data: rawptr, len: int) -> (int, Errno) {
+	return write(fd, mem.slice_ptr(cast(^byte)data, len));
+}
+
+read_ptr :: proc(fd: Handle, data: rawptr, len: int) -> (int, Errno) {
+	return read(fd, mem.slice_ptr(cast(^byte)data, len));
+}
@@ -0,0 +1,113 @@
+foreign import api "system:api"
+
+Handle    :: distinct int;
+Errno     :: distinct int;
+
+O_RDONLY   :: 1;
+O_WRONLY   :: 2;
+O_CREATE   :: 4;
+O_TRUNC    :: 4;
+
+OS_Node_Type :: enum i32 {
+	File      = 0,
+	Directory = 1,
+}
+
+OS_Node_Information :: struct {
+	handle:   Handle,
+	id:       [16]byte,
+	ntype:    OS_Node_Type,
+	size:     i64,
+	position: i64,
+}
+
+foreign api {
+	@(link_name="OSHelloWorld")       os_hello_world       :: proc() ---;
+	@(link_name="OSPrintDirect")      os_print_direct      :: proc(string: ^byte, length: int) ---;
+	@(link_name="OSHeapAllocate")     os_heap_allocate     :: proc(bytes: int, zero: bool) -> rawptr ---;
+	@(link_name="OSHeapFree")         os_heap_free         :: proc(address: rawptr) ---;
+	@(link_name="OSOpenNode")         os_open_node         :: proc(path: ^byte, path_length: int, flags: u64, information: ^OS_Node_Information) -> Errno ---;
+	@(link_name="OSResizeFile")       os_resize_file       :: proc(handle: Handle, new_size: u64) -> Errno ---;
+	@(link_name="OSCloseHandle")      os_close_handle      :: proc(handle: Handle) ---;
+	@(link_name="OSWriteFileSync")    os_write_file_sync   :: proc(handle: Handle, offset: i64, size: i64, buffer: rawptr) -> i64 ---;
+	@(link_name="OSReadFileSync")     os_read_file_sync    :: proc(handle: Handle, offset: i64, size: i64, buffer: rawptr) -> i64 ---;
+	@(link_name="OSInitialiseAPI")    os_initialise_api    :: proc() -> int ---;
+	@(link_name="OSTerminateProcess") os_terminate_process :: proc(handle: Handle) ---;
+	@(link_name="realloc")            os_heap_reallocate   :: proc(address: rawptr, size: int) -> rawptr ---;
+}
+
+stdin  := Handle(-1); // Not implemented
+stdout := Handle(0);
+stderr := Handle(0);
+
+current_thread_id :: proc() -> int {
+	// Not implemented
+	return -1;
+}
+
+heap_alloc :: proc(size: int) -> rawptr {
+	return os_heap_allocate(size, true);
+}
+
+heap_free :: proc(address: rawptr) {
+	os_heap_free(address);
+}
+
+heap_resize :: proc(address: rawptr, new_size: int) -> rawptr {
+	return os_heap_reallocate(address, new_size);
+}
+
+open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno) {
+	information := new(OS_Node_Information);
+	error := os_open_node(&path[0], len(path), u64(mode), information);
+	if error < -1 do return 0, 1;
+	information.position = 0;
+	if mode&O_TRUNC==O_TRUNC {
+		error := os_resize_file(information.handle, 0);
+		if error < -1 do return 0, 1;
+	}
+	return Handle(uintptr(information)), 0;
+}
+
+close :: proc(fd: Handle) {
+	information := (^OS_Node_Information)(uintptr(fd));
+	os_close_handle(information.handle);
+	free(information);
+}
+
+file_size :: proc(fd: Handle) -> (i64, Errno) {
+	// Not (properly) implemented
+	information := cast(^OS_Node_Information)uintptr(fd);
+	return information.size,0;
+}
+
+write :: proc(fd: Handle, data: []byte) -> (int, Errno) {
+	if fd == 0 {
+		os_print_direct(&data[0], len(data));
+		return len(data), 0;
+	} else if fd == 1 {
+		assert(false);
+		return 0, 1;
+	}
+	information := (^OS_Node_Information)(uintptr(fd));
+	count := os_write_file_sync(information.handle, information.position, i64(len(data)), &data[0]);
+	if count < 0 do  return 0, 1;
+	information.position += count;
+	return int(count), 0;
+}
+
+read :: proc(fd: Handle, data: []byte) -> (int, Errno) {
+	if (fd == 0 || fd == 1) {
+		assert(false);
+		return 0, 1;
+	}
+	information := (^OS_Node_Information)(uintptr(fd));
+	count := os_read_file_sync(information.handle, information.position, i64(len(data)), &data[0]);
+	if count < 0 do return 0, 1;
+	information.position += count;
+	return int(count), 0;
+}
+
+os_terminate_this_process :: proc() {
+	os_terminate_process(0x1001);
+}
@@ -0,0 +1,278 @@
+foreign import dl   "system:dl"
+foreign import libc "system:c"
+
+import "core:strings.odin"
+import "core:mem.odin"
+
+Handle    :: distinct i32;
+File_Time :: distinct u64;
+Errno     :: distinct i32;
+
+
+O_RDONLY   :: 0x00000;
+O_WRONLY   :: 0x00001;
+O_RDWR     :: 0x00002;
+O_CREATE   :: 0x00040;
+O_EXCL     :: 0x00080;
+O_NOCTTY   :: 0x00100;
+O_TRUNC    :: 0x00200;
+O_NONBLOCK :: 0x00800;
+O_APPEND   :: 0x00400;
+O_SYNC     :: 0x01000;
+O_ASYNC    :: 0x02000;
+O_CLOEXEC  :: 0x80000;
+
+
+SEEK_SET   :: 0;
+SEEK_CUR   :: 1;
+SEEK_END   :: 2;
+SEEK_DATA  :: 3;
+SEEK_HOLE  :: 4;
+SEEK_MAX   :: SEEK_HOLE;
+
+// NOTE(zangent): These are OS specific!
+// Do not mix these up!
+RTLD_LAZY         :: 0x001;
+RTLD_NOW          :: 0x002;
+RTLD_BINDING_MASK :: 0x3;
+RTLD_GLOBAL       :: 0x100;
+
+// "Argv" arguments converted to Odin strings
+args := _alloc_command_line_arguments();
+
+_File_Time :: struct {
+	seconds:     i64,
+	nanoseconds: i32,
+	reserved:    i32,
+}
+
+// Translated from
+//  https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.7-4.6/+/jb-dev/sysroot/usr/include/bits/stat.h
+// Validity is not guaranteed.
+
+Stat :: struct {
+	device_id:     u64, // ID of device containing file
+	serial:        u64, // File serial number
+	nlink:         u32, // Number of hard links
+	mode:          u32, // Mode of the file
+	uid:           u32, // User ID of the file's owner
+	gid:           u32, // Group ID of the file's group
+	_padding:      i32, // 32 bits of padding
+	rdev:          u64, // Device ID, if device
+	size:          i64, // Size of the file, in bytes
+	block_size:    i64, // Optimal bllocksize for I/O
+	blocks:        i64, // Number of 512-byte blocks allocated
+
+	last_access:   _File_Time, // Time of last access
+	modified:      _File_Time, // Time of last modification
+	status_change: _File_Time, // Time of last status change
+
+	_reserve1,
+	_reserve2,
+	_reserve3:     i64,
+	serial_numbe:  u64, // File serial number...? Maybe.
+	_reserve4:     i64,
+};
+
+// File type
+S_IFMT   :: 0170000; // Type of file mask
+S_IFIFO  :: 0010000; // Named pipe (fifo)
+S_IFCHR  :: 0020000; // Character special
+S_IFDIR  :: 0040000; // Directory
+S_IFBLK  :: 0060000; // Block special
+S_IFREG  :: 0100000; // Regular
+S_IFLNK  :: 0120000; // Symbolic link
+S_IFSOCK :: 0140000; // Socket
+
+// File mode
+// Read, write, execute/search by owner
+S_IRWXU :: 0000700; // RWX mask for owner
+S_IRUSR :: 0000400; // R for owner
+S_IWUSR :: 0000200; // W for owner
+S_IXUSR :: 0000100; // X for owner
+
+	// Read, write, execute/search by group
+S_IRWXG :: 0000070; // RWX mask for group
+S_IRGRP :: 0000040; // R for group
+S_IWGRP :: 0000020; // W for group
+S_IXGRP :: 0000010; // X for group
+
+	// Read, write, execute/search by others
+S_IRWXO :: 0000007; // RWX mask for other
+S_IROTH :: 0000004; // R for other
+S_IWOTH :: 0000002; // W for other
+S_IXOTH :: 0000001; // X for other
+
+S_ISUID :: 0004000; // Set user id on execution
+S_ISGID :: 0002000; // Set group id on execution
+S_ISVTX :: 0001000; // Directory restrcted delete
+
+
+S_ISLNK  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFLNK;
+S_ISREG  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFREG;
+S_ISDIR  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFDIR;
+S_ISCHR  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFCHR;
+S_ISBLK  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFBLK;
+S_ISFIFO :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFIFO;
+S_ISSOCK :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFSOCK;
+
+F_OK :: 0; // Test for file existance
+X_OK :: 1; // Test for execute permission
+W_OK :: 2; // Test for write permission
+R_OK :: 4; // Test for read permission
+
+foreign libc {
+	@(link_name="open")    _unix_open    :: proc(path: ^byte, mode: int) -> Handle ---;
+	@(link_name="close")   _unix_close   :: proc(fd: Handle) -> i32 ---;
+	@(link_name="read")    _unix_read    :: proc(fd: Handle, buf: rawptr, size: int) -> int ---;
+	@(link_name="write")   _unix_write   :: proc(fd: Handle, buf: rawptr, size: int) -> int ---;
+	@(link_name="lseek64") _unix_seek    :: proc(fd: Handle, offset: i64, whence: i32) -> i64 ---;
+	@(link_name="gettid")  _unix_gettid  :: proc() -> u64 ---;
+	@(link_name="stat")    _unix_stat    :: proc(path: ^byte, stat: ^Stat) -> i32 ---;
+	@(link_name="access")  _unix_access  :: proc(path: ^byte, mask: int) -> i32 ---;
+
+	@(link_name="malloc")  _unix_malloc  :: proc(size: int) -> rawptr ---;
+	@(link_name="calloc")  _unix_calloc  :: proc(num, size: int) -> rawptr ---;
+	@(link_name="free")    _unix_free    :: proc(ptr: rawptr) ---;
+	@(link_name="realloc") _unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr ---;
+	@(link_name="getenv")  _unix_getenv  :: proc(^byte) -> ^byte ---;
+
+	@(link_name="exit")    _unix_exit    :: proc(status: int) ---;
+}
+foreign dl {
+	@(link_name="dlopen")  _unix_dlopen  :: proc(filename: ^byte, flags: int) -> rawptr ---;
+	@(link_name="dlsym")   _unix_dlsym   :: proc(handle: rawptr, symbol: ^byte) -> rawptr ---;
+	@(link_name="dlclose") _unix_dlclose :: proc(handle: rawptr) -> int ---;
+	@(link_name="dlerror") _unix_dlerror :: proc() -> ^byte ---;
+}
+
+// TODO(zangent): Change this to just `open` when Bill fixes overloading.
+open_simple :: proc(path: string, mode: int) -> (Handle, Errno) {
+
+	cstr := strings.new_c_string(path);
+	handle := _unix_open(cstr, mode);
+	free(cstr);
+	if(handle == -1) {
+		return 0, 1;
+	}
+	return handle, 0;
+}
+// NOTE(zangent): This is here for compatability reasons. Should this be here?
+open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno) {
+	return open_simple(path, mode);
+}
+
+close :: proc(fd: Handle) {
+	_unix_close(fd);
+}
+
+read :: proc(fd: Handle, data: []byte) -> (int, Errno) {
+	sz := _unix_read(fd, &data[0], len(data));
+	return sz, 0;
+}
+
+write :: proc(fd: Handle, data: []byte) -> (int, Errno) {
+	sz := _unix_write(fd, &data[0], len(data));
+	return sz, 0;
+}
+
+seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
+	res := _unix_seek(fd, offset, i32(whence));
+	return res, 0;
+}
+
+file_size :: proc(fd: Handle) -> (i64, Errno) {
+	prev, _   := seek(fd, 0, SEEK_CUR);
+	size, err := seek(fd, 0, SEEK_END);
+	seek(fd, prev, SEEK_SET);
+	return size, err;
+}
+
+
+// NOTE(bill): Uses startup to initialize it
+
+stdin:  Handle = 0;
+stdout: Handle = 1;
+stderr: Handle = 2;
+
+/* TODO(zangent): Implement these!
+last_write_time :: proc(fd: Handle) -> File_Time {}
+last_write_time_by_name :: proc(name: string) -> File_Time {}
+*/
+
+stat :: inline proc(path: string) -> (Stat, int) {
+	cstr := strings.new_c_string(path);
+	defer free(cstr);
+
+	s: Stat;
+	ret_int := _unix_stat(cstr, &s);
+	return s, int(ret_int);
+}
+
+access :: inline proc(path: string, mask: int) -> bool {
+	cstr := strings.new_c_string(path);
+	defer free(cstr);
+	return _unix_access(cstr, mask) == 0;
+}
+
+heap_alloc :: proc(size: int) -> rawptr {
+	assert(size > 0);
+	return _unix_calloc(1, size);
+}
+
+heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
+	return _unix_realloc(ptr, new_size);
+}
+
+heap_free :: proc(ptr: rawptr) {
+	_unix_free(ptr);
+}
+
+getenv :: proc(name: string) -> (string, bool) {
+	path_str := strings.new_c_string(name);
+	defer free(path_str);
+	cstr := _unix_getenv(path_str);
+	if cstr == nil {
+		return "", false;
+	}
+	return strings.to_odin_string(cstr), true;
+}
+
+exit :: proc(code: int) {
+	_unix_exit(code);
+}
+
+current_thread_id :: proc() -> int {
+	// return int(_unix_gettid());
+	return 0;
+}
+
+dlopen :: inline proc(filename: string, flags: int) -> rawptr {
+	cstr := strings.new_c_string(filename);
+	defer free(cstr);
+	handle := _unix_dlopen(cstr, flags);
+	return handle;
+}
+dlsym :: inline proc(handle: rawptr, symbol: string) -> rawptr {
+	assert(handle != nil);
+	cstr := strings.new_c_string(symbol);
+	defer free(cstr);
+	proc_handle := _unix_dlsym(handle, cstr);
+	return proc_handle;
+}
+dlclose :: inline proc(handle: rawptr) -> bool {
+	assert(handle != nil);
+	return _unix_dlclose(handle) == 0;
+}
+dlerror :: proc() -> string {
+	return strings.to_odin_string(_unix_dlerror());
+}
+
+
+_alloc_command_line_arguments :: proc() -> []string {
+	args := make([]string, __argc__);
+	for i in 0..__argc__ {
+		args[i] = strings.to_odin_string((__argv__+i)^);
+	}
+	return args;
+}
@@ -1,18 +1,19 @@
-#import win32 "sys/windows.odin";
-#import "fmt.odin";
+import win32 "core:sys/windows.odin"
+import "core:mem.odin"
+
+Handle    :: distinct uintptr;
+File_Time :: distinct u64;
+Errno     :: distinct int;


-Handle    :: int;
-File_Time :: u64;
-Errno     :: int;
+INVALID_HANDLE :: ~Handle(0);

-INVALID_HANDLE: Handle : -1;


 O_RDONLY   :: 0x00000;
 O_WRONLY   :: 0x00001;
 O_RDWR     :: 0x00002;
-O_CREAT    :: 0x00040;
+O_CREATE   :: 0x00040;
 O_EXCL     :: 0x00080;
 O_NOCTTY   :: 0x00100;
 O_TRUNC    :: 0x00200;
@@ -22,135 +23,167 @@ O_SYNC     :: 0x01000;
 O_ASYNC    :: 0x02000;
 O_CLOEXEC  :: 0x80000;

-ERROR_NONE:                Errno : 0;
-ERROR_FILE_NOT_FOUND:      Errno : 2;
-ERROR_PATH_NOT_FOUND:      Errno : 3;
-ERROR_ACCESS_DENIED:       Errno : 5;
-ERROR_NO_MORE_FILES:       Errno : 18;
-ERROR_HANDLE_EOF:          Errno : 38;
-ERROR_NETNAME_DELETED:     Errno : 64;
-ERROR_FILE_EXISTS:         Errno : 80;
-ERROR_BROKEN_PIPE:         Errno : 109;
-ERROR_BUFFER_OVERFLOW:     Errno : 111;
-ERROR_INSUFFICIENT_BUFFER: Errno : 122;
-ERROR_MOD_NOT_FOUND:       Errno : 126;
-ERROR_PROC_NOT_FOUND:      Errno : 127;
-ERROR_DIR_NOT_EMPTY:       Errno : 145;
-ERROR_ALREADY_EXISTS:      Errno : 183;
-ERROR_ENVVAR_NOT_FOUND:    Errno : 203;
-ERROR_MORE_DATA:           Errno : 234;
-ERROR_OPERATION_ABORTED:   Errno : 995;
-ERROR_IO_PENDING:          Errno : 997;
-ERROR_NOT_FOUND:           Errno : 1168;
-ERROR_PRIVILEGE_NOT_HELD:  Errno : 1314;
-WSAEACCES:                 Errno : 10013;
-WSAECONNRESET:             Errno : 10054;
+
+ERROR_NONE:                   Errno : 0;
+ERROR_FILE_NOT_FOUND:         Errno : 2;
+ERROR_PATH_NOT_FOUND:         Errno : 3;
+ERROR_ACCESS_DENIED:          Errno : 5;
+ERROR_NO_MORE_FILES:          Errno : 18;
+ERROR_HANDLE_EOF:             Errno : 38;
+ERROR_NETNAME_DELETED:        Errno : 64;
+ERROR_FILE_EXISTS:            Errno : 80;
+ERROR_BROKEN_PIPE:            Errno : 109;
+ERROR_BUFFER_OVERFLOW:        Errno : 111;
+ERROR_INSUFFICIENT_BUFFER:    Errno : 122;
+ERROR_MOD_NOT_FOUND:          Errno : 126;
+ERROR_PROC_NOT_FOUND:         Errno : 127;
+ERROR_DIR_NOT_EMPTY:          Errno : 145;
+ERROR_ALREADY_EXISTS:         Errno : 183;
+ERROR_ENVVAR_NOT_FOUND:       Errno : 203;
+ERROR_MORE_DATA:              Errno : 234;
+ERROR_OPERATION_ABORTED:      Errno : 995;
+ERROR_IO_PENDING:             Errno : 997;
+ERROR_NOT_FOUND:              Errno : 1168;
+ERROR_PRIVILEGE_NOT_HELD:     Errno : 1314;
+WSAEACCES:                    Errno : 10013;
+WSAECONNRESET:                Errno : 10054;

 // Windows reserves errors >= 1<<29 for application use
-ERROR_FILE_IS_PIPE: Errno : 1<<29 + 0;
+ERROR_FILE_IS_PIPE:           Errno : 1<<29 + 0;


+// "Argv" arguments converted to Odin strings
+args := _alloc_command_line_arguments();


-open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
-	using win32;
-	if path.count == 0 {
-		return INVALID_HANDLE, ERROR_FILE_NOT_FOUND;
-	}
+open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno) {
+	if len(path) == 0 do return INVALID_HANDLE, ERROR_FILE_NOT_FOUND;

 	access: u32;
-	match mode & (O_RDONLY|O_WRONLY|O_RDWR) {
-	case O_RDONLY: access = FILE_GENERIC_READ;
-	case O_WRONLY: access = FILE_GENERIC_WRITE;
-	case O_RDWR:   access = FILE_GENERIC_READ | FILE_GENERIC_WRITE;
+	switch mode & (O_RDONLY|O_WRONLY|O_RDWR) {
+	case O_RDONLY: access = win32.FILE_GENERIC_READ;
+	case O_WRONLY: access = win32.FILE_GENERIC_WRITE;
+	case O_RDWR:   access = win32.FILE_GENERIC_READ | win32.FILE_GENERIC_WRITE;
 	}

-	if mode&O_CREAT != 0 {
-		access |= FILE_GENERIC_WRITE;
+	if mode&O_CREATE != 0 {
+		access |= win32.FILE_GENERIC_WRITE;
 	}
 	if mode&O_APPEND != 0 {
-		access &~= FILE_GENERIC_WRITE;
-		access |= FILE_APPEND_DATA;
+		access &~= win32.FILE_GENERIC_WRITE;
+		access |=  win32.FILE_APPEND_DATA;
 	}

-	share_mode := (FILE_SHARE_READ|FILE_SHARE_WRITE) as u32;
-	sa: ^SECURITY_ATTRIBUTES = nil;
-	sa_inherit := SECURITY_ATTRIBUTES{length = size_of(SECURITY_ATTRIBUTES), inherit_handle = 1};
+	share_mode := u32(win32.FILE_SHARE_READ|win32.FILE_SHARE_WRITE);
+	sa: ^win32.Security_Attributes = nil;
+	sa_inherit := win32.Security_Attributes{length = size_of(win32.Security_Attributes), inherit_handle = true};
 	if mode&O_CLOEXEC == 0 {
-		sa = ^sa_inherit;
+		sa = &sa_inherit;
 	}

 	create_mode: u32;
-	match {
-	case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL):
-		create_mode = CREATE_NEW;
-	case mode&(O_CREAT|O_TRUNC) == (O_CREAT | O_TRUNC):
-		create_mode = CREATE_ALWAYS;
-	case mode&O_CREAT == O_CREAT:
-		create_mode = OPEN_ALWAYS;
+	switch {
+	case mode&(O_CREATE|O_EXCL) == (O_CREATE | O_EXCL):
+		create_mode = win32.CREATE_NEW;
+	case mode&(O_CREATE|O_TRUNC) == (O_CREATE | O_TRUNC):
+		create_mode = win32.CREATE_ALWAYS;
+	case mode&O_CREATE == O_CREATE:
+		create_mode = win32.OPEN_ALWAYS;
 	case mode&O_TRUNC == O_TRUNC:
-		create_mode = TRUNCATE_EXISTING;
-	default:
-		create_mode = OPEN_EXISTING;
+		create_mode = win32.TRUNCATE_EXISTING;
+	case:
+		create_mode = win32.OPEN_EXISTING;
 	}

 	buf: [300]byte;
-	copy(buf[:], path as []byte);
+	copy(buf[..], cast([]byte)path);

-	handle := CreateFileA(^buf[0], access, share_mode, sa, create_mode, FILE_ATTRIBUTE_NORMAL, nil) as Handle;
-	if handle != INVALID_HANDLE {
-		return handle, ERROR_NONE;
-	}
-	err := GetLastError();
-	return INVALID_HANDLE, err as Errno;
+	handle := Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil));
+	if handle != INVALID_HANDLE do return handle, ERROR_NONE;
+
+	err := Errno(win32.get_last_error());
+	return INVALID_HANDLE, err;
 }

 close :: proc(fd: Handle) {
-	win32.CloseHandle(fd as win32.HANDLE);
+	win32.close_handle(win32.Handle(fd));
 }

+
 write :: proc(fd: Handle, data: []byte) -> (int, Errno) {
-	bytes_written: i32;
-	e := win32.WriteFile(fd as win32.HANDLE, data.data, data.count as i32, ^bytes_written, nil);
-	if e == win32.FALSE {
-		err := win32.GetLastError();
-		return 0, err as Errno;
+	if len(data) == 0 do return 0, ERROR_NONE;
+
+	single_write_length: i32;
+	total_write: i64;
+	length := i64(len(data));
+
+	for total_write < length {
+		remaining := length - total_write;
+		MAX :: 1<<31-1;
+		to_write: i32 = min(i32(remaining), MAX);
+
+		e := win32.write_file(win32.Handle(fd), &data[total_write], to_write, &single_write_length, nil);
+		if single_write_length <= 0 || !e {
+			err := Errno(win32.get_last_error());
+			return int(total_write), err;
+		}
+		total_write += i64(single_write_length);
 	}
-	return bytes_written as int, ERROR_NONE;
+	return int(total_write), ERROR_NONE;
 }

 read :: proc(fd: Handle, data: []byte) -> (int, Errno) {
-	bytes_read: i32;
-	e := win32.ReadFile(fd as win32.HANDLE, data.data, data.count as u32, ^bytes_read, nil);
-	if e == win32.FALSE {
-		err := win32.GetLastError();
-		return 0, err as Errno;
+	if len(data) == 0 do return 0, ERROR_NONE;
+
+	single_read_length: i32;
+	total_read: i64;
+	length := i64(len(data));
+
+	for total_read < length {
+		remaining := length - total_read;
+		MAX :: 1<<32-1;
+		to_read: u32 = min(u32(remaining), MAX);
+
+		e := win32.read_file(win32.Handle(fd), &data[total_read], to_read, &single_read_length, nil);
+		if single_read_length <= 0 || !e {
+			err := Errno(win32.get_last_error());
+			return int(total_read), err;
+		}
+		total_read += i64(single_read_length);
 	}
-	return bytes_read as int, ERROR_NONE;
+	return int(total_read), ERROR_NONE;
 }

 seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
-	using win32;
 	w: u32;
-	match whence {
-	case 0: w = FILE_BEGIN;
-	case 1: w = FILE_CURRENT;
-	case 2: w = FILE_END;
+	switch whence {
+	case 0: w = win32.FILE_BEGIN;
+	case 1: w = win32.FILE_CURRENT;
+	case 2: w = win32.FILE_END;
 	}
-	hi := (offset>>32) as i32;
-	lo := offset as i32;
-	ft := GetFileType(fd as HANDLE);
-	if ft == FILE_TYPE_PIPE {
-		return 0, ERROR_FILE_IS_PIPE;
+	hi := i32(offset>>32);
+	lo := i32(offset);
+	ft := win32.get_file_type(win32.Handle(fd));
+	if ft == win32.FILE_TYPE_PIPE do return 0, ERROR_FILE_IS_PIPE;
+
+	dw_ptr := win32.set_file_pointer(win32.Handle(fd), lo, &hi, w);
+	if dw_ptr == win32.INVALID_SET_FILE_POINTER {
+		err := Errno(win32.get_last_error());
+		return 0, err;
 	}
-	dw_ptr := SetFilePointer(fd as HANDLE, lo, ^hi, w);
-	if dw_ptr == INVALID_SET_FILE_POINTER {
-		err := GetLastError();
-		return 0, err as Errno;
-	}
-	return (hi as i64)<<32 + (dw_ptr as i64), ERROR_NONE;
+	return i64(hi)<<32 + i64(dw_ptr), ERROR_NONE;
 }

+file_size :: proc(fd: Handle) -> (i64, Errno) {
+	length: i64;
+	err: Errno;
+	if !win32.get_file_size_ex(win32.Handle(fd), &length) {
+		err = Errno(win32.get_last_error());
+	}
+	return length, err;
+}
+
+

 // NOTE(bill): Uses startup to initialize it
 stdin  := get_std_handle(win32.STD_INPUT_HANDLE);
@@ -159,9 +192,9 @@ stderr := get_std_handle(win32.STD_ERROR_HANDLE);


 get_std_handle :: proc(h: int) -> Handle {
-	fd := win32.GetStdHandle(h as i32);
-	win32.SetHandleInformation(fd, win32.HANDLE_FLAG_INHERIT, 0);
-	return fd as Handle;
+	fd := win32.get_std_handle(i32(h));
+	win32.set_handle_information(fd, win32.HANDLE_FLAG_INHERIT, 0);
+	return Handle(fd);
 }


@@ -170,104 +203,112 @@ get_std_handle :: proc(h: int) -> Handle {


 last_write_time :: proc(fd: Handle) -> File_Time {
-	file_info: win32.BY_HANDLE_FILE_INFORMATION;
-	win32.GetFileInformationByHandle(fd as win32.HANDLE, ^file_info);
-	lo := file_info.last_write_time.lo as File_Time;
-	hi := file_info.last_write_time.hi as File_Time;
+	file_info: win32.By_Handle_File_Information;
+	win32.get_file_information_by_handle(win32.Handle(fd), &file_info);
+	lo := File_Time(file_info.last_write_time.lo);
+	hi := File_Time(file_info.last_write_time.hi);
 	return lo | hi << 32;
 }

 last_write_time_by_name :: proc(name: string) -> File_Time {
-	last_write_time: win32.FILETIME;
-	data: win32.FILE_ATTRIBUTE_DATA;
+	last_write_time: win32.Filetime;
+	data: win32.File_Attribute_Data;
 	buf: [1024]byte;

-	assert(buf.count > name.count);
+	assert(len(buf) > len(name));

-	copy(buf[:], name as []byte);
+	copy(buf[..], cast([]byte)name);

-	if win32.GetFileAttributesExA(^buf[0], win32.GetFileExInfoStandard, ^data) != 0 {
+	if win32.get_file_attributes_ex_a(&buf[0], win32.GetFileExInfoStandard, &data) {
 		last_write_time = data.last_write_time;
 	}

-	l := last_write_time.lo as File_Time;
-	h := last_write_time.hi as File_Time;
+	l := File_Time(last_write_time.lo);
+	h := File_Time(last_write_time.hi);
 	return l | h << 32;
 }



-
-
-read_entire_file :: proc(name: string) -> ([]byte, bool) {
-	buf: [300]byte;
-	copy(buf[:], name as []byte);
-
-	fd, err := open(name, O_RDONLY, 0);
-	if err != ERROR_NONE {
-		return nil, false;
-	}
-	defer close(fd);
-
-	length: i64;
-	file_size_ok := win32.GetFileSizeEx(fd as win32.HANDLE, ^length) != 0;
-	if !file_size_ok {
-		return nil, false;
-	}
-
-	data := new_slice(u8, length);
-	if data.data == nil {
-		return nil, false;
-	}
-
-	single_read_length: i32;
-	total_read: i64;
-
-	while total_read < length {
-		remaining := length - total_read;
-		to_read: u32;
-		MAX :: 1<<32-1;
-		if remaining <= MAX {
-			to_read = remaining as u32;
-		} else {
-			to_read = MAX;
-		}
-
-		win32.ReadFile(fd as win32.HANDLE, ^data[total_read], to_read, ^single_read_length, nil);
-		if single_read_length <= 0 {
-			free(data.data);
-			return nil, false;
-		}
-
-		total_read += single_read_length as i64;
-	}
-
-	return data, true;
-}
-
-
-
 heap_alloc :: proc(size: int) -> rawptr {
-	return win32.HeapAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, size);
+	return win32.heap_alloc(win32.get_process_heap(), win32.HEAP_ZERO_MEMORY, size);
 }
 heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
-	return win32.HeapReAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, ptr, new_size);
+	if new_size == 0 {
+		heap_free(ptr);
+		return nil;
+	}
+	if ptr == nil do return heap_alloc(new_size);
+
+	return win32.heap_realloc(win32.get_process_heap(), win32.HEAP_ZERO_MEMORY, ptr, new_size);
 }
 heap_free :: proc(ptr: rawptr) {
-	win32.HeapFree(win32.GetProcessHeap(), 0, ptr);
+	if ptr == nil do return;
+	win32.heap_free(win32.get_process_heap(), 0, ptr);
 }


 exit :: proc(code: int) {
-	win32.ExitProcess(code as u32);
+	win32.exit_process(u32(code));
 }



 current_thread_id :: proc() -> int {
-	GetCurrentThreadId :: proc() -> u32 #foreign #dll_import
-	return GetCurrentThreadId() as int;
+	return int(win32.get_current_thread_id());
 }



+
+_alloc_command_line_arguments :: proc() -> []string {
+	alloc_ucs2_to_utf8 :: proc(wstr: ^u16) -> string {
+		wstr_len := 0;
+		for (wstr+wstr_len)^ != 0 do wstr_len += 1;
+
+		len := 2*wstr_len-1;
+		buf := make([]byte, len+1);
+		str := mem.slice_ptr(wstr, wstr_len+1);
+
+		i, j := 0, 0;
+		for str[j] != 0 {
+			switch {
+			case str[j] < 0x80:
+				if i+1 > len do return "";
+				buf[i] = byte(str[j]); i += 1;
+				j += 1;
+			case str[j] < 0x800:
+				if i+2 > len do return "";
+				buf[i] = byte(0xc0 + (str[j]>>6));   i += 1;
+				buf[i] = byte(0x80 + (str[j]&0x3f)); i += 1;
+				j += 1;
+			case 0xd800 <= str[j] && str[j] < 0xdc00:
+				if i+4 > len do return "";
+			c := rune((str[j] - 0xd800) << 10) + rune((str[j+1]) - 0xdc00) + 0x10000;
+				buf[i] = byte(0xf0 +  (c >> 18));         i += 1;
+				buf[i] = byte(0x80 + ((c >> 12) & 0x3f)); i += 1;
+				buf[i] = byte(0x80 + ((c >>  6) & 0x3f)); i += 1;
+				buf[i] = byte(0x80 + ((c      ) & 0x3f)); i += 1;
+				j += 2;
+			case 0xdc00 <= str[j] && str[j] < 0xe000:
+				return "";
+			case:
+				if i+3 > len do return "";
+				buf[i] = 0xe0 + byte (str[j] >> 12);         i += 1;
+				buf[i] = 0x80 + byte((str[j] >>  6) & 0x3f); i += 1;
+				buf[i] = 0x80 + byte((str[j]      ) & 0x3f); i += 1;
+				j += 1;
+			}
+		}
+
+		return string(buf[..i]);
+	}
+
+	arg_count: i32;
+	arg_list_ptr := win32.command_line_to_argv_w(win32.get_command_line_w(), &arg_count);
+	arg_list := make([]string, int(arg_count));
+	for _, i in arg_list do arg_list[i] = alloc_ucs2_to_utf8((arg_list_ptr+i)^);
+	return arg_list;
+}
+
+
@@ -0,0 +1,292 @@
+foreign import dl   "system:dl"
+foreign import libc "system:c"
+
+import "core:strings.odin"
+import "core:mem.odin"
+
+Handle    :: distinct i32;
+File_Time :: distinct u64;
+Errno     :: distinct int;
+
+
+O_RDONLY   :: 0x00000;
+O_WRONLY   :: 0x00001;
+O_RDWR     :: 0x00002;
+O_CREATE   :: 0x00040;
+O_EXCL     :: 0x00080;
+O_NOCTTY   :: 0x00100;
+O_TRUNC    :: 0x00200;
+O_NONBLOCK :: 0x00800;
+O_APPEND   :: 0x00400;
+O_SYNC     :: 0x01000;
+O_ASYNC    :: 0x02000;
+O_CLOEXEC  :: 0x80000;
+
+
+SEEK_SET   :: 0;
+SEEK_CUR   :: 1;
+SEEK_END   :: 2;
+SEEK_DATA  :: 3;
+SEEK_HOLE  :: 4;
+SEEK_MAX   :: SEEK_HOLE;
+
+
+
+// NOTE(zangent): These are OS specific!
+// Do not mix these up!
+RTLD_LAZY     :: 0x1;
+RTLD_NOW      :: 0x2;
+RTLD_LOCAL    :: 0x4;
+RTLD_GLOBAL   :: 0x8;
+RTLD_NODELETE :: 0x80;
+RTLD_NOLOAD   :: 0x10;
+RTLD_FIRST    :: 0x100;
+
+
+// "Argv" arguments converted to Odin strings
+args := _alloc_command_line_arguments();
+
+_File_Time :: struct {
+	seconds: i64,
+	nanoseconds: i64,
+}
+
+Stat :: struct {
+	device_id:     i32, // ID of device containing file
+	mode:          u16, // Mode of the file
+	nlink:         u16, // Number of hard links
+	serial:        u64, // File serial number
+	uid:           u32, // User ID of the file's owner
+	gid:           u32, // Group ID of the file's group
+	rdev:          i32, // Device ID, if device
+
+	last_access:   File_Time, // Time of last access
+	modified:      File_Time, // Time of last modification
+	status_change: File_Time, // Time of last status change
+	created:       File_Time, // Time of creation
+
+	size:          i64,  // Size of the file, in bytes
+	blocks:        i64,  // Number of blocks allocated for the file
+	block_size:    i32,  // Optimal blocksize for I/O
+	flags:         u32,  // User-defined flags for the file
+	gen_num:       u32,  // File generation number ...?
+	_spare:        i32,  // RESERVED
+	_reserve1,
+	_reserve2:     i64,  // RESERVED
+};
+
+// File type
+S_IFMT   :: 0170000; // Type of file mask
+S_IFIFO  :: 0010000; // Named pipe (fifo)
+S_IFCHR  :: 0020000; // Character special
+S_IFDIR  :: 0040000; // Directory
+S_IFBLK  :: 0060000; // Block special
+S_IFREG  :: 0100000; // Regular
+S_IFLNK  :: 0120000; // Symbolic link
+S_IFSOCK :: 0140000; // Socket
+
+// File mode
+// Read, write, execute/search by owner
+S_IRWXU :: 0000700; // RWX mask for owner
+S_IRUSR :: 0000400; // R for owner
+S_IWUSR :: 0000200; // W for owner
+S_IXUSR :: 0000100; // X for owner
+
+// Read, write, execute/search by group
+S_IRWXG :: 0000070; // RWX mask for group
+S_IRGRP :: 0000040; // R for group
+S_IWGRP :: 0000020; // W for group
+S_IXGRP :: 0000010; // X for group
+
+// Read, write, execute/search by others
+S_IRWXO :: 0000007; // RWX mask for other
+S_IROTH :: 0000004; // R for other
+S_IWOTH :: 0000002; // W for other
+S_IXOTH :: 0000001; // X for other
+
+S_ISUID :: 0004000; // Set user id on execution
+S_ISGID :: 0002000; // Set group id on execution
+S_ISVTX :: 0001000; // Directory restrcted delete
+
+S_ISLNK  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFLNK;
+S_ISREG  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFREG;
+S_ISDIR  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFDIR;
+S_ISCHR  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFCHR;
+S_ISBLK  :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFBLK;
+S_ISFIFO :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFIFO;
+S_ISSOCK :: inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFSOCK;
+
+R_OK :: 4; // Test for read permission
+W_OK :: 2; // Test for write permission
+X_OK :: 1; // Test for execute permission
+F_OK :: 0; // Test for file existance
+
+foreign libc {
+	@(link_name="open")    _unix_open    :: proc(path: ^byte, mode: int) -> Handle ---;
+	@(link_name="close")   _unix_close   :: proc(handle: Handle) ---;
+	@(link_name="read")    _unix_read    :: proc(handle: Handle, buffer: rawptr, count: int) -> int ---;
+	@(link_name="write")   _unix_write   :: proc(handle: Handle, buffer: rawptr, count: int) -> int ---;
+	@(link_name="lseek")   _unix_lseek   :: proc(fs: Handle, offset: int, whence: int) -> int ---;
+	@(link_name="gettid")  _unix_gettid  :: proc() -> u64 ---;
+	@(link_name="stat")    _unix_stat    :: proc(path: ^byte, stat: ^Stat) -> int ---;
+	@(link_name="access")  _unix_access  :: proc(path: ^byte, mask: int) -> int ---;
+
+	@(link_name="malloc")  _unix_malloc  :: proc(size: int) -> rawptr ---;
+	@(link_name="calloc")  _unix_calloc  :: proc(num, size: int) -> rawptr ---;
+	@(link_name="free")    _unix_free    :: proc(ptr: rawptr) ---;
+	@(link_name="realloc") _unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr ---;
+	@(link_name="getenv")  _unix_getenv  :: proc(^byte) -> ^byte ---;
+
+	@(link_name="exit")    _unix_exit    :: proc(status: int) ---;
+}
+
+foreign dl {
+	@(link_name="dlopen")  _unix_dlopen  :: proc(filename: ^byte, flags: int) -> rawptr ---;
+	@(link_name="dlsym")   _unix_dlsym   :: proc(handle: rawptr, symbol: ^byte) -> rawptr ---;
+	@(link_name="dlclose") _unix_dlclose :: proc(handle: rawptr) -> int ---;
+	@(link_name="dlerror") _unix_dlerror :: proc() -> ^byte ---;
+}
+
+// TODO(zangent): Change this to just `open` when Bill fixes overloading.
+open_simple :: proc(path: string, mode: int) -> (Handle, Errno) {
+	cstr := strings.new_c_string(path);
+	defer free(cstr);
+	handle := _unix_open(cstr, mode);
+	if handle == -1 {
+		return 0, 1;
+	}
+	return handle, 0;
+}
+
+// NOTE(zangent): This is here for compatability reasons. Should this be here?
+open :: proc(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno) {
+	return open_simple(path, mode);
+}
+
+close :: proc(fd: Handle) {
+	_unix_close(fd);
+}
+
+write :: proc(fd: Handle, data: []u8) -> (int, Errno) {
+	assert(fd != -1);
+
+	bytes_written := _unix_write(fd, &data[0], len(data));
+	if(bytes_written == -1) {
+		return 0, 1;
+	}
+	return bytes_written, 0;
+}
+
+read :: proc(fd: Handle, data: []u8) -> (int, Errno) {
+	assert(fd != -1);
+
+	bytes_read := _unix_read(fd, &data[0], len(data));
+	if bytes_read == -1 {
+		return 0, 1;
+	}
+	return bytes_read, 0;
+}
+
+seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
+	assert(fd != -1);
+
+	final_offset := i64(_unix_lseek(fd, int(offset), whence));
+	if final_offset == -1 {
+		return 0, 1;
+	}
+	return final_offset, 0;
+}
+
+file_size :: proc(fd: Handle) -> (i64, Errno) {
+	prev, _   := seek(fd, 0, SEEK_CUR);
+	size, err := seek(fd, 0, SEEK_END);
+	seek(fd, prev, SEEK_SET);
+	return i64(size), err;
+}
+
+
+
+// NOTE(bill): Uses startup to initialize it
+stdin:  Handle = 0; // get_std_handle(win32.STD_INPUT_HANDLE);
+stdout: Handle = 1; // get_std_handle(win32.STD_OUTPUT_HANDLE);
+stderr: Handle = 2; // get_std_handle(win32.STD_ERROR_HANDLE);
+
+/* TODO(zangent): Implement these!
+last_write_time :: proc(fd: Handle) -> File_Time {}
+last_write_time_by_name :: proc(name: string) -> File_Time {}
+*/
+
+stat :: inline proc(path: string) -> (Stat, bool) {
+	s: Stat;
+	cstr := strings.new_c_string(path);
+	defer free(cstr);
+	ret_int := _unix_stat(cstr, &s);
+	return s, ret_int==0;
+}
+
+access :: inline proc(path: string, mask: int) -> bool {
+	cstr := strings.new_c_string(path);
+	defer free(cstr);
+	return _unix_access(cstr, mask) == 0;
+}
+
+heap_alloc :: inline proc(size: int) -> rawptr {
+	assert(size > 0);
+	return _unix_calloc(1, size);
+}
+heap_resize :: inline proc(ptr: rawptr, new_size: int) -> rawptr {
+	return _unix_realloc(ptr, new_size);
+}
+heap_free :: inline proc(ptr: rawptr) {
+	_unix_free(ptr);
+}
+
+getenv :: proc(name: string) -> (string, bool) {
+	path_str := strings.new_c_string(name);
+	defer free(path_str);
+	cstr := _unix_getenv(path_str);
+	if cstr == nil {
+		return "", false;
+	}
+	return strings.to_odin_string(cstr), true;
+}
+
+exit :: inline proc(code: int) {
+	_unix_exit(code);
+}
+
+
+current_thread_id :: proc() -> int {
+	// return int(_unix_gettid());
+	return 0;
+}
+
+dlopen :: inline proc(filename: string, flags: int) -> rawptr {
+	cstr := strings.new_c_string(filename);
+	defer free(cstr);
+	handle := _unix_dlopen(cstr, flags);
+	return handle;
+}
+dlsym :: inline proc(handle: rawptr, symbol: string) -> rawptr {
+	assert(handle != nil);
+	cstr := strings.new_c_string(symbol);
+	defer free(cstr);
+	proc_handle := _unix_dlsym(handle, cstr);
+	return proc_handle;
+}
+dlclose :: inline proc(handle: rawptr) -> bool {
+	assert(handle != nil);
+	return _unix_dlclose(handle) == 0;
+}
+dlerror :: proc() -> string {
+	return strings.to_odin_string(_unix_dlerror());
+}
+
+
+_alloc_command_line_arguments :: proc() -> []string {
+	args := make([]string, __argc__);
+	for i in 0..__argc__ {
+		args[i] = strings.to_odin_string((__argv__+i)^);
+	}
+	return args;
+}
@@ -0,0 +1,45 @@
+Any :: struct {
+	data:      rawptr,
+	type_info: ^Type_Info,
+}
+
+String :: struct {
+	data: ^byte,
+	len:  int,
+}
+
+Slice :: struct {
+	data: rawptr,
+	len:  int,
+}
+
+Dynamic_Array :: struct {
+	data:      rawptr,
+	len:       int,
+	cap:       int,
+	allocator: Allocator,
+}
+
+Map :: struct {
+	hashes:  [dynamic]int,
+	entries: Dynamic_Array,
+}
+
+
+make_any :: inline proc(data: rawptr, type_info: ^Type_Info) -> any {
+	return transmute(any)Any{data, type_info};
+}
+
+string_data :: inline proc(s: $T/string) -> ^byte {
+	return (^String)(&s).data;
+}
+slice_data :: inline proc(a: $T/[]$E) -> ^E {
+	return cast(^E)(^Slice)(&a).data;
+}
+dynamic_array_data :: inline proc(a: $T/[dynamic]$E) -> ^E {
+	return cast(^E)(^Dynamic_Array)(&a).data;
+}
+
+data :: proc[string_data, slice_data, dynamic_array_data];
+
+
@@ -0,0 +1,213 @@
+bubble_sort_proc :: proc(array: $A/[]$T, f: proc(T, T) -> int) {
+	assert(f != nil);
+	count := len(array);
+
+	init_j, last_j := 0, count-1;
+
+	for {
+		init_swap, prev_swap := -1, -1;
+
+		for j in init_j..last_j {
+			if f(array[j], array[j+1]) > 0 {
+				array[j], array[j+1] = array[j+1], array[j];
+				prev_swap = j;
+				if init_swap == -1 do init_swap = j;
+			}
+		}
+
+		if prev_swap == -1 do return;
+
+		init_j = max(init_swap-1, 0);
+		last_j = prev_swap;
+	}
+}
+
+bubble_sort :: proc(array: $A/[]$T) {
+	count := len(array);
+
+	init_j, last_j := 0, count-1;
+
+	for {
+		init_swap, prev_swap := -1, -1;
+
+		for j in init_j..last_j {
+			if array[j] > array[j+1] {
+				array[j], array[j+1] = array[j+1], array[j];
+				prev_swap = j;
+				if init_swap == -1 do init_swap = j;
+			}
+		}
+
+		if prev_swap == -1 do return;
+
+		init_j = max(init_swap-1, 0);
+		last_j = prev_swap;
+	}
+}
+
+quick_sort_proc :: proc(array: $A/[]$T, f: proc(T, T) -> int) {
+	assert(f != nil);
+	a := array;
+	n := len(a);
+	if n < 2 do return;
+
+	p := a[n/2];
+	i, j := 0, n-1;
+
+	loop: for {
+		for f(a[i], p) < 0 do i += 1;
+		for f(p, a[j]) < 0 do j -= 1;
+
+		if i >= j do break loop;
+
+		a[i], a[j] = a[j], a[i];
+		i += 1;
+		j -= 1;
+	}
+
+	quick_sort(a[0..i], f);
+	quick_sort(a[i..n], f);
+}
+
+quick_sort :: proc(array: $A/[]$T) {
+	a := array;
+	n := len(a);
+	if n < 2 do return;
+
+	p := a[n/2];
+	i, j := 0, n-1;
+
+	loop: for {
+		for a[i] < p do i += 1;
+		for p < a[j] do j -= 1;
+
+		if i >= j do break loop;
+
+		a[i], a[j] = a[j], a[i];
+		i += 1;
+		j -= 1;
+	}
+
+	quick_sort(a[0..i]);
+	quick_sort(a[i..n]);
+}
+
+_log2 :: proc(n: int) -> int {
+	res := 0;
+	for ; n != 0; n >>= 1 do res += 1;
+	return res;
+}
+
+merge_sort_proc :: proc(array: $A/[]$T, f: proc(T, T) -> int) {
+	merge_slices :: proc(arr1, arr2, out: A, f: proc(T, T) -> int) {
+		N1, N2 := len(arr1), len(arr2);
+		i, j := 0, 0;
+		for k in 0..N1+N2 {
+			if j == N2 || i < N1 && j < N2 && f(arr1[i], arr2[j]) < 0 {
+				out[k] = arr1[i];
+				i += 1;
+			} else {
+				out[k] = arr2[j];
+				j += 1;
+			}
+		}
+	}
+
+	assert(f != nil);
+
+	arr1 := array;
+	N := len(arr1);
+	arr2 := make([]T, N);
+	defer free(arr2);
+
+	a, b, m, M := N/2, N, 1, _log2(N);
+
+	for i in 0..M+1 {
+		for j in 0..a {
+			k := 2*j*m;
+			merge_slices(arr1[k..k+m], arr1[k+m..k+m+m], arr2[k..], f);
+		}
+		if N-b > m {
+			k := 2*a*m;
+			merge_slices(arr1[k..k+m], arr1[k+m..k+m+(N-b)&(m-1)], arr2[k..], f);
+		} else {
+			copy(arr2[b..N], arr1[b..N]);
+		}
+		arr1, arr2 = arr2, arr1;
+		m <<= 1;
+		a >>= 1;
+		b = a << uint(i) << 2;
+	}
+
+	if M & 1 == 0 do copy(arr2, arr1);
+}
+
+merge_sort :: proc(array: $A/[]$T) {
+	merge_slices :: proc(arr1, arr2, out: A) {
+		N1, N2 := len(arr1), len(arr2);
+		i, j := 0, 0;
+		for k in 0..N1+N2 {
+			if j == N2 || i < N1 && j < N2 && arr1[i] < arr2[j] {
+				out[k] = arr1[i];
+				i += 1;
+			} else {
+				out[k] = arr2[j];
+				j += 1;
+			}
+		}
+	}
+
+	arr1 := array;
+	N := len(arr1);
+	arr2 := make([]T, N);
+	defer free(arr2);
+
+	a, b, m, M := N/2, N, 1, _log2(N);
+
+	for i in 0..M+1 {
+		for j in 0..a {
+			k := 2*j*m;
+			merge_slices(arr1[k..k+m], arr1[k+m..k+m+m], arr2[k..]);
+		}
+		if N-b > m {
+			k := 2*a*m;
+			merge_slices(arr1[k..k+m], arr1[k+m..k+m+(N-b)&(m-1)], arr2[k..]);
+		} else {
+			copy(arr2[b..N], arr1[b..N]);
+		}
+		arr1, arr2 = arr2, arr1;
+		m <<= 1;
+		a >>= 1;
+		b = a << uint(i) << 2;
+	}
+
+	if M & 1 == 0 do copy(arr2, arr1);
+}
+
+
+
+compare_ints :: proc(a, b: int) -> int {
+	switch delta := a - b; {
+	case delta < 0: return -1;
+	case delta > 0: return +1;
+	}
+	return 0;
+}
+
+compare_f32s :: proc(a, b: f32) -> int {
+	switch delta := a - b; {
+	case delta < 0: return -1;
+	case delta > 0: return +1;
+	}
+	return 0;
+}
+compare_f64s :: proc(a, b: f64) -> int {
+	switch delta := a - b; {
+	case delta < 0: return -1;
+	case delta > 0: return +1;
+	}
+	return 0;
+}
+compare_strings :: proc(a, b: string) -> int {
+	return __string_cmp(a, b);
+}
@@ -0,0 +1,503 @@
+using import "core:decimal.odin"
+
+Int_Flag :: enum {
+	Prefix = 1<<0,
+	Plus   = 1<<1,
+	Space  = 1<<2,
+}
+
+
+parse_bool :: proc(s: string) -> (result: bool = false, ok: bool) {
+	switch s {
+	case "1", "t", "T", "true", "TRUE", "True":
+		return true, true;
+	case "0", "f", "F", "false", "FALSE", "False":
+		return false, true;
+	}
+	return;
+}
+
+_digit_value :: proc(r: rune) -> int {
+	ri := int(r);
+	v: int = 16;
+	switch r {
+	case '0'...'9': v = ri-'0';
+	case 'a'...'z': v = ri-'a'+10;
+	case 'A'...'Z': v = ri-'A'+10;
+	}
+	return v;
+}
+
+parse_i64 :: proc(s: string) -> i64 {
+	neg := false;
+	if len(s) > 1 {
+		switch s[0] {
+		case '-':
+			neg = true;
+			s = s[1..];
+		case '+':
+			s = s[1..];
+		}
+	}
+
+
+	base: i64 = 10;
+	if len(s) > 2 && s[0] == '0' {
+		switch s[1] {
+		case 'b': base =  2;  s = s[2..];
+		case 'o': base =  8;  s = s[2..];
+		case 'd': base = 10;  s = s[2..];
+		case 'z': base = 12;  s = s[2..];
+		case 'x': base = 16;  s = s[2..];
+		}
+	}
+
+
+	value: i64;
+	for r in s {
+		if r == '_' {
+			continue;
+		}
+
+		v := i64(_digit_value(r));
+		if v >= base {
+			break;
+		}
+		value *= base;
+		value += v;
+	}
+
+	if neg do return -value;
+	return value;
+}
+
+parse_u64 :: proc(s: string) -> u64 {
+	neg := false;
+	if len(s) > 1 && s[0] == '+' {
+		s = s[1..];
+	}
+
+
+	base := u64(10);
+	if len(s) > 2 && s[0] == '0' {
+		switch s[1] {
+		case 'b': base =  2;  s = s[2..];
+		case 'o': base =  8;  s = s[2..];
+		case 'd': base = 10;  s = s[2..];
+		case 'z': base = 12;  s = s[2..];
+		case 'x': base = 16;  s = s[2..];
+		}
+	}
+
+
+	value: u64;
+	for r in s {
+		if r == '_' do continue;
+		v := u64(_digit_value(r));
+		if v >= base do break;
+		value *= base;
+		value += u64(v);
+	}
+
+	if neg do return -value;
+	return value;
+}
+
+
+parse_int :: proc(s: string) -> int {
+	return int(parse_i64(s));
+}
+parse_uint :: proc(s: string, base: int) -> uint {
+	return uint(parse_u64(s));
+}
+
+parse_f32 :: proc(s: string) -> f32 {
+	return f32(parse_f64(s));
+}
+
+
+parse_f64 :: proc(s: string) -> f64 {
+	if s == "" {
+		return 0;
+	}
+	i := 0;
+
+	sign: f64 = 1;
+	switch s[i] {
+	case '-': i += 1; sign = -1;
+	case '+': i += 1;
+	}
+
+	value: f64 = 0;
+	for ; i < len(s); i += 1 {
+		r := rune(s[i]);
+		if r == '_' do continue;
+
+		v := _digit_value(r);
+		if v >= 10 do break;
+		value *= 10;
+		value += f64(v);
+	}
+
+	if i < len(s) && s[i] == '.' {
+		pow10: f64 = 10;
+		i += 1;
+
+		for ; i < len(s); i += 1 {
+			r := rune(s[i]);
+			if r == '_' do continue;
+
+			v := _digit_value(r);
+			if v >= 10 do break;
+			value += f64(v)/pow10;
+			pow10 *= 10;
+		}
+	}
+
+	frac := false;
+	scale: f64 = 1;
+
+	if i < len(s) && (s[i] == 'e' || s[i] == 'E') {
+		i += 1;
+
+		if i < len(s) {
+			switch s[i] {
+			case '-': i += 1; frac = true;
+			case '+': i += 1;
+			}
+
+			exp: u32 = 0;
+			for ; i < len(s); i += 1 {
+				r := rune(s[i]);
+				if r == '_' do continue;
+
+				d := u32(_digit_value(r));
+				if d >= 10 do break;
+				exp = exp * 10 + d;
+			}
+			if exp > 308 { exp = 308; }
+
+			for exp >= 50 { scale *= 1e50; exp -= 50; }
+			for exp >=  8 { scale *=  1e8; exp -=  8; }
+			for exp >   0 { scale *=   10; exp -=  1; }
+		}
+	}
+
+	if frac do return sign * (value/scale);
+	return sign * (value*scale);
+}
+
+
+append_bool :: proc(buf: []byte, b: bool) -> string {
+	n := 0;
+	if b do n = copy(buf, cast([]byte)"true");
+	else do n = copy(buf, cast([]byte)"false");
+	return string(buf[..n]);
+}
+
+append_uint :: proc(buf: []byte, u: u64, base: int) -> string {
+	return append_bits(buf, u64(u), base, false, 8*size_of(uint), digits, 0);
+}
+append_int :: proc(buf: []byte, i: i64, base: int) -> string {
+	return append_bits(buf, u64(i), base, true, 8*size_of(int), digits, 0);
+}
+itoa :: proc(buf: []byte, i: int) -> string do return append_int(buf, i64(i), 10);
+
+append_float :: proc(buf: []byte, f: f64, fmt: byte, prec, bit_size: int) -> string {
+	return string(generic_ftoa(buf, f, fmt, prec, bit_size));
+}
+
+
+
+
+DecimalSlice :: struct {
+	digits:        []byte,
+	count:         int,
+	decimal_point: int,
+	neg:           bool,
+}
+
+FloatInfo :: struct {
+	mantbits: uint,
+	expbits:  uint,
+	bias:     int,
+}
+
+
+_f16_info := FloatInfo{10, 5,   -15};
+_f32_info := FloatInfo{23, 8,  -127};
+_f64_info := FloatInfo{52, 11, -1023};
+
+
+generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> []byte {
+	bits: u64;
+	flt: ^FloatInfo;
+	switch bit_size {
+	case 32:
+		bits = u64(transmute(u32)f32(val));
+		flt = &_f32_info;
+	case 64:
+		bits = transmute(u64)val;
+		flt = &_f64_info;
+	case:
+		panic("strconv: invalid bit_size");
+	}
+
+	neg  := bits>>(flt.expbits+flt.mantbits) != 0;
+	exp  := int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
+	mant := bits & (u64(1) << flt.mantbits - 1);
+
+	switch exp {
+	case 1<<flt.expbits - 1:
+		s: string;
+		if mant != 0 {
+			s = "NaN";
+		} else if neg {
+			s = "-Inf";
+		} else {
+			s = "+Inf";
+		}
+		n := copy(buf, cast([]byte)s);
+		return buf[..n];
+
+	case 0: // denormalized
+		exp += 1;
+
+	case:
+		mant |= u64(1) << flt.mantbits;
+	}
+
+	exp += flt.bias;
+
+	d_: Decimal;
+	d := &d_;
+	assign(d, mant);
+	shift(d, exp - int(flt.mantbits));
+	digs: DecimalSlice;
+	shortest := prec < 0;
+	if shortest {
+		round_shortest(d, mant, exp, flt);
+		digs = DecimalSlice{digits = d.digits[..], count = d.count, decimal_point = d.decimal_point};
+		switch fmt {
+		case 'e', 'E': prec = digs.count-1;
+		case 'f', 'F': prec = max(digs.count-digs.decimal_point, 0);
+		case 'g', 'G': prec = digs.count;
+		}
+	} else {
+		switch fmt {
+		case 'e', 'E': round(d, prec+1);
+		case 'f', 'F': round(d, d.decimal_point+prec);
+		case 'g', 'G':
+			if prec == 0 {
+				prec = 1;
+			}
+			round(d, prec);
+		}
+
+		digs = DecimalSlice{digits = d.digits[..], count = d.count, decimal_point = d.decimal_point};
+	}
+	return format_digits(buf, shortest, neg, digs, prec, fmt);
+}
+
+
+
+format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: DecimalSlice, prec: int, fmt: byte) -> []byte {
+	Buffer :: struct {
+		b: []byte,
+		n: int,
+	}
+
+	to_bytes :: proc(b: Buffer) -> []byte do return b.b[..b.n];
+	add_bytes :: proc(buf: ^Buffer, bytes: ...byte) {
+		buf.n += copy(buf.b[buf.n..], bytes);
+	}
+
+	b := Buffer{b = buf};
+
+	switch fmt {
+	case 'f', 'F':
+		add_bytes(&b, neg ? '-' : '+');
+
+		// integer, padded with zeros when needed
+		if digs.decimal_point > 0 {
+			m := min(digs.count, digs.decimal_point);
+			add_bytes(&b, ...digs.digits[0..m]);
+			for ; m < digs.decimal_point; m += 1 {
+				add_bytes(&b, '0');
+			}
+		} else {
+			add_bytes(&b, '0');
+		}
+
+
+		// fractional part
+		if prec > 0 {
+			add_bytes(&b, '.');
+			for i in 0..prec {
+				c: byte = '0';
+				if j := digs.decimal_point + i; 0 <= j && j < digs.count {
+					c = digs.digits[j];
+				}
+				add_bytes(&b, c);
+			}
+		}
+		return to_bytes(b);
+
+	case 'e', 'E':
+		panic("strconv: e/E float printing is not yet supported");
+		return to_bytes(b); // TODO
+
+	case 'g', 'G':
+		panic("strconv: g/G float printing is not yet supported");
+		return to_bytes(b); // TODO
+
+	case:
+		add_bytes(&b, '%', fmt);
+		return to_bytes(b);
+	}
+
+
+}
+
+round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^FloatInfo) {
+	if mant == 0 { // If mantissa is zero, the number is zero
+		d.count = 0;
+		return;
+	}
+
+	/*
+		10^(dp-nd) > 2^(exp-mantbits)
+		log2(10) * (dp-nd) > exp-mantbits
+		log(2) >~ 0.332
+		332*(dp-nd) >= 100*(exp-mantbits)
+	 */
+	minexp := flt.bias+1;
+	if exp > minexp && 332*(d.decimal_point-d.count) >= 100*(exp - int(flt.mantbits)) {
+		// Number is already its shortest
+		return;
+	}
+
+	upper_: Decimal; upper := &upper_;
+	assign(upper, 2*mant - 1);
+	shift(upper, exp - int(flt.mantbits) - 1);
+
+	mantlo: u64;
+	explo:  int;
+	if mant > 1<<flt.mantbits || exp == minexp {
+		mantlo = mant-1;
+		explo = exp;
+	} else {
+		mantlo = 2*mant - 1;
+		explo = exp-1;
+	}
+	lower_: Decimal; lower := &lower_;
+	assign(lower, 2*mantlo + 1);
+	shift(lower, explo - int(flt.mantbits) - 1);
+
+	inclusive := mant%2 == 0;
+
+	for i in 0..d.count {
+		l: byte = '0'; // lower digit
+		if i < lower.count {
+			l = lower.digits[i];
+		}
+		m := d.digits[i];   // middle digit
+		u: byte = '0'; // upper digit
+		if i < upper.count {
+			u = upper.digits[i];
+		}
+
+		ok_round_down := l != m || inclusive && i+1 == lower.count;
+		ok_round_up   := m != u && (inclusive || m+1 < u || i+1 < upper.count);
+
+		if ok_round_down && ok_round_up {
+			round(d, i+1);
+			return;
+		}
+		if ok_round_down {
+			round_down(d, i+1);
+			return;
+		}
+		if ok_round_up {
+			round_up(d, i+1);
+			return;
+		}
+	}
+
+}
+
+MAX_BASE :: 32;
+digits := "0123456789abcdefghijklmnopqrstuvwxyz";
+
+
+is_integer_negative :: proc(u: u64, is_signed: bool, bit_size: int) -> (unsigned: u64, neg: bool) {
+	if is_signed {
+		switch bit_size {
+		case 8:
+			i := i8(u);
+			neg = i < 0;
+			u = u64(abs(i));
+		case 16:
+			i := i16(u);
+			neg = i < 0;
+			u = u64(abs(i));
+		case 32:
+			i := i32(u);
+			neg = i < 0;
+			u = u64(abs(i));
+		case 64:
+			i := i64(u);
+			neg = i < 0;
+			u = u64(abs(i));
+		case:
+			panic("is_integer_negative: Unknown integer size");
+		}
+	}
+	return u, neg;
+}
+
+append_bits :: proc(buf: []byte, u: u64, base: int, is_signed: bool, bit_size: int, digits: string, flags: Int_Flag) -> string {
+	if base < 2 || base > MAX_BASE {
+		panic("strconv: illegal base passed to append_bits");
+	}
+
+	neg: bool;
+	a: [129]byte;
+	i := len(a);
+	u, neg = is_integer_negative(u, is_signed, bit_size);
+	b := u64(base);
+	for u >= b {
+		i-=1; a[i] = digits[u % b];
+		u /= b;
+	}
+	i-=1; a[i] = digits[u % b];
+
+	if flags&Int_Flag.Prefix != 0 {
+		ok := true;
+		switch base {
+		case  2: i-=1; a[i] = 'b';
+		case  8: i-=1; a[i] = 'o';
+		case 10: i-=1; a[i] = 'd';
+		case 12: i-=1; a[i] = 'z';
+		case 16: i-=1; a[i] = 'x';
+		case: ok = false;
+		}
+		if ok {
+			i-=1; a[i] = '0';
+		}
+	}
+
+	switch {
+	case neg:
+		i-=1; a[i] = '-';
+	case flags&Int_Flag.Plus != 0:
+		i-=1; a[i] = '+';
+	case flags&Int_Flag.Space != 0:
+		i-=1; a[i] = ' ';
+	}
+
+	out := a[i..];
+	copy(buf, out);
+	return string(buf[0..len(out)]);
+}
+
@@ -0,0 +1,29 @@
+import "core:mem.odin"
+
+new_string :: proc(s: string) -> string {
+	c := make([]byte, len(s)+1);
+	copy(c, cast([]byte)s);
+	c[len(s)] = 0;
+	return string(c[..len(s)]);
+}
+
+new_c_string :: proc(s: string) -> ^byte {
+	c := make([]byte, len(s)+1);
+	copy(c, cast([]byte)s);
+	c[len(s)] = 0;
+	return &c[0];
+}
+
+to_odin_string :: proc(str: ^byte) -> string {
+	if str == nil do return "";
+	end := str;
+	for end^ != 0 do end+=1;
+	return string(mem.slice_ptr(str, end-str));
+}
+
+contains_rune :: proc(s: string, r: rune) -> int {
+	for c, offset in s {
+		if c == r do return offset;
+	}
+	return -1;
+}
@@ -1,91 +1,2 @@
-#import win32 "sys/windows.odin" when ODIN_OS == "windows";
-#import "atomic.odin";
-
-Semaphore :: struct {
-	handle: win32.HANDLE;
-}
-
-Mutex :: struct {
-	semaphore: Semaphore;
-	counter:   i32;
-	owner:     i32;
-	recursion: i32;
-}
-
-current_thread_id :: proc() -> i32 {
-	return win32.GetCurrentThreadId() as i32;
-}
-
-semaphore_init :: proc(s: ^Semaphore) {
-	s.handle = win32.CreateSemaphoreA(nil, 0, 1<<31-1, nil);
-}
-
-semaphore_destroy :: proc(s: ^Semaphore) {
-	win32.CloseHandle(s.handle);
-}
-
-semaphore_post :: proc(s: ^Semaphore, count: int) {
-	win32.ReleaseSemaphore(s.handle, count as i32, nil);
-}
-
-semaphore_release :: proc(s: ^Semaphore) #inline { semaphore_post(s, 1); }
-
-semaphore_wait :: proc(s: ^Semaphore) {
-	win32.WaitForSingleObject(s.handle, win32.INFINITE);
-}
-
-
-mutex_init :: proc(m: ^Mutex) {
-	atomic.store32(^m.counter, 0);
-	atomic.store32(^m.owner, current_thread_id());
-	semaphore_init(^m.semaphore);
-	m.recursion = 0;
-}
-mutex_destroy :: proc(m: ^Mutex) {
-	semaphore_destroy(^m.semaphore);
-}
-mutex_lock :: proc(m: ^Mutex) {
-	thread_id := current_thread_id();
-	if atomic.fetch_add32(^m.counter, 1) > 0 {
-		if thread_id != atomic.load32(^m.owner) {
-			semaphore_wait(^m.semaphore);
-		}
-	}
-	atomic.store32(^m.owner, thread_id);
-	m.recursion += 1;
-}
-mutex_try_lock :: proc(m: ^Mutex) -> bool {
-	thread_id := current_thread_id();
-	if atomic.load32(^m.owner) == thread_id {
-		atomic.fetch_add32(^m.counter, 1);
-	} else {
-		expected: i32 = 0;
-		if atomic.load32(^m.counter) != 0 {
-			return false;
-		}
-		if atomic.compare_exchange32(^m.counter, expected, 1) == 0 {
-			return false;
-		}
-		atomic.store32(^m.owner, thread_id);
-	}
-	m.recursion += 1;
-	return true;
-}
-mutex_unlock :: proc(m: ^Mutex) {
-	recursion: i32;
-	thread_id := current_thread_id();
-	assert(thread_id == atomic.load32(^m.owner));
-
-	m.recursion -= 1;
-	recursion = m.recursion;
-	if recursion == 0 {
-		atomic.store32(^m.owner, thread_id);
-	}
-
-	if atomic.fetch_add32(^m.counter, -1) > 1 {
-		if recursion == 0 {
-			semaphore_release(^m.semaphore);
-		}
-	}
-}
-
+when ODIN_OS == "windows" do export "core:sync_windows.odin";
+when ODIN_OS == "linux"   do export "core:sync_linux.odin";
@@ -0,0 +1,93 @@
+import "core:atomics.odin"
+import "core:os.odin"
+
+Semaphore :: struct {
+	// _handle: win32.Handle,
+}
+
+Mutex :: struct {
+	_semaphore: Semaphore,
+	_counter:   i32,
+	_owner:     i32,
+	_recursion: i32,
+}
+
+current_thread_id :: proc() -> i32 {
+	return i32(os.current_thread_id());
+}
+
+semaphore_init :: proc(s: ^Semaphore) {
+	// s._handle = win32.CreateSemaphoreA(nil, 0, 1<<31-1, nil);
+}
+
+semaphore_destroy :: proc(s: ^Semaphore) {
+	// win32.CloseHandle(s._handle);
+}
+
+semaphore_post :: proc(s: ^Semaphore, count: int) {
+	// win32.ReleaseSemaphore(s._handle, cast(i32)count, nil);
+}
+
+semaphore_release :: inline proc(s: ^Semaphore) {
+	semaphore_post(s, 1);
+}
+
+semaphore_wait :: proc(s: ^Semaphore) {
+	// win32.WaitForSingleObject(s._handle, win32.INFINITE);
+}
+
+
+mutex_init :: proc(m: ^Mutex) {
+	atomics.store(&m._counter, 0);
+	atomics.store(&m._owner, current_thread_id());
+	semaphore_init(&m._semaphore);
+	m._recursion = 0;
+}
+mutex_destroy :: proc(m: ^Mutex) {
+	semaphore_destroy(&m._semaphore);
+}
+mutex_lock :: proc(m: ^Mutex) {
+	thread_id := current_thread_id();
+	if atomics.fetch_add(&m._counter, 1) > 0 {
+		if thread_id != atomics.load(&m._owner) {
+			semaphore_wait(&m._semaphore);
+		}
+	}
+	atomics.store(&m._owner, thread_id);
+	m._recursion += 1;
+}
+mutex_try_lock :: proc(m: ^Mutex) -> bool {
+	thread_id := current_thread_id();
+	if atomics.load(&m._owner) == thread_id {
+		atomics.fetch_add(&m._counter, 1);
+	} else {
+		expected: i32 = 0;
+		if atomics.load(&m._counter) != 0 {
+			return false;
+		}
+		if atomics.compare_exchange(&m._counter, expected, 1) == 0 {
+			return false;
+		}
+		atomics.store(&m._owner, thread_id);
+	}
+	m._recursion += 1;
+	return true;
+}
+mutex_unlock :: proc(m: ^Mutex) {
+	recursion: i32;
+	thread_id := current_thread_id();
+	assert(thread_id == atomics.load(&m._owner));
+
+	m._recursion -= 1;
+	recursion = m._recursion;
+	if recursion == 0 {
+		atomics.store(&m._owner, thread_id);
+	}
+
+	if atomics.fetch_add(&m._counter, -1) > 1 {
+		if recursion == 0 {
+			semaphore_release(&m._semaphore);
+		}
+	}
+}
+
@@ -0,0 +1,124 @@
+when ODIN_OS == "windows" {
+	import win32 "core:sys/windows.odin";
+}
+import "core:atomics.odin"
+
+Semaphore :: struct {
+	_handle: win32.Handle,
+}
+
+/*
+Mutex :: struct {
+	_semaphore: Semaphore,
+	_counter:   i32,
+	_owner:     i32,
+	_recursion: i32,
+}
+*/
+
+Mutex :: struct {
+	_critical_section: win32.Critical_Section,
+}
+
+current_thread_id :: proc() -> i32 {
+	return i32(win32.get_current_thread_id());
+}
+
+semaphore_init :: proc(s: ^Semaphore) {
+	s._handle = win32.create_semaphore_a(nil, 0, 1<<31-1, nil);
+}
+
+semaphore_destroy :: proc(s: ^Semaphore) {
+	win32.close_handle(s._handle);
+}
+
+semaphore_post :: proc(s: ^Semaphore, count: int) {
+	win32.release_semaphore(s._handle, i32(count), nil);
+}
+
+semaphore_release :: inline proc(s: ^Semaphore) {
+	semaphore_post(s, 1);
+}
+
+semaphore_wait :: proc(s: ^Semaphore) {
+	win32.wait_for_single_object(s._handle, win32.INFINITE);
+}
+
+
+mutex_init :: proc(m: ^Mutex, spin_count := 0) {
+	win32.initialize_critical_section_and_spin_count(&m._critical_section, u32(spin_count));
+}
+
+mutex_destroy :: proc(m: ^Mutex) {
+	win32.delete_critical_section(&m._critical_section);
+}
+
+mutex_lock :: proc(m: ^Mutex) {
+	win32.enter_critical_section(&m._critical_section);
+}
+
+mutex_try_lock :: proc(m: ^Mutex) -> bool {
+	return bool(win32.try_enter_critical_section(&m._critical_section));
+}
+
+mutex_unlock :: proc(m: ^Mutex) {
+	win32.leave_critical_section(&m._critical_section);
+}
+
+
+
+/*
+mutex_init :: proc(m: ^Mutex) {
+	atomics.store(&m._counter, 0);
+	atomics.store(&m._owner, current_thread_id());
+	semaphore_init(&m._semaphore);
+	m._recursion = 0;
+}
+mutex_destroy :: proc(m: ^Mutex) {
+	semaphore_destroy(&m._semaphore);
+}
+mutex_lock :: proc(m: ^Mutex) {
+	thread_id := current_thread_id();
+	if atomics.fetch_add(&m._counter, 1) > 0 {
+		if thread_id != atomics.load(&m._owner) {
+			semaphore_wait(&m._semaphore);
+		}
+	}
+	atomics.store(&m._owner, thread_id);
+	m._recursion++;
+}
+mutex_try_lock :: proc(m: ^Mutex) -> bool {
+	thread_id := current_thread_id();
+	if atomics.load(&m._owner) == thread_id {
+		atomics.fetch_add(&m._counter, 1);
+	} else {
+		expected: i32 = 0;
+		if atomics.load(&m._counter) != 0 {
+			return false;
+		}
+		if atomics.compare_exchange(&m._counter, expected, 1) == 0 {
+			return false;
+		}
+		atomics.store(&m._owner, thread_id);
+	}
+	m._recursion++;
+	return true;
+}
+mutex_unlock :: proc(m: ^Mutex) {
+	recursion: i32;
+	thread_id := current_thread_id();
+	assert(thread_id == atomics.load(&m._owner));
+
+	m._recursion--;
+	recursion = m._recursion;
+	if recursion == 0 {
+		atomics.store(&m._owner, thread_id);
+	}
+
+	if atomics.fetch_add(&m._counter, -1) > 1 {
+		if recursion == 0 {
+			semaphore_release(&m._semaphore);
+		}
+	}
+}
+*/
@@ -0,0 +1,24 @@
+ENTRY(_start)
+
+SECTIONS
+{
+	. = 0x100000;
+	.text BLOCK(4K) : ALIGN(4K)
+	{
+		*(.text)
+	}
+	.rodata BLOCK(4K) : ALIGN(4K)
+	{
+		*(.rodata)
+	}
+	.data BLOCK(4K) : ALIGN(4K)
+	{
+		*(.data)
+	}
+
+	.bss BLOCK(4K) : ALIGN(4K)
+	{
+		*(COMMON)
+		*(.bss)
+	}
+}
@@ -0,0 +1,115 @@
+when ODIN_OS == "windows" {
+	foreign import "system:opengl32.lib"
+	using import "core:sys/windows.odin"
+}
+
+
+CONTEXT_MAJOR_VERSION_ARB             :: 0x2091;
+CONTEXT_MINOR_VERSION_ARB             :: 0x2092;
+CONTEXT_FLAGS_ARB                     :: 0x2094;
+CONTEXT_PROFILE_MASK_ARB              :: 0x9126;
+CONTEXT_FORWARD_COMPATIBLE_BIT_ARB    :: 0x0002;
+CONTEXT_CORE_PROFILE_BIT_ARB          :: 0x00000001;
+CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :: 0x00000002;
+
+Hglrc     :: distinct Handle;
+Color_Ref :: distinct u32;
+
+Layer_Plane_Descriptor :: struct {
+	size:             u16,
+	version:          u16,
+	flags:            u32,
+	pixel_type:       u8,
+	color_bits:       u8,
+	red_bits:         u8,
+	red_shift:        u8,
+	green_bits:       u8,
+	green_shift:      u8,
+	blue_bits:        u8,
+	blue_shift:       u8,
+	alpha_bits:       u8,
+	alpha_shift:      u8,
+	accum_bits:       u8,
+	accum_red_bits:   u8,
+	accum_green_bits: u8,
+	accum_blue_bits:  u8,
+	accum_alpha_bits: u8,
+	depth_bits:       u8,
+	stencil_bits:     u8,
+	aux_buffers:      u8,
+	layer_type:       u8,
+	reserved:         u8,
+	transparent:      Color_Ref,
+}
+
+Point_Float :: struct {x, y: f32};
+
+Glyph_Metrics_Float :: struct {
+	black_box_x:  f32,
+	black_box_y:  f32,
+	glyph_origin: Point_Float,
+	cell_inc_x:   f32,
+	cell_inc_y:   f32,
+}
+
+Create_Context_Attribs_ARB_Type :: #type proc "c" (hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc;
+Choose_Pixel_Format_ARB_Type    :: #type proc "c" (hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool;
+Swap_Interval_EXT_Type          :: #type proc "c" (interval: i32) -> bool;
+Get_Extensions_String_ARB_Type  :: #type proc "c" (Hdc) -> ^byte;
+
+// Procedures
+	create_context_attribs_arb: Create_Context_Attribs_ARB_Type;
+	choose_pixel_format_arb:    Choose_Pixel_Format_ARB_Type;
+	swap_interval_ext:          Swap_Interval_EXT_Type;
+	get_extensions_string_arb:  Get_Extensions_String_ARB_Type;
+
+
+foreign opengl32 {
+	@(link_name="wglCreateContext")
+	create_context :: proc(hdc: Hdc) -> Hglrc ---;
+
+	@(link_name="wglMakeCurrent")
+	make_current :: proc(hdc: Hdc, hglrc: Hglrc) -> Bool ---;
+
+	@(link_name="wglGetProcAddress")
+	get_gl_proc_address :: proc(c_str: ^byte) -> rawptr ---;
+
+	@(link_name="wglDeleteContext")
+	delete_context :: proc(hglrc: Hglrc) -> Bool ---;
+
+	@(link_name="wglCopyContext")
+	copy_context :: proc(src, dst: Hglrc, mask: u32) -> Bool ---;
+
+	@(link_name="wglCreateLayerContext")
+	create_layer_context :: proc(hdc: Hdc, layer_plane: i32) -> Hglrc ---;
+
+	@(link_name="wglDescribeLayerPlane")
+	describe_layer_plane :: proc(hdc: Hdc, pixel_format, layer_plane: i32, bytes: u32, pd: ^Layer_Plane_Descriptor) -> Bool ---;
+
+	@(link_name="wglGetCurrentContext")
+	get_current_context :: proc() -> Hglrc ---;
+
+	@(link_name="wglGetCurrentDC")
+	get_current_dc :: proc() -> Hdc ---;
+
+	@(link_name="wglGetLayerPaletteEntries")
+	get_layer_palette_entries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^Color_Ref) -> i32 ---;
+
+	@(link_name="wglRealizeLayerPalette")
+	realize_layer_palette :: proc(hdc: Hdc, layer_plane: i32, realize: Bool) -> Bool ---;
+
+	@(link_name="wglSetLayerPaletteEntries")
+	set_layer_palette_entries :: proc(hdc: Hdc, layer_plane, start, entries: i32, cr: ^Color_Ref) -> i32 ---;
+
+	@(link_name="wglShareLists")
+	share_lists :: proc(hglrc1, hglrc2: Hglrc) -> Bool ---;
+
+	@(link_name="wglSwapLayerBuffers")
+	swap_layer_buffers :: proc(hdc: Hdc, planes: u32) -> Bool ---;
+
+	@(link_name="wglUseFontBitmaps")
+	use_font_bitmaps :: proc(hdc: Hdc, first, count, list_base: u32) -> Bool ---;
+
+	@(link_name="wglUseFontOutlines")
+	use_font_outlines :: proc(hdc: Hdc, first, count, list_base: u32, deviation, extrusion: f32, format: i32, gmf: ^Glyph_Metrics_Float) -> Bool ---;
+}
@@ -0,0 +1,76 @@
+_ :: compile_assert(ODIN_OS == "windows");
+
+when ODIN_OS == "windows" {
+	import win32 "core:sys/windows.odin"
+}
+
+Thread_Proc :: #type proc(^Thread) -> int;
+
+Thread_Os_Specific :: struct {
+	win32_thread:    win32.Handle,
+	win32_thread_id: u32,
+}
+
+Thread :: struct {
+	using specific:   Thread_Os_Specific,
+	procedure:        Thread_Proc,
+	data:             rawptr,
+	user_index:       int,
+
+	init_context:     Context,
+	use_init_context: bool,
+}
+
+
+create :: proc(procedure: Thread_Proc) -> ^Thread {
+	win32_thread_id: u32;
+
+	__windows_thread_entry_proc :: proc "c" (t: ^Thread) -> i32 {
+		c := context;
+		if t.use_init_context {
+			c = t.init_context;
+		}
+
+		exit := 0;
+		context <- c {
+			exit = t.procedure(t);
+		}
+
+		return i32(exit);
+	}
+
+
+	win32_thread_proc := rawptr(__windows_thread_entry_proc);
+	thread := new(Thread);
+
+	win32_thread := win32.create_thread(nil, 0, win32_thread_proc, thread, win32.CREATE_SUSPENDED, &win32_thread_id);
+	if win32_thread == nil {
+		free(thread);
+		return nil;
+	}
+	thread.procedure       = procedure;
+	thread.win32_thread    = win32_thread;
+	thread.win32_thread_id = win32_thread_id;
+
+	return thread;
+}
+
+start :: proc(using thread: ^Thread) {
+	win32.resume_thread(win32_thread);
+}
+
+is_done :: proc(using thread: ^Thread) -> bool {
+	res := win32.wait_for_single_object(win32_thread, 0);
+	return res != win32.WAIT_TIMEOUT;
+}
+
+join :: proc(using thread: ^Thread) {
+	win32.wait_for_single_object(win32_thread, win32.INFINITE);
+	win32.close_handle(win32_thread);
+	win32_thread = win32.INVALID_HANDLE;
+}
+
+destroy :: proc(thread: ^Thread) {
+	join(thread);
+	free(thread);
+}
@@ -0,0 +1,252 @@
+are_types_identical :: proc(a, b: ^Type_Info) -> bool {
+	if a == b do return true;
+
+	if (a == nil && b != nil) ||
+	   (a != nil && b == nil) {
+		return false;
+	}
+
+
+	switch {
+	case a.size != b.size, a.align != b.align:
+		return false;
+	}
+
+	switch x in a.variant {
+	case Type_Info_Named:
+		y, ok := b.variant.(Type_Info_Named);
+		if !ok do return false;
+		return x.base == y.base;
+
+	case Type_Info_Integer:
+		y, ok := b.variant.(Type_Info_Integer);
+		if !ok do return false;
+		return x.signed == y.signed;
+
+	case Type_Info_Rune:
+		_, ok := b.variant.(Type_Info_Rune);
+		return ok;
+
+	case Type_Info_Float:
+		_, ok := b.variant.(Type_Info_Float);
+		return ok;
+
+	case Type_Info_Complex:
+		_, ok := b.variant.(Type_Info_Complex);
+		return ok;
+
+	case Type_Info_String:
+		_, ok := b.variant.(Type_Info_String);
+		return ok;
+
+	case Type_Info_Boolean:
+		_, ok := b.variant.(Type_Info_Boolean);
+		return ok;
+
+	case Type_Info_Any:
+		_, ok := b.variant.(Type_Info_Any);
+		return ok;
+
+	case Type_Info_Pointer:
+		y, ok := b.variant.(Type_Info_Pointer);
+		if !ok do return false;
+		return are_types_identical(x.elem, y.elem);
+
+	case Type_Info_Procedure:
+		y, ok := b.variant.(Type_Info_Procedure);
+		if !ok do return false;
+		switch {
+		case x.variadic   != y.variadic,
+		     x.convention != y.convention:
+			return false;
+		}
+
+		return are_types_identical(x.params, y.params) && are_types_identical(x.results, y.results);
+
+	case Type_Info_Array:
+		y, ok := b.variant.(Type_Info_Array);
+		if !ok do return false;
+		if x.count != y.count do return false;
+		return are_types_identical(x.elem, y.elem);
+
+	case Type_Info_Dynamic_Array:
+		y, ok := b.variant.(Type_Info_Dynamic_Array);
+		if !ok do return false;
+		return are_types_identical(x.elem, y.elem);
+
+	case Type_Info_Slice:
+		y, ok := b.variant.(Type_Info_Slice);
+		if !ok do return false;
+		return are_types_identical(x.elem, y.elem);
+
+	case Type_Info_Tuple:
+		y, ok := b.variant.(Type_Info_Tuple);
+		if !ok do return false;
+		if len(x.types) != len(y.types) do return false;
+		for _, i in x.types {
+			xt, yt := x.types[i], y.types[i];
+			if !are_types_identical(xt, yt) {
+				return false;
+			}
+		}
+		return true;
+
+	case Type_Info_Struct:
+		y, ok := b.variant.(Type_Info_Struct);
+		if !ok do return false;
+	   	switch {
+		case len(x.types)   != len(y.types),
+		     x.is_packed    != y.is_packed,
+		     x.is_raw_union != y.is_raw_union,
+		     x.custom_align != y.custom_align:
+		     return false;
+		}
+		for _, i in x.types {
+			xn, yn := x.names[i], y.names[i];
+			xt, yt := x.types[i], y.types[i];
+
+			if xn != yn do return false;
+			if !are_types_identical(xt, yt) do return false;
+		}
+		return true;
+
+	case Type_Info_Union:
+		y, ok := b.variant.(Type_Info_Union);
+		if !ok do return false;
+		if len(x.variants) != len(y.variants) do return false;
+
+		for _, i in x.variants {
+			xv, yv := x.variants[i], y.variants[i];
+			if !are_types_identical(xv, yv) do return false;
+		}
+		return true;
+
+	case Type_Info_Enum:
+		// NOTE(bill): Should be handled above
+		return false;
+
+	case Type_Info_Map:
+		y, ok := b.variant.(Type_Info_Map);
+		if !ok do return false;
+		return are_types_identical(x.key, y.key) && are_types_identical(x.value, y.value);
+
+	case Type_Info_Bit_Field:
+		y, ok := b.variant.(Type_Info_Bit_Field);
+		if !ok do return false;
+		if len(x.names) != len(y.names) do return false;
+
+		for _, i in x.names {
+			xb, yb := x.bits[i], y.bits[i];
+			xo, yo := x.offsets[i], y.offsets[i];
+			xn, yn := x.names[i], y.names[i];
+
+			if xb != yb do return false;
+			if xo != yo do return false;
+			if xn != yn do return false;
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+
+is_signed :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	switch i in type_info_base(info).variant {
+	case Type_Info_Integer: return i.signed;
+	case Type_Info_Float:   return true;
+	}
+	return false;
+}
+is_integer :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Integer);
+	return ok;
+}
+is_rune :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Rune);
+	return ok;
+}
+is_float :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Float);
+	return ok;
+}
+is_complex :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Complex);
+	return ok;
+}
+is_any :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Any);
+	return ok;
+}
+is_string :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_String);
+	return ok;
+}
+is_boolean :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Boolean);
+	return ok;
+}
+is_pointer :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Pointer);
+	return ok;
+}
+is_procedure :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Procedure);
+	return ok;
+}
+is_array :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Array);
+	return ok;
+}
+is_dynamic_array :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Dynamic_Array);
+	return ok;
+}
+is_dynamic_map :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Map);
+	return ok;
+}
+is_slice :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Slice);
+	return ok;
+}
+is_tuple :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Tuple);
+	return ok;
+}
+is_struct :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	s, ok := type_info_base(info).variant.(Type_Info_Struct);
+	return ok && !s.is_raw_union;
+}
+is_raw_union :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	s, ok := type_info_base(info).variant.(Type_Info_Struct);
+	return ok && s.is_raw_union;
+}
+is_union :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Union);
+	return ok;
+}
+is_enum :: proc(info: ^Type_Info) -> bool {
+	if info == nil do return false;
+	_, ok := type_info_base(info).variant.(Type_Info_Enum);
+	return ok;
+}
@@ -0,0 +1,81 @@
+import "utf8.odin"
+
+REPLACEMENT_CHAR :: '\uFFFD';
+MAX_RUNE         :: '\U0010FFFF';
+
+_surr1           :: 0xd800;
+_surr2           :: 0xdc00;
+_surr3           :: 0xe000;
+_surr_self       :: 0x10000;
+
+
+is_surrogate :: proc(r: rune) -> bool {
+	return _surr1 <= r && r < _surr3;
+}
+
+decode_surrogate_pair :: proc(r1, r2: rune) -> rune {
+	if _surr1 <= r1 && r1 < _surr2 && _surr2 <= r2 && r2 < _surr3 {
+		return (r1-_surr1)<<10 | (r2 - _surr2) + _surr_self;
+	}
+	return REPLACEMENT_CHAR;
+}
+
+
+encode_surrogate_pair :: proc(r: rune) -> (r1, r2: rune) {
+	if r < _surr_self || r > MAX_RUNE {
+		return REPLACEMENT_CHAR, REPLACEMENT_CHAR;
+	}
+	r -= _surr_self;
+	return _surr1 + (r>>10)&0x3ff, _surr2 + r&0x3ff;
+}
+
+encode :: proc(d: []u16, s: []rune) -> int {
+	n, m := 0, len(d);
+	loop: for r in s {
+		switch r {
+		case 0.._surr1, _surr3 .. _surr_self:
+			if m+1 < n do break loop;
+			d[n] = u16(r);
+			n += 1;
+
+		case _surr_self .. MAX_RUNE:
+			if m+2 < n do break loop;
+			r1, r2 := encode_surrogate_pair(r);
+			d[n]    = u16(r1);
+			d[n+1]  = u16(r2);
+			n += 2;
+
+		case:
+			if m+1 < n do break loop;
+			d[n] = u16(REPLACEMENT_CHAR);
+			n += 1;
+		}
+	}
+	return n;
+}
+
+
+encode_string :: proc(d: []u16, s: string) -> int {
+	n, m := 0, len(d);
+	loop: for r in s {
+		switch r {
+		case 0.._surr1, _surr3 .. _surr_self:
+			if m+1 < n do break loop;
+			d[n] = u16(r);
+			n += 1;
+
+		case _surr_self .. MAX_RUNE:
+			if m+2 < n do break loop;
+			r1, r2 := encode_surrogate_pair(r);
+			d[n]    = u16(r1);
+			d[n+1]  = u16(r2);
+			n += 2;
+
+		case:
+			if m+1 < n do break loop;
+			d[n] = u16(REPLACEMENT_CHAR);
+			n += 1;
+		}
+	}
+	return n;
+}
@@ -1,16 +1,34 @@
 RUNE_ERROR :: '\ufffd';
 RUNE_SELF  :: 0x80;
 RUNE_BOM   :: 0xfeff;
-RUNE_EOF   :: ~(0 as rune);
+RUNE_EOF   :: ~rune(0);
 MAX_RUNE   :: '\U0010ffff';
 UTF_MAX    :: 4;

 SURROGATE_MIN :: 0xd800;
 SURROGATE_MAX :: 0xdfff;

-Accept_Range :: struct {
-	lo, hi: u8;
-}
+T1 :: 0b0000_0000;
+TX :: 0b1000_0000;
+T2 :: 0b1100_0000;
+T3 :: 0b1110_0000;
+T4 :: 0b1111_0000;
+T5 :: 0b1111_1000;
+
+MASKX :: 0b0011_1111;
+MASK2 :: 0b0001_1111;
+MASK3 :: 0b0000_1111;
+MASK4 :: 0b0000_0111;
+
+RUNE1_MAX :: 1<<7 - 1;
+RUNE2_MAX :: 1<<11 - 1;
+RUNE3_MAX :: 1<<16 - 1;
+
+	// The default lowest and highest continuation byte.
+LOCB :: 0b1000_0000;
+HICB :: 0b1011_1111;
+
+Accept_Range :: struct {lo, hi: u8};

 accept_ranges := [5]Accept_Range{
 	{0x80, 0xbf},
@@ -20,7 +38,7 @@ accept_ranges := [5]Accept_Range{
 	{0x80, 0x8f},
 };

-accept_sizes := [256]byte{
+accept_sizes := [256]u8{
 	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f
 	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f
 	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f
@@ -40,17 +58,17 @@ accept_sizes := [256]byte{
 	0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff
 };

-encode_rune :: proc(r: rune) -> ([4]byte, int) {
-	buf: [4]byte;
-	i := r as u32;
-	mask: byte : 0x3f;
+encode_rune :: proc(r: rune) -> ([4]u8, int) {
+	buf: [4]u8;
+	i := u32(r);
+	mask :: u8(0x3f);
 	if i <= 1<<7-1 {
-		buf[0] = r as byte;
+		buf[0] = u8(r);
 		return buf, 1;
 	}
 	if i <= 1<<11-1 {
-		buf[0] = 0xc0 | (r>>6) as byte;
-		buf[1] = 0x80 | (r)    as byte & mask;
+		buf[0] = 0xc0 | u8(r>>6);
+		buf[1] = 0x80 | u8(r) & mask;
 		return buf, 2;
 	}

@@ -61,64 +79,94 @@ encode_rune :: proc(r: rune) -> ([4]byte, int) {
 	}

 	if i <= 1<<16-1 {
-		buf[0] = 0xe0 | (r>>12) as byte;
-		buf[1] = 0x80 | (r>>6)  as byte & mask;
-		buf[2] = 0x80 | (r)     as byte & mask;
+		buf[0] = 0xe0 | u8(r>>12);
+		buf[1] = 0x80 | u8(r>>6) & mask;
+		buf[2] = 0x80 | u8(r)    & mask;
 		return buf, 3;
 	}

-	buf[0] = 0xf0 | (r>>18) as byte;
-	buf[1] = 0x80 | (r>>12) as byte & mask;
-	buf[2] = 0x80 | (r>>6)  as byte & mask;
-	buf[3] = 0x80 | (r)     as byte & mask;
+	buf[0] = 0xf0 | u8(r>>18);
+	buf[1] = 0x80 | u8(r>>12) & mask;
+	buf[2] = 0x80 | u8(r>>6)  & mask;
+	buf[3] = 0x80 | u8(r)       & mask;
 	return buf, 4;
 }

-decode_rune :: proc(s: string) -> (rune, int) {
-	n := s.count;
+decode_rune_from_string :: inline proc(s: string) -> (rune, int) do return decode_rune(cast([]u8)s);
+decode_rune :: proc(s: []u8) -> (rune, int) {
+	n := len(s);
 	if n < 1 {
 		return RUNE_ERROR, 0;
 	}
-	b0 := s[0];
-	x := accept_sizes[b0];
-	if x >= 0xf0 {
-		mask := (x as rune << 31) >> 31; // all zeros or all ones
-		return (b0 as rune) &~ mask | RUNE_ERROR&mask, 1;
+	s0 := s[0];
+	x := accept_sizes[s0];
+	if x >= 0xF0 {
+		mask := rune(x) << 31 >> 31; // NOTE(bill): Create 0x0000 or 0xffff.
+		return rune(s[0])&~mask | RUNE_ERROR&mask, 1;
 	}
-	size := x & 7;
-	ar := accept_ranges[x>>4];
-	if n < size as int {
+	sz := x & 7;
+	accept := accept_ranges[x>>4];
+	if n < int(sz) {
 		return RUNE_ERROR, 1;
 	}
 	b1 := s[1];
-	if b1 < ar.lo || ar.hi < b1 {
+	if b1 < accept.lo || accept.hi < b1 {
 		return RUNE_ERROR, 1;
 	}
-
-	MASK_X :: 0b00111111;
-	MASK_2 :: 0b00011111;
-	MASK_3 :: 0b00001111;
-	MASK_4 :: 0b00000111;
-
-	if size == 2 {
-		return (b0&MASK_2) as rune <<6 | (b1&MASK_X) as rune, 2;
+	if sz == 2 {
+		return rune(s0&MASK2)<<6 | rune(b1&MASKX), 2;
 	}
 	b2 := s[2];
-	if b2 < 0x80 || 0xbf < b2 {
+	if b2 < LOCB || HICB < b2 {
 		return RUNE_ERROR, 1;
 	}
-	if size == 3 {
-		return (b0&MASK_3) as rune <<12 | (b1&MASK_X) as rune <<6 | (b2&MASK_X) as rune, 3;
+	if sz == 3 {
+		return rune(s0&MASK3)<<12 | rune(b1&MASKX)<<6 | rune(b2&MASKX), 3;
 	}
 	b3 := s[3];
-	if b3 < 0x80 || 0xbf < b3 {
+	if b3 < LOCB || HICB < b3 {
 		return RUNE_ERROR, 1;
 	}
-	return (b0&MASK_4) as rune <<18 | (b1&MASK_X) as rune <<12 | (b3&MASK_X) as rune <<6 | (b3&MASK_X) as rune, 4;
-
+	return rune(s0&MASK4)<<18 | rune(b1&MASKX)<<12 | rune(b2&MASKX)<<6 | rune(b3&MASKX), 4;
 }


+
+decode_last_rune_from_string :: inline proc(s: string) -> (rune, int) do return decode_last_rune(cast([]u8)s);
+decode_last_rune :: proc(s: []u8) -> (rune, int) {
+	r: rune;
+	size: int;
+	start, end, limit: int;
+
+	end = len(s);
+	if end == 0 {
+		return RUNE_ERROR, 0;
+	}
+	start = end-1;
+	r = rune(s[start]);
+	if r < RUNE_SELF {
+		return r, 1;
+	}
+
+
+	limit = max(end - UTF_MAX, 0);
+
+	for start-=1; start >= limit; start-=1 {
+		if rune_start(s[start]) do break;
+	}
+
+	start = max(start, 0);
+	r, size = decode_rune(s[start..end]);
+	if start+size != end {
+		return RUNE_ERROR, 1;
+	}
+	return r, size;
+}
+
+
+
+
+
 valid_rune :: proc(r: rune) -> bool {
 	if r < 0 {
 		return false;
@@ -131,9 +179,8 @@ valid_rune :: proc(r: rune) -> bool {
 }

 valid_string :: proc(s: string) -> bool {
-	n := s.count;
-	i := 0;
-	while i < n {
+	n := len(s);
+	for i := 0; i < n; {
 		si := s[i];
 		if si < RUNE_SELF { // ascii
 			i += 1;
@@ -143,7 +190,7 @@ valid_string :: proc(s: string) -> bool {
 		if x == 0xf1 {
 			return false;
 		}
-		size := (x & 7) as int;
+		size := int(x & 7);
 		if i+size > n {
 			return false;
 		}
@@ -164,11 +211,14 @@ valid_string :: proc(s: string) -> bool {
 	return true;
 }

-rune_count :: proc(s: string) -> int {
+rune_start :: inline proc(b: u8) -> bool do return b&0xc0 != 0x80;
+
+rune_count_from_string :: inline proc(s: string) -> int do return rune_count(cast([]u8)s);
+rune_count :: proc(s: []u8) -> int {
 	count := 0;
-	n := s.count;
-	i := 0;
-	while i < n {
+	n := len(s);
+
+	for i := 0; i < n; {
 		defer count += 1;
 		si := s[i];
 		if si < RUNE_SELF { // ascii
@@ -180,7 +230,7 @@ rune_count :: proc(s: string) -> int {
 			i += 1;
 			continue;
 		}
-		size := (x & 7) as int;
+		size := int(x & 7);
 		if i+size > n {
 			i += 1;
 			continue;
@@ -204,7 +254,7 @@ rune_count :: proc(s: string) -> int {


 rune_size :: proc(r: rune) -> int {
-	match {
+	switch {
 	case r < 0:          return -1;
 	case r <= 1<<7  - 1: return 1;
 	case r <= 1<<11 - 1: return 2;
@@ -0,0 +1,745 @@
+import "core:fmt.odin"
+import "core:strconv.odin"
+import "core:mem.odin"
+import "core:bits.odin"
+import "core:hash.odin"
+import "core:math.odin"
+import "core:math/rand.odin"
+import "core:os.odin"
+import "core:raw.odin"
+import "core:sort.odin"
+import "core:strings.odin"
+import "core:types.odin"
+import "core:utf16.odin"
+import "core:utf8.odin"
+
+// File scope `when` statements
+when ODIN_OS == "windows" {
+	import "core:atomics.odin"
+	import "core:thread.odin"
+	import win32 "core:sys/windows.odin"
+}
+
+@(link_name="general_stuff")
+general_stuff :: proc() {
+	fmt.println("# general_stuff");
+	{ // `do` for inline statments rather than block
+		foo :: proc() do fmt.println("Foo!");
+		if   false do foo();
+		for  false do foo();
+		when false do foo();
+
+		if false do foo();
+		else     do foo();
+	}
+
+	{ // Removal of `++` and `--` (again)
+		x: int;
+		x += 1;
+		x -= 1;
+	}
+	{ // Casting syntaxes
+		i := i32(137);
+		ptr := &i;
+
+		_ = (^f32)(ptr);
+		// ^f32(ptr) == ^(f32(ptr))
+		_ = cast(^f32)ptr;
+
+		_ = (^f32)(ptr)^;
+		_ = (cast(^f32)ptr)^;
+
+		// Questions: Should there be two ways to do it?
+	}
+
+	/*
+	 * Remove *_val_of built-in procedures
+	 * size_of, align_of, offset_of
+	 * type_of, type_info_of
+	 */
+
+	{ // `expand_to_tuple` built-in procedure
+		Foo :: struct {
+			x: int,
+			b: bool,
+		}
+		f := Foo{137, true};
+		x, b := expand_to_tuple(f);
+		fmt.println(f);
+		fmt.println(x, b);
+		fmt.println(expand_to_tuple(f));
+	}
+
+	{
+		// ..  half-closed range
+		// ... open range
+
+		for in 0..2  {} // 0, 1
+		for in 0...2 {} // 0, 1, 2
+	}
+
+	{ // Multiple sized booleans
+
+		x0: bool; // default
+		x1: b8  = true;
+		x2: b16 = false;
+		x3: b32 = true;
+		x4: b64 = false;
+
+		fmt.printf("x1: %T = %v;\n", x1, x1);
+		fmt.printf("x2: %T = %v;\n", x2, x2);
+		fmt.printf("x3: %T = %v;\n", x3, x3);
+		fmt.printf("x4: %T = %v;\n", x4, x4);
+
+		// Having specific sized booleans is very useful when dealing with foreign code
+		// and to enforce specific alignment for a boolean, especially within a struct
+	}
+
+	{ // `distinct` types
+		// Originally, all type declarations would create a distinct type unless #type_alias was present.
+		// Now the behaviour has been reversed. All type declarations create a type alias unless `distinct` is present.
+		// If the type expression is `struct`, `union`, `enum`, `proc`, or `bit_field`, the types will always been distinct.
+
+		Int32 :: i32;
+		compile_assert(Int32 == i32);
+
+		My_Int32 :: distinct i32;
+		compile_assert(My_Int32 != i32);
+
+		My_Struct :: struct{x: int};
+		compile_assert(My_Struct != struct{x: int});
+	}
+}
+
+default_struct_values :: proc() {
+	fmt.println("# default_struct_values");
+	{
+		Vector3 :: struct {
+			x: f32,
+			y: f32,
+			z: f32,
+		}
+		v: Vector3;
+		fmt.println(v);
+	}
+	{
+		// Default values must be constants
+		Vector3 :: struct {
+			x: f32 = 1,
+			y: f32 = 4,
+			z: f32 = 9,
+		}
+		v: Vector3;
+		fmt.println(v);
+
+		v = Vector3{};
+		fmt.println(v);
+
+		// Uses the same semantics as a default values in a procedure
+		v = Vector3{137};
+		fmt.println(v);
+
+		v = Vector3{z = 137};
+		fmt.println(v);
+	}
+
+	{
+		Vector3 :: struct {
+			x := 1.0,
+			y := 4.0,
+			z := 9.0,
+		}
+		stack_default: Vector3;
+		stack_literal := Vector3{};
+		heap_one      := new(Vector3);         defer free(heap_one);
+		heap_two      := new_clone(Vector3{}); defer free(heap_two);
+
+		fmt.println("stack_default  - ", stack_default);
+		fmt.println("stack_literal  - ", stack_literal);
+		fmt.println("heap_one       - ", heap_one^);
+		fmt.println("heap_two       - ", heap_two^);
+
+
+		N :: 4;
+		stack_array: [N]Vector3;
+		heap_array := new([N]Vector3);    defer free(heap_array);
+		heap_slice := make([]Vector3, N); defer free(heap_slice);
+		fmt.println("stack_array[1] - ", stack_array[1]);
+		fmt.println("heap_array[1]  - ", heap_array[1]);
+		fmt.println("heap_slice[1]  - ", heap_slice[1]);
+	}
+}
+
+
+
+
+union_type :: proc() {
+	fmt.println("\n# union_type");
+	{
+		val: union{int, bool};
+		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");
+		}
+	}
+	{
+		// There is a duality between `any` and `union`
+		// An `any` has a pointer to the data and allows for any type (open)
+		// A `union` has as binary blob to store the data and allows only certain types (closed)
+		// The following code is with `any` but has the same syntax
+		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");
+		}
+	}
+
+	Vector3 :: struct {x, y, z: f32};
+	Quaternion :: struct {x, y, z: f32, w: f32 = 1};
+
+	// More realistic examples
+	{
+		// NOTE(bill): For the above basic examples, you may not have any
+		// particular use for it. However, my main use for them is not for these
+		// simple cases. My main use is for hierarchical types. Many prefer
+		// subtyping, embedding the base data into the derived types. Below is
+		// an example of this for a basic game Entity.
+
+		Entity :: struct {
+			id:          u64,
+			name:        string,
+			position:    Vector3,
+			orientation: Quaternion,
+
+			derived: any,
+		}
+
+		Frog :: struct {
+			using entity: Entity,
+			jump_height:  f32,
+		}
+
+		Monster :: struct {
+			using entity: Entity,
+			is_robot:     bool,
+			is_zombie:    bool,
+		}
+
+		// See `parametric_polymorphism` procedure for details
+		new_entity :: proc(T: type) -> ^Entity {
+			t := new(T);
+			t.derived = t^;
+			return t;
+		}
+
+		entity := new_entity(Monster);
+
+		switch e in entity.derived {
+		case Frog:
+			fmt.println("Ribbit");
+		case Monster:
+			if e.is_robot  do fmt.println("Robotic");
+			if e.is_zombie do fmt.println("Grrrr!");
+		}
+	}
+
+	{
+		// NOTE(bill): A union can be used to achieve something similar. Instead
+		// of embedding the base data into the derived types, the derived data
+		// in embedded into the base type. Below is the same example of the
+		// basic game Entity but using an union.
+
+		Entity :: struct {
+			id:          u64,
+			name:        string,
+			position:    Vector3,
+			orientation: Quaternion,
+
+			derived: union {Frog, Monster},
+		}
+
+		Frog :: struct {
+			using entity: ^Entity,
+			jump_height:  f32,
+		}
+
+		Monster :: struct {
+			using entity: ^Entity,
+			is_robot:     bool,
+			is_zombie:    bool,
+		}
+
+		// See `parametric_polymorphism` procedure for details
+		new_entity :: proc(T: type) -> ^Entity {
+			t := new(Entity);
+			t.derived = T{entity = t};
+			return t;
+		}
+
+		entity := new_entity(Monster);
+
+		switch e in entity.derived {
+		case Frog:
+			fmt.println("Ribbit");
+		case Monster:
+			if e.is_robot  do fmt.println("Robotic");
+			if e.is_zombie do fmt.println("Grrrr!");
+		}
+
+		// NOTE(bill): As you can see, the usage code has not changed, only its
+		// memory layout. Both approaches have their own advantages but they can
+		// be used together to achieve different results. The subtyping approach
+		// can allow for a greater control of the memory layout and memory
+		// allocation, e.g. storing the derivatives together. However, this is
+		// also its disadvantage. You must either preallocate arrays for each
+		// derivative separation (which can be easily missed) or preallocate a
+		// bunch of "raw" memory; determining the maximum size of the derived
+		// types would require the aid of metaprogramming. Unions solve this
+		// particular problem as the data is stored with the base data.
+		// Therefore, it is possible to preallocate, e.g. [100]Entity.
+
+		// It should be noted that the union approach can have the same memory
+		// layout as the any and with the same type restrictions by using a
+		// pointer type for the derivatives.
+
+		/*
+			Entity :: struct {
+				...
+				derived: union{^Frog, ^Monster},
+			}
+
+			Frog :: struct {
+				using entity: Entity,
+				...
+			}
+			Monster :: struct {
+				using entity: Entity,
+				...
+
+			}
+			new_entity :: proc(T: type) -> ^Entity {
+				t := new(T);
+				t.derived = t;
+				return t;
+			}
+		*/
+	}
+}
+
+parametric_polymorphism :: proc() {
+	fmt.println("# parametric_polymorphism");
+
+	print_value :: proc(value: $T) {
+		fmt.printf("print_value: %T %v\n", value, value);
+	}
+
+	v1: int    = 1;
+	v2: f32    = 2.1;
+	v3: f64    = 3.14;
+	v4: string = "message";
+
+	print_value(v1);
+	print_value(v2);
+	print_value(v3);
+	print_value(v4);
+
+	fmt.println();
+
+	add :: proc(p, q: $T) -> T {
+		x: T = p + q;
+		return x;
+	}
+
+	a := add(3, 4);
+	fmt.printf("a: %T = %v\n", a, a);
+
+	b := add(3.2, 4.3);
+	fmt.printf("b: %T = %v\n", b, b);
+
+	// This is how `new` is implemented
+	alloc_type :: proc(T: type) -> ^T {
+		t := cast(^T)alloc(size_of(T), align_of(T));
+		t^ = T{}; // Use default initialization value
+		return t;
+	}
+
+	copy_slice :: proc(dst, src: []$T) -> int {
+		return mem.copy(&dst[0], &src[0], n*size_of(T));
+	}
+
+	double_params :: proc(a: $A, b: $B) -> A {
+		return a + A(b);
+	}
+
+	fmt.println(double_params(12, 1.345));
+
+
+
+	{ // Polymorphic Types and Type Specialization
+		Table_Slot :: struct(Key, Value: type) {
+			occupied: bool,
+			hash:     u32,
+			key:      Key,
+			value:    Value,
+		}
+		TABLE_SIZE_MIN :: 32;
+		Table :: struct(Key, Value: type) {
+			count:     int,
+			allocator: Allocator,
+			slots:     []Table_Slot(Key, Value),
+		}
+
+		// Only allow types that are specializations of a (polymorphic) slice
+		make_slice :: proc(T: type/[]$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 do 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 do c.allocator = table.allocator;
+
+			context <- c {
+				old_slots := table.slots;
+
+				cap := max(2*len(table.slots), TABLE_SIZE_MIN);
+				allocate(table, cap);
+
+				for s in old_slots do if s.occupied {
+					put(table, s.key, s.value);
+				}
+
+				free(old_slots);
+			}
+		}
+
+		// 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));
+
+				hash := get_hash(key);
+				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 do 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 do put(&table, "Hellope", i);
+		for i in 0..42 do 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
+	}
+}
+
+
+
+
+prefix_table := [...]string{
+	"White",
+	"Red",
+	"Green",
+	"Blue",
+	"Octarine",
+	"Black",
+};
+
+threading_example :: proc() {
+	when ODIN_OS == "windows" {
+		fmt.println("# threading_example");
+
+		unordered_remove :: proc(array: ^[dynamic]$T, index: int, loc := #caller_location) {
+			__bounds_check_error_loc(loc, index, len(array));
+			array[index] = array[len(array)-1];
+			pop(array);
+		}
+		ordered_remove :: proc(array: ^[dynamic]$T, index: int, loc := #caller_location) {
+			__bounds_check_error_loc(loc, index, len(array));
+			copy(array[index..], array[index+1..]);
+			pop(array);
+		}
+
+		worker_proc :: proc(t: ^thread.Thread) -> int {
+			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);
+				// win32.sleep(1);
+			}
+			return 0;
+		}
+
+		threads := make([dynamic]^thread.Thread, 0, len(prefix_table));
+		defer free(threads);
+
+		for in prefix_table {
+			if t := thread.create(worker_proc); t != nil {
+				t.init_context = context;
+				t.use_init_context = true;
+				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;
+				}
+			}
+		}
+	}
+}
+
+array_programming :: proc() {
+	fmt.println("# array_programming");
+	{
+		a := [3]f32{1, 2, 3};
+		b := [3]f32{5, 6, 7};
+		c := a * b;
+		d := a + b;
+		e := 1 +  (c - d) / 2;
+		fmt.printf("%.1f\n", e); // [0.5, 3.0, 6.5]
+	}
+
+	{
+		a := [3]f32{1, 2, 3};
+		b := swizzle(a, 2, 1, 0);
+		assert(b == [3]f32{3, 2, 1});
+
+		c := swizzle(a, 0, 0);
+		assert(c == [2]f32{1, 1});
+		assert(c == 1);
+	}
+
+	{
+		Vector3 :: distinct [3]f32;
+		a := Vector3{1, 2, 3};
+		b := Vector3{5, 6, 7};
+		c := (a * b)/2 + 1;
+		d := c.x + c.y + c.z;
+		fmt.printf("%.1f\n", d); // 22.0
+
+		cross :: proc(a, b: Vector3) -> Vector3 {
+			i := swizzle(a, 1, 2, 0) * swizzle(b, 2, 0, 1);
+			j := swizzle(a, 2, 0, 1) * swizzle(b, 1, 2, 0);
+			return i - j;
+		}
+
+		blah :: proc(a: Vector3) -> f32 {
+			return a.x + a.y + a.z;
+		}
+
+		x := cross(a, b);
+		fmt.println(x);
+		fmt.println(blah(x));
+	}
+}
+
+
+using println in import "core:fmt.odin"
+
+using_in :: proc() {
+	fmt.println("# using in");
+	using print in fmt;
+
+	println("Hellope1");
+	print("Hellope2\n");
+
+	Foo :: struct {
+		x, y: int,
+		b: bool,
+	}
+	f: Foo;
+	f.x, f.y = 123, 321;
+	println(f);
+	using x, y in f;
+	f.x, f.y = 456, 654;
+	println(f);
+}
+
+named_proc_return_parameters :: proc() {
+	fmt.println("# named proc return parameters");
+
+	foo0 :: proc() -> int {
+		return 123;
+	}
+	foo1 :: proc() -> (a: int) {
+		a = 123;
+		return;
+	}
+	foo2 :: proc() -> (a, b: int) {
+		// Named return values act like variables within the scope
+		a = 321;
+		b = 567;
+		return b, a;
+	}
+	fmt.println("foo0 =", foo0()); // 123
+	fmt.println("foo1 =", foo1()); // 123
+	fmt.println("foo2 =", foo2()); // 567 321
+}
+
+
+enum_export :: proc() {
+	fmt.println("# enum #export");
+
+	Foo :: enum #export {A, B, C};
+
+	f0 := A;
+	f1 := B;
+	f2 := C;
+	fmt.println(f0, f1, f2);
+}
+
+explicit_procedure_overloading :: proc() {
+	fmt.println("# explicit procedure overloading");
+
+	add_ints :: proc(a, b: int) -> int {
+		x := a + b;
+		fmt.println("add_ints", x);
+		return x;
+	}
+	add_floats :: proc(a, b: f32) -> f32 {
+		x := a + b;
+		fmt.println("add_floats", x);
+		return x;
+	}
+	add_numbers :: proc(a: int, b: f32, c: u8) -> int {
+		x := int(a) + int(b) + int(c);
+		fmt.println("add_numbers", x);
+		return x;
+	}
+
+	add :: proc[add_ints, add_floats, add_numbers];
+
+	add(int(1), int(2));
+	add(f32(1), f32(2));
+	add(int(1), f32(2), u8(3));
+
+	add(1, 2);     // untyped ints coerce to int tighter than f32
+	add(1.0, 2.0); // untyped floats coerce to f32 tighter than int
+	add(1, 2, 3);  // three parameters
+
+	// Ambiguous answers
+	// add(1.0, 2);
+	// add(1, 2.0);
+}
+
+main :: proc() {
+	when true {
+		general_stuff();
+		default_struct_values();
+		union_type();
+		parametric_polymorphism();
+		threading_example();
+		array_programming();
+		using_in();
+		named_proc_return_parameters();
+		enum_export();
+		explicit_procedure_overloading();
+	}
+}
@@ -0,0 +1,20 @@
+import "core:fmt.odin";
+
+main :: proc() {
+	recursive_factorial :: proc(i: u64) -> u64 {
+		if i < 2 do return 1;
+		return i * recursive_factorial(i-1);
+	}
+
+	loop_factorial :: proc(i: u64) -> u64 {
+		result: u64 = 1;
+		for n in 2..i {
+			result *= n;
+		}
+		return result;
+	}
+
+
+	fmt.println(recursive_factorial(12));
+	fmt.println(loop_factorial(12));
+}
@@ -0,0 +1,221 @@
+when ODIN_OS == "windows" do import win32 "core:sys/windows.odin";
+when ODIN_OS == "windows" import wgl "core:sys/wgl.odin";
+import "core:fmt.odin";
+import "core:math.odin";
+import "core:os.odin";
+import gl "core:opengl.odin";
+
+TWO_HEARTS :: '💕';
+
+win32_perf_count_freq := win32.get_query_performance_frequency();
+time_now :: proc() -> f64 {
+	assert(win32_perf_count_freq != 0);
+
+	counter: i64;
+	win32.query_performance_counter(&counter);
+	return f64(counter) / f64(win32_perf_count_freq);
+}
+win32_print_last_error :: proc() {
+	err_code := win32.get_last_error();
+	if err_code != 0 {
+		fmt.println("get_last_error: ", err_code);
+	}
+}
+
+// Yuk!
+to_c_string :: proc(s: string) -> []u8 {
+	c_str := make([]u8, len(s)+1);
+	copy(c_str, cast([]u8)s);
+	c_str[len(s)] = 0;
+	return c_str;
+}
+
+
+Window :: struct {
+	width, height:      int,
+	wc:                 win32.Wnd_Class_Ex_A,
+	dc:                 win32.Hdc,
+	hwnd:               win32.Hwnd,
+	opengl_context, rc: wgl.Hglrc,
+	c_title:            []u8,
+}
+
+make_window :: proc(title: string, msg, height: int, window_proc: win32.Wnd_Proc) -> (Window, bool) {
+	using win32;
+
+	w: Window;
+	w.width, w.height = msg, height;
+
+	class_name := "Win32-Odin-Window\x00";
+	c_class_name := &class_name[0];
+	if title[len(title)-1] != 0 {
+		w.c_title = to_c_string(title);
+	} else {
+		w.c_title = cast([]u8)title;
+	}
+
+	instance := get_module_handle_a(nil);
+
+	w.wc = Wnd_Class_Ex_A{
+		size       = size_of(Wnd_Class_Ex_A),
+		style      = CS_VREDRAW | CS_HREDRAW,
+		instance   = Hinstance(instance),
+		class_name = c_class_name,
+		wnd_proc   = window_proc,
+	};
+
+	if register_class_ex_a(&w.wc) == 0 {
+		win32_print_last_error();
+		return w, false;
+	}
+
+	w.hwnd = create_window_ex_a(0,
+	                            c_class_name, &w.c_title[0],
+	                            WS_VISIBLE | WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
+	                            CW_USEDEFAULT, CW_USEDEFAULT,
+	                            i32(w.width), i32(w.height),
+	                            nil, nil, instance, nil);
+
+	if w.hwnd == nil {
+		win32_print_last_error();
+		return w, false;
+	}
+
+	w.dc = get_dc(w.hwnd);
+
+	{
+		pfd := Pixel_Format_Descriptor{
+			size         = size_of(Pixel_Format_Descriptor),
+			version      = 1,
+			flags        = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
+			pixel_type   = PFD_TYPE_RGBA,
+			color_bits   = 32,
+			alpha_bits   = 8,
+			depth_bits   = 24,
+			stencil_bits = 8,
+			layer_type   = PFD_MAIN_PLANE,
+		};
+
+		set_pixel_format(w.dc, choose_pixel_format(w.dc, &pfd), nil);
+		w.opengl_context = wgl.create_context(w.dc);
+		wgl.make_current(w.dc, w.opengl_context);
+
+		attribs := [8]i32{
+			wgl.CONTEXT_MAJOR_VERSION_ARB, 2,
+			wgl.CONTEXT_MINOR_VERSION_ARB, 1,
+			wgl.CONTEXT_PROFILE_MASK_ARB, wgl.CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
+			0, // NOTE(bill): tells the that :: proc this is the end of attribs
+		};
+
+		wgl_str := "wglCreateContextAttribsARB\x00";
+		wglCreateContextAttribsARB := cast(wgl.Create_Context_Attribs_ARB_Type)wgl.get_proc_address(&wgl_str[0]);
+		w.rc = wglCreateContextAttribsARB(w.dc, nil, &attribs[0]);
+		wgl.make_current(w.dc, w.rc);
+		swap_buffers(w.dc);
+	}
+
+	return w, true;
+}
+
+destroy_window :: proc(w: ^Window) {
+	free(w.c_title);
+}
+
+display_window :: proc(w: ^Window) {
+	win32.swap_buffers(w.dc);
+}
+
+
+run :: proc() {
+	using math;
+
+	win32_proc :: proc(hwnd: win32.Hwnd, msg: u32, wparam: win32.Wparam, lparam: win32.Lparam) -> win32.Lresult #no_inline {
+		using win32;
+		if msg == WM_DESTROY || msg == WM_CLOSE || msg == WM_QUIT {
+			os.exit(0);
+			return 0;
+		}
+		return def_window_proc_a(hwnd, msg, wparam, lparam);
+	}
+
+	window, window_success := make_window("Odin Language Demo", 854, 480, cast(win32.Wnd_Proc)win32_proc);
+	if !window_success {
+		return;
+	}
+	defer destroy_window(&window);
+
+	gl.init();
+
+	using win32;
+
+	prev_time := time_now();
+	running := true;
+
+	pos := Vec2{100, 100};
+
+	for running {
+		curr_time := time_now();
+		dt := f32(curr_time - prev_time);
+		prev_time = curr_time;
+
+		msg: Msg;
+		for peek_message_a(&msg, nil, 0, 0, PM_REMOVE) > 0 {
+			if msg.message == WM_QUIT {
+				running = false;
+			}
+			translate_message(&msg);
+			dispatch_message_a(&msg);
+		}
+
+		if is_key_down(Key_Code.Escape) {
+			running = false;
+		}
+
+		{
+			SPEED :: 500;
+			v: Vec2;
+
+			if is_key_down(Key_Code.Right) do v[0] += 1;
+			if is_key_down(Key_Code.Left)  do v[0] -= 1;
+			if is_key_down(Key_Code.Up)    do v[1] += 1;
+			if is_key_down(Key_Code.Down)  do v[1] -= 1;
+
+			v = norm(v);
+
+			pos += v * Vec2{SPEED * dt};
+		}
+
+
+		gl.ClearColor(0.5, 0.7, 1.0, 1.0);
+		gl.Clear(gl.COLOR_BUFFER_BIT);
+
+		gl.LoadIdentity();
+		gl.Ortho(0, f64(window.width),
+		         0, f64(window.height), 0, 1);
+
+		draw_rect :: proc(x, y, w, h: f32) {
+			gl.Begin(gl.TRIANGLES);
+			defer gl.End();
+
+			gl.Color3f(1, 0, 0); gl.Vertex3f(x,   y,   0);
+			gl.Color3f(0, 1, 0); gl.Vertex3f(x+w, y,   0);
+			gl.Color3f(0, 0, 1); gl.Vertex3f(x+w, y+h, 0);
+
+			gl.Color3f(0, 0, 1); gl.Vertex3f(x+w, y+h, 0);
+			gl.Color3f(1, 1, 0); gl.Vertex3f(x,   y+h, 0);
+			gl.Color3f(1, 0, 0); gl.Vertex3f(x,   y,   0);
+		}
+
+		draw_rect(pos.x, pos.y, 50, 50);
+
+		display_window(&window);
+		if ms_to_sleep := i32(16 - 1000*dt); ms_to_sleep > 0 {
+			win32.sleep(ms_to_sleep);
+		}
+	}
+}
+
+
+main :: proc() {
+	run();
+}
@@ -0,0 +1,5 @@
+import "core:fmt.odin";
+
+main :: proc() {
+	fmt.println("Hellope, world!");
+}
@@ -1,83 +1,86 @@
-#import "fmt.odin"
-#import "os.odin"
-#import "mem.odin"
-// #import "http_test.odin" as ht
-// #import "game.odin" as game
-// #import "punity.odin" as pn
+import "core:fmt.odin";
+import "core:os.odin";
+import "core:mem.odin";
+// import "http_test.odin" as ht;
+// import "game.odin" as game;
+// import "punity.odin" as pn;

 main :: proc() {
-	// struct_padding()
-	// bounds_checking()
-	// type_introspection()
-	// any_type()
-	// crazy_introspection()
-	// namespaces_and_files()
-	// miscellany()
-	// ht.run()
-	// game.run()
-	// {
-	// 	init :: proc(c: ^pn.Core) {}
-	// 	step :: proc(c: ^pn.Core) {}
+	struct_padding();
+	bounds_checking();
+	type_introspection();
+	any_type();
+	crazy_introspection();
+	namespaces_and_files();
+	miscellany();

-	// 	pn.run(init, step)
-	// }
+	/*
+	ht.run();
+	game.run();
+	{
+		init :: proc(c: ^pn.Core) {}
+		step :: proc(c: ^pn.Core) {}
+
+		pn.run(init, step);
+	}
+	*/
 }

 struct_padding :: proc() {
 	{
 		A :: struct {
-			a: u8
-			b: u32
-			c: u16
+			a: u8,
+			b: u32,
+			c: u16,
 		}

 		B :: struct {
-			a: [7]u8
-			b: [3]u16
-			c: u8
-			d: u16
+			a: [7]u8,
+			b: [3]u16,
+			c: u8,
+			d: u16,
 		}

-		fmt.println("size_of(A):", size_of(A))
-		fmt.println("size_of(B):", size_of(B))
+		fmt.println("size_of(A):", size_of(A));
+		fmt.println("size_of(B):", size_of(B));

 		// n.b. http://cbloomrants.blogspot.co.uk/2012/07/07-23-12-structs-are-not-what-you-want.html
 	}
 	{
 		A :: struct #ordered {
-			a: u8
-			b: u32
-			c: u16
+			a: u8,
+			b: u32,
+			c: u16,
 		}

 		B :: struct #ordered {
-			a: [7]u8
-			b: [3]u16
-			c: u8
-			d: u16
+			a: [7]u8,
+			b: [3]u16,
+			c: u8,
+			d: u16,
 		}

-		fmt.println("size_of(A):", size_of(A))
-		fmt.println("size_of(B):", size_of(B))
+		fmt.println("size_of(A):", size_of(A));
+		fmt.println("size_of(B):", size_of(B));

 		// C-style structure layout
 	}
 	{
 		A :: struct #packed {
-			a: u8
-			b: u32
-			c: u16
+			a: u8,
+			b: u32,
+			c: u16,
 		}

 		B :: struct #packed {
-			a: [7]u8
-			b: [3]u16
-			c: u8
-			d: u16
+			a: [7]u8,
+			b: [3]u16,
+			c: u8,
+			d: u16,
 		}

-		fmt.println("size_of(A):", size_of(A))
-		fmt.println("size_of(B):", size_of(B))
+		fmt.println("size_of(A):", size_of(A));
+		fmt.println("size_of(B):", size_of(B));

 		// Useful for explicit layout
 	}
@@ -119,7 +122,7 @@ struct_padding :: proc() {
 }

 bounds_checking :: proc() {
-	x: [4]int
+	x: [4]int;
 	// x[-1] = 0; // Compile Time
 	// x[4]  = 0; // Compile Time

@@ -132,9 +135,9 @@ bounds_checking :: proc() {
 	// Works for arrays, strings, slices, and related procedures & operations

 	{
-		base: [10]int
-		s := base[2:6]
-		a, b := -1, 6
+		base: [10]int;
+		s := base[2..6];
+		a, b := -1, 6;

 		#no_bounds_check {
 			s[a] = 0;
@@ -154,69 +157,69 @@ bounds_checking :: proc() {

 type_introspection :: proc() {
 	{
-		info: ^Type_Info
-		x: int
+		info: ^Type_Info;
+		x: int;

-		info = type_info(int) // by type
-		info = type_info_of_val(x) // by value
+		info = type_info_of(int); // by type
+		info = type_info_of(x);   // by value
 		// See: runtime.odin

-		match type i : info {
-		case Type_Info.Integer:
-			fmt.println("integer!")
-		case Type_Info.Float:
-			fmt.println("float!")
-		default:
-			fmt.println("potato!")
+		match i in info.variant {
+		case Type_Info_Integer:
+			fmt.println("integer!");
+		case Type_Info_Float:
+			fmt.println("float!");
+		case:
+			fmt.println("potato!");
 		}

 		// Unsafe cast
-		integer_info := info as ^Type_Info.Integer
+		integer_info := cast(^Type_Info_Integer)cast(rawptr)info;
 	}

 	{
 		Vector2 :: struct { x, y: f32 }
 		Vector3 :: struct { x, y, z: f32 }

-		v1: Vector2
-		v2: Vector3
-		v3: Vector3
+		v1: Vector2;
+		v2: Vector3;
+		v3: Vector3;

-		t1 := type_info_of_val(v1)
-		t2 := type_info_of_val(v2)
-		t3 := type_info_of_val(v3)
+		t1 := type_info_of(v1);
+		t2 := type_info_of(v2);
+		t3 := type_info_of(v3);

-		fmt.println()
-		fmt.print("Type of v1 is:\n\t", t1)
+		fmt.println();
+		fmt.print("Type of v1 is:\n\t", t1);

-		fmt.println()
-		fmt.print("Type of v2 is:\n\t", t2)
+		fmt.println();
+		fmt.print("Type of v2 is:\n\t", t2);

-		fmt.println("\n")
-		fmt.println("t1 == t2:", t1 == t2)
-		fmt.println("t2 == t3:", t2 == t3)
+		fmt.println("\n");
+		fmt.println("t1 == t2:", t1 == t2);
+		fmt.println("t2 == t3:", t2 == t3);
 	}
 }

 any_type :: proc() {
-	a: any
+	a: any;

-	x: int = 123
-	y: f64 = 6.28
-	z: string = "Yo-Yo Ma"
+	x: int = 123;
+	y: f64 = 6.28;
+	z: string = "Yo-Yo Ma";
 	// All types can be implicit cast to `any`
-	a = x
-	a = y
-	a = z
-	a = a // This the "identity" type, it doesn't get converted
+	a = x;
+	a = y;
+	a = z;
+	a = a; // This the "identity" type, it doesn't get converted

-	a = 123 // Literals are copied onto the stack first
+	a = 123; // Literals are copied onto the stack first

 	// any has two members
 	// data      - rawptr to the data
 	// type_info - pointer to the type info

-	fmt.println(x, y, z)
+	fmt.println(x, y, z);
 	// See: fmt.odin
 	// For variadic any procedures in action
 }
@@ -232,15 +235,15 @@ crazy_introspection :: proc() {
 			TOMATO,
 		}

-		s: string
-		s = enum_to_string(Fruit.PEACH)
-		fmt.println(s)
+		s: string;
+		// s = enum_to_string(Fruit.PEACH);
+		fmt.println(s);

-		f := Fruit.GRAPE
-		s = enum_to_string(f)
-		fmt.println(s)
+		f := Fruit.GRAPE;
+		// s = enum_to_string(f);
+		fmt.println(s);

-		fmt.println(f)
+		fmt.println(f);
 		// See: runtime.odin
 	}

@@ -259,15 +262,15 @@ crazy_introspection :: proc() {
 			TOMATO,
 		}

-		fruit_ti := type_info(Fruit)
-		name := (fruit_ti as ^Type_Info.Named).name // Unsafe casts
-		info := type_info_base(fruit_ti) as ^Type_Info.Enum // Unsafe casts
+		fruit_ti := type_info_of(Fruit);
+		name := fruit_ti.variant.(Type_Info_Named).name;
+		info, _ := type_info_base(fruit_ti).variant.(Type_Info_Enum);

-		fmt.printf("% :: enum % {\n", name, info.base);
-		for i := 0; i < info.values.count; i++ {
-			fmt.printf("\t%\t= %,\n", info.names[i], info.values[i])
+		fmt.printf("%s :: enum %T {\n", name, info.base);
+		for _, i in info.values {
+			fmt.printf("\t%s\t= %v,\n", info.names[i], info.values[i]);
 		}
-		fmt.printf("}\n")
+		fmt.printf("}\n");

 		// NOTE(bill): look at that type-safe printf!
 	}
@@ -275,10 +278,10 @@ crazy_introspection :: proc() {
 	{
 		Vector3 :: struct {x, y, z: f32}

-		a := Vector3{x = 1, y = 4, z = 9}
-		fmt.println(a)
-		b := Vector3{x = 9, y = 3, z = 1}
-		fmt.println(b)
+		a := Vector3{x = 1, y = 4, z = 9};
+		fmt.println(a);
+		b := Vector3{x = 9, y = 3, z = 1};
+		fmt.println(b);

 		// NOTE(bill): See fmt.odin
 	}
@@ -0,0 +1,879 @@
+// Demo 002
+export "core:fmt.odin";
+export "core:math.odin";
+export "core:mem.odin";
+// export "game.odin"
+
+#thread_local tls_int: int;
+
+main :: proc() {
+	// Forenotes
+
+	// Semicolons are now optional
+	// Rule for when a semicolon is expected after a statement
+	// - If the next token is not on the same line
+	// - if the next token is a closing brace }
+	// - Otherwise, a semicolon is needed
+	//
+	// Expections:
+	// for, if, match
+	// if x := thing(); x < 123 {}
+	// for i := 0; i < 123; i++ {}
+
+	// Q: Should I use the new rule or go back to the old one without optional semicolons?
+
+
+	// #thread_local - see runtime.odin and above at `tls_int`
+	// #foreign_system_library - see win32.odin
+
+	// struct_compound_literals();
+	// enumerations();
+	// variadic_procedures();
+	// new_builtins();
+	// match_statement();
+	// namespacing();
+	// subtyping();
+	// tagged_unions();
+}
+
+struct_compound_literals :: proc() {
+	Thing :: struct {
+		id: int,
+		x: f32,
+		name: string,
+	};
+	{
+		t1: Thing;
+		t1.id = 1;
+
+		t3 := Thing{};
+		t4 := Thing{1, 2, "Fred"};
+		// t5 := Thing{1, 2};
+
+		t6 := Thing{
+			name = "Tom",
+			x    = 23,
+		};
+	}
+}
+
+enumerations :: proc() {
+	{
+		Fruit :: enum {
+			APPLE,  // 0
+			BANANA, // 1
+			PEAR,   // 2
+		};
+
+		f := Fruit.APPLE;
+		// g12: int = Fruit.BANANA
+		g: int = cast(int)Fruit.BANANA;
+		// However, you can use enums are index values as _any_ integer allowed
+	}
+	{
+		Fruit1 :: enum int {
+			APPLE,
+			BANANA,
+			PEAR,
+		}
+
+		Fruit2 :: enum u8 {
+			APPLE,
+			BANANA,
+			PEAR,
+		}
+
+		Fruit3 :: enum u8 {
+			APPLE = 1,
+			BANANA, // 2
+			PEAR  = 5,
+			TOMATO, // 6
+		}
+	}
+
+	// Q: remove the need for `type` if it's a record (struct/enum/raw_union/union)?
+}
+
+variadic_procedures :: proc() {
+	print_ints :: proc(args: ...int) {
+		for arg, i in args {
+			if i > 0 do print(", ");
+			print(arg);
+		}
+	}
+
+	print_ints(); // nl()
+	print_ints(1); nl();
+	print_ints(1, 2, 3); nl();
+
+	print_prefix_f32s :: proc(prefix: string, args: ...f32) {
+		print(prefix);
+		print(": ");
+		for arg, i in args {
+			if i > 0 do print(", ");
+			print(arg);
+		}
+	}
+
+	print_prefix_f32s("a"); nl();
+	print_prefix_f32s("b", 1); nl();
+	print_prefix_f32s("c", 1, 2, 3); nl();
+
+	// Internally, the variadic procedures get allocated to an array on the stack,
+	// and this array is passed a slice
+
+	// This is first step for a `print` procedure but I do not have an `any` type
+	// yet as this requires a few other things first - i.e. introspection
+
+	// NOTE(bill): I haven't yet added the feature of expanding a slice or array into
+	// a variadic a parameter but it's pretty trivial to add
+}
+
+new_builtins :: proc() {
+	{
+		a := new(int);
+		b := make([]int, 12);
+		c := make([]int, 12, 16);
+
+		defer free(a);
+		defer free(b);
+		defer free(c);
+
+		// NOTE(bill): These use the current context's allocator not the default allocator
+		// see runtime.odin
+
+		// Q: Should this be `free` rather than `free` and should I overload it for slices too?
+
+		push_allocator default_allocator() {
+			a := new(int);
+			defer free(a);
+
+			// Do whatever
+
+		}
+	}
+
+	{
+		a: int = 123;
+		b: type_of(a) = 321;
+
+		// NOTE(bill): This matches the current naming scheme
+		// size_of
+		// align_of
+		// offset_of
+		//
+		// size_of_val
+		// align_of_val
+		// offset_of_val
+		// type_of_val
+	}
+
+	{
+		// Compile time assert
+		COND :: true;
+		compile_assert(COND);
+		// compile_assert(!COND)
+
+		// Runtime assert
+		x := true;
+		assert(x);
+		// assert(!x);
+	}
+
+	{
+		x: ^u32 = nil;
+		y := x+100;
+		z := y-x;
+		w := slice_ptr(x, 12);
+		t := slice_ptr(x, 12, 16);
+
+		// NOTE(bill): These are here because I've removed:
+		// pointer arithmetic
+		// pointer indexing
+		// pointer slicing
+
+		// Reason
+
+		a: [16]int;
+		a[1] = 1;
+		b := &a;
+		// Auto pointer deref
+		// consistent with record members
+		assert(b[1] == 1);
+
+		// Q: Should I add them back in at the cost of inconsitency?
+	}
+
+	{
+		a, b := -1, 2;
+		print(min(a, b)); nl();
+		print(max(a, b)); nl();
+		print(abs(a)); nl();
+
+		// These work at compile time too
+		A :: -1;
+		B :: 2;
+		C :: min(A, B);
+		D :: max(A, B);
+		E :: abs(A);
+
+		print(C); nl();
+		print(D); nl();
+		print(E); nl();
+	}
+}
+
+
+match_statement :: proc() {
+	// NOTE(bill): `match` statements are similar to `switch` statements
+	// in other languages but there are few differences
+
+	{
+		match x := 5; x {
+		case 1: // cases must be constant expression
+			print("1!\n");
+			// break by default
+
+		case 2:
+			s := "2!\n"; // Each case has its own scope
+			print(s);
+			break; // explicit break
+
+		case 3, 4: // multiple cases
+			print("3 or 4!\n");
+
+		case 5:
+			print("5!\n");
+			fallthrough; // explicit fallthrough
+
+		case:
+			print("default!\n");
+		}
+
+
+
+		match x := 1.5; x {
+		case 1.5:
+			print("1.5!\n");
+			// break by default
+		case TAU:
+			print("τ!\n");
+		case:
+			print("default!\n");
+		}
+
+
+
+		match x := "Hello"; x {
+		case "Hello":
+			print("greeting\n");
+			// break by default
+		case "Goodbye":
+			print("farewell\n");
+		case:
+			print("???\n");
+		}
+
+
+
+
+
+
+		a := 53;
+		match {
+		case a == 1:
+			print("one\n");
+		case a == 2:
+			print("a couple\n");
+		case a < 7, a == 7:
+			print("a few\n");
+		case a < 12: // intentional bug
+			print("several\n");
+		case a >= 12 && a < 100:
+			print("dozens\n");
+		case a >= 100 && a < 1000:
+			print("hundreds\n");
+		case:
+			print("a fuck ton\n");
+		}
+
+		// Identical to this
+
+		b := 53;
+		if b == 1 {
+			print("one\n");
+		} else if b == 2 {
+			print("a couple\n");
+		} else if b < 7 || b == 7 {
+			print("a few\n");
+		} else if b < 12 { // intentional bug
+			print("several\n");
+		} else if b >= 12 && b < 100 {
+			print("dozens\n");
+		} else if b >= 100 && b < 1000 {
+			print("hundreds\n");
+		} else {
+			print("a fuck ton\n");
+		}
+
+		// However, match statements allow for `break` and `fallthrough` unlike
+		// an if statement
+	}
+}
+
+Vector3 :: struct {x, y, z: f32}
+
+print_floats :: proc(args: ...f32) {
+	for arg, i in args {
+		if i > 0 do print(", ");
+		print(arg);
+	}
+	println();
+}
+
+namespacing :: proc() {
+	{
+		Thing :: #type struct {
+			x: f32,
+			name: string,
+		};
+
+		a: Thing;
+		a.x = 3;
+		{
+			Thing :: #type struct {
+				y: int,
+				test: bool,
+			};
+
+			b: Thing; // Uses this scope's Thing
+			b.test = true;
+		}
+	}
+/*
+	{
+		Entity :: struct {
+			Guid :: int
+			Nested :: struct {
+				MyInt :: int
+				i: int
+			}
+
+			CONSTANT :: 123
+
+
+			guid:   Guid
+			name:   string
+			pos:    Vector3
+			vel:    Vector3
+			nested: Nested
+		}
+
+		guid: Entity.Guid = Entity.CONSTANT
+		i: Entity.Nested.MyInt
+
+
+
+		{
+			using Entity
+			guid: Guid = CONSTANT
+			using Nested
+			i: MyInt
+		}
+
+
+		{
+			using Entity.Nested
+			guid: Entity.Guid = Entity.CONSTANT
+			i: MyInt
+		}
+
+
+		{
+			e: Entity
+			using e
+			guid = 27832
+			name = "Bob"
+
+			print(e.guid as int); nl()
+			print(e.name); nl()
+		}
+
+		{
+			using e: Entity
+			guid = 78456
+			name = "Thing"
+
+			print(e.guid as int); nl()
+			print(e.name); nl()
+		}
+	}
+
+	{
+		Entity :: struct {
+			Guid :: int
+			Nested :: struct {
+				MyInt :: int
+				i: int
+			}
+
+			CONSTANT :: 123
+
+
+			guid:      Guid
+			name:      string
+			using pos: Vector3
+			vel:       Vector3
+			using nested: ^Nested
+		}
+
+		e := Entity{nested = new(Entity.Nested)}
+		e.x = 123
+		e.i = Entity.CONSTANT
+	}
+
+*/
+
+	{
+		Entity :: struct {
+			position: Vector3
+		}
+
+		print_pos_1 :: proc(entity: ^Entity) {
+			print("print_pos_1: ");
+			print_floats(entity.position.x, entity.position.y, entity.position.z);
+		}
+
+		print_pos_2 :: proc(entity: ^Entity) {
+			using entity;
+			print("print_pos_2: ");
+			print_floats(position.x, position.y, position.z);
+		}
+
+		print_pos_3 :: proc(using entity: ^Entity) {
+			print("print_pos_3: ");
+			print_floats(position.x, position.y, position.z);
+		}
+
+		print_pos_4 :: proc(using entity: ^Entity) {
+			using position;
+			print("print_pos_4: ");
+			print_floats(x, y, z);
+		}
+
+		e := Entity{position = Vector3{1, 2, 3}};
+		print_pos_1(&e);
+		print_pos_2(&e);
+		print_pos_3(&e);
+		print_pos_4(&e);
+
+		// This is similar to C++'s `this` pointer that is implicit and only available in methods
+	}
+}
+
+subtyping :: proc() {
+	{
+		// C way for subtyping/subclassing
+
+		Entity :: struct {
+			position: Vector3,
+		}
+
+		Frog :: struct {
+			entity: Entity,
+			jump_height: f32,
+		}
+
+		f: Frog;
+		f.entity.position = Vector3{1, 2, 3};
+
+		using f.entity;
+		position = Vector3{1, 2, 3};
+
+	}
+
+	{
+		// C++ way for subtyping/subclassing
+
+		Entity :: struct {
+			position: Vector3
+		}
+
+		Frog :: struct {
+			using entity: Entity,
+			jump_height: f32,
+		}
+
+		f: Frog;
+		f.position = Vector3{1, 2, 3};
+
+
+		print_pos :: proc(using entity: Entity) {
+			print("print_pos: ");
+			print_floats(position.x, position.y, position.z);
+		}
+
+		print_pos(f.entity);
+		// print_pos(f);
+
+		// Subtype Polymorphism
+	}
+
+	{
+		// More than C++ way for subtyping/subclassing
+
+		Entity :: struct {
+			position: Vector3,
+		}
+
+		Frog :: struct {
+			jump_height: f32,
+			using entity: ^Entity, // Doesn't have to be first member!
+		}
+
+		f: Frog;
+		f.entity = new(Entity);
+		f.position = Vector3{1, 2, 3};
+
+
+		print_pos :: proc(using entity: ^Entity) {
+			print("print_pos: ");
+			print_floats(position.x, position.y, position.z);
+		}
+
+		print_pos(f.entity);
+		// print_pos(^f);
+		// print_pos(f);
+	}
+
+	{
+		// More efficient subtyping
+
+		Entity :: struct {
+			position: Vector3,
+		}
+
+		Frog :: struct {
+			jump_height: f32,
+			using entity: ^Entity,
+		}
+
+		MAX_ENTITES :: 64;
+		entities: [MAX_ENTITES]Entity;
+		entity_count := 0;
+
+		next_entity :: proc(entities: []Entity, entity_count: ^int) -> ^Entity {
+			e := &entities[entity_count^];
+			entity_count^ += 1;
+			return e;
+		}
+
+		f: Frog;
+		f.entity = next_entity(entities[..], &entity_count);
+		f.position = Vector3{3, 4, 6};
+
+		using f.position;
+		print_floats(x, y, z);
+	}
+
+	/*{
+		// Down casting
+
+		Entity :: struct {
+			position: Vector3,
+		}
+
+		Frog :: struct {
+			jump_height: f32,
+			using entity: Entity,
+		}
+
+		f: Frog;
+		f.jump_height = 564;
+		e := ^f.entity;
+
+		frog := down_cast(^Frog)e;
+		print("down_cast: ");
+		print(frog.jump_height); nl();
+
+		// NOTE(bill): `down_cast` is unsafe and there are not check are compile time or run time
+		// Q: Should I completely remove `down_cast` as I added it in about 30 minutes
+	}*/
+
+	{
+		// Multiple "inheritance"/subclassing
+
+		Entity :: struct {
+			position: Vector3,
+		}
+		Climber :: struct {
+			speed: f32,
+		}
+
+		Frog :: struct {
+			using entity:  Entity,
+			using climber: Climber,
+		}
+	}
+}
+
+tagged_unions :: proc() {
+	{
+		Entity_Kind :: enum {
+			INVALID,
+			FROG,
+			GIRAFFE,
+			HELICOPTER,
+		}
+
+		Entity :: struct {
+			kind: Entity_Kind
+			using data: struct #raw_union {
+				frog: struct {
+					jump_height: f32,
+					colour: u32,
+				},
+				giraffe: struct {
+					neck_length: f32,
+					spot_count: int,
+				},
+				helicopter: struct {
+					blade_count: int,
+					weight: f32,
+					pilot_name: string,
+				},
+			}
+		}
+
+		e: Entity;
+		e.kind = Entity_Kind.FROG;
+		e.frog.jump_height = 12;
+
+		f: type_of(e.frog);
+
+		// But this is very unsafe and extremely cumbersome to write
+		// In C++, I use macros to alleviate this but it's not a solution
+	}
+
+	{
+		Frog :: struct {
+			jump_height: f32,
+			colour: u32,
+		}
+		Giraffe :: struct {
+			neck_length: f32,
+			spot_count: int,
+		}
+		Helicopter :: struct {
+			blade_count: int,
+			weight: f32,
+			pilot_name: string,
+		}
+		Entity :: union {Frog, Giraffe, Helicopter};
+
+		f1: Frog = Frog{12, 0xff9900};
+		f2: Entity = Frog{12, 0xff9900}; // Implicit cast
+		f3 := cast(Entity)Frog{12, 0xff9900}; // Explicit cast
+
+		// f3.Frog.jump_height = 12 // There are "members" of a union
+
+
+
+		e, f, g, h: Entity;
+		f = Frog{12, 0xff9900};
+		g = Giraffe{2.1, 23};
+		h = Helicopter{4, 1000, "Frank"};
+
+
+
+
+		// Requires a pointer to the union
+		// `x` will be a pointer to type of the case
+
+		match x in &f {
+		case Frog:
+			print("Frog!\n");
+			print(x.jump_height); nl();
+			// x.jump_height = 3;
+			print(x.jump_height); nl();
+		case Giraffe:
+			print("Giraffe!\n");
+		case Helicopter:
+			print("ROFLCOPTER!\n");
+		case:
+			print("invalid entity\n");
+		}
+
+
+		// Q: Allow for a non pointer version with takes a copy instead?
+		// Or it takes the pointer the data and not a copy
+
+
+		// fp := cast(^Frog)^f; // Unsafe
+		// print(fp.jump_height); nl();
+
+
+		// Internals of a tagged union
+		/*
+			struct {
+				data: [size_of_biggest_tag]u8,
+				tag_index: int,
+			}
+		*/
+		// This is to allow for pointer casting if needed
+
+
+		// Advantage over subtyping version
+		MAX_ENTITES :: 64;
+		entities: [MAX_ENTITES]Entity;
+
+		entities[0] = Frog{};
+		entities[1] = Helicopter{};
+		// etc.
+	}
+
+
+	{
+		// Transliteration of code from this actual compiler
+		// Some stuff is missing
+		Type       :: struct {};
+		Scope      :: struct {};
+		Token      :: struct {};
+		AstNode    :: struct {};
+		ExactValue :: struct {};
+
+		Entity_Kind :: enum {
+			Invalid,
+			Constant,
+			Variable,
+			Using_Variable,
+			TypeName,
+			Procedure,
+			Builtin,
+			Count,
+		}
+
+		Guid :: i64;
+		Entity :: struct {
+
+			kind: Entity_Kind,
+			guid: Guid,
+
+			scope: ^Scope,
+			token: Token,
+			type_: ^Type,
+
+			using data: struct #raw_union {
+				Constant: struct {
+					value: ExactValue,
+				},
+				Variable: struct {
+					visited:   bool, // Cycle detection
+					used:      bool, // Variable is used
+					is_field:  bool, // Is struct field
+					anonymous: bool, // Variable is an anonymous
+				},
+				Using_Variable: struct {
+				},
+				TypeName: struct {
+				},
+				Procedure: struct {
+					used: bool,
+				},
+				Builtin: struct {
+					id: int,
+				},
+			},
+		}
+
+		// Plus all the constructing procedures that go along with them!!!!
+		// It's a nightmare
+	}
+
+	{
+		Type       :: struct {};
+		Scope      :: struct {};
+		Token      :: struct {};
+		AstNode    :: struct {};
+		ExactValue :: struct {};
+
+
+		Guid :: i64;
+		Entity_Base :: struct {
+		}
+
+
+		Constant :: struct {
+			value: ExactValue,
+		}
+		Variable :: struct {
+			visited:   bool, // Cycle detection
+			used:      bool, // Variable is used
+			is_field:  bool, // Is struct field
+			anonymous: bool, // Variable is an anonymous
+		}
+		Using_Variable :: struct {
+		}
+		TypeName :: struct {
+		}
+		Procedure :: struct {
+			used: bool,
+		}
+		Builtin :: struct {
+			id: int,
+		}
+
+		Entity :: struct {
+			guid: Guid,
+
+			scope: ^Scope,
+			token: Token,
+			type_: ^Type,
+
+			variant: union {Constant, Variable, Using_Variable, TypeName, Procedure, Builtin},
+		}
+
+		e := Entity{
+			variant = Variable{
+				used = true,
+				anonymous = false,
+			},
+		};
+
+
+
+		// Q: Allow a "base" type to be added to a union?
+		// Or even `using` on union to get the same properties?
+	}
+
+
+	{
+		// `Raw` unions still have uses, especially for mathematic types
+
+		Vector2 :: struct #raw_union {
+			using xy_: struct { x, y: f32 },
+			e: [2]f32,
+			v: [vector 2]f32,
+		}
+
+		Vector3 :: struct #raw_union {
+			using xyz_: struct { x, y, z: f32 },
+			xy: Vector2,
+			e: [3]f32,
+			v: [vector 3]f32,
+		}
+
+		v2: Vector2;
+		v2.x = 1;
+		v2.e[0] = 1;
+		v2.v[0] = 1;
+
+		v3: Vector3;
+		v3.x = 1;
+		v3.e[0] = 1;
+		v3.v[0] = 1;
+		v3.xy.x = 1;
+	}
+}
+
+nl :: proc() { println(); }
@@ -1,14 +1,14 @@
-#import "fmt.odin"
-#import "utf8.odin"
-#import "hash.odin"
-#import "mem.odin"
+import "core:fmt.odin";
+import "core:utf8.odin";
+import "core:hash.odin";
+import "core:mem.odin";

 main :: proc() {
 	{ // New Standard Library stuff
-		s := "Hello"
+		s := "Hello";
 		fmt.println(s,
 		            utf8.valid_string(s),
-		            hash.murmur64(s.data, s.count))
+		            hash.murmur64(cast([]u8)s));

 		// utf8.odin
 		// hash.odin
@@ -19,15 +19,15 @@ main :: proc() {
 	}

 	{
-		arena: mem.Arena
-		mem.init_arena_from_context(^arena, mem.megabytes(16)) // Uses default allocator
-		defer mem.free_arena(^arena)
+		arena: mem.Arena;
+		mem.init_arena_from_context(&arena, mem.megabytes(16)); // Uses default allocator
+		defer mem.destroy_arena(&arena);

-		push_allocator mem.arena_allocator(^arena) {
-			x := new(int)
-			x^ = 1337
+		push_allocator mem.arena_allocator(&arena) {
+			x := new(int);
+			x^ = 1337;

-			fmt.println(x^)
+			fmt.println(x^);
 		}

 		/*
@@ -48,14 +48,14 @@ main :: proc() {

 		// You can also "push" a context

-		c := current_context() // Create copy of the allocator
-		c.allocator = mem.arena_allocator(^arena)
+		c := context; // Create copy of the allocator
+		c.allocator = mem.arena_allocator(&arena);

 		push_context c {
-			x := new(int)
-			x^ = 365
+			x := new(int);
+			x^ = 365;

-			fmt.println(x^)
+			fmt.println(x^);
 		}
 	}

@@ -0,0 +1,283 @@
+import "core:fmt.odin";
+import "core:utf8.odin";
+// import "core:atomic.odin";
+// import "core:hash.odin";
+// import "core:math.odin";
+// import "core:mem.odin";
+// import "core:opengl.odin";
+// import "core:os.odin";
+// import "core:sync.odin";
+// import win32 "core:sys/windows.odin";
+
+main :: proc() {
+	// syntax();
+	procedure_overloading();
+}
+
+syntax :: proc() {
+	// Cyclic type checking
+	// Uncomment to see the error
+	// A :: struct {b: B};
+	// B :: struct {a: A};
+
+	x: int;
+	y := cast(f32)x;
+	z := transmute(u32)y;
+	// down_cast, union_cast are similar too
+
+
+
+	// Basic directives
+	fmt.printf("Basic directives = %s(%d): %s\n", #file, #line, #procedure);
+	// NOTE: new and improved `printf`
+	// TODO: It does need accurate float printing
+
+
+
+	// record fields use the same syntax a procedure signatures
+	Thing1 :: struct {
+		x: f32,
+		y: int,
+		z: ^[]int,
+	};
+	Thing2 :: struct {x: f32, y: int, z: ^[]int};
+
+	// Slice interals are now just a `ptr+len+cap`
+	slice: []int; compile_assert(size_of(slice) == 3*size_of(int));
+
+	// Helper type - Help the reader understand what it is quicker
+	My_Int  :: #type int;
+	My_Proc :: #type proc(int) -> f32;
+
+
+	// All declarations with : are either variable or constant
+	// To make these declarations syntactically consistent
+	v_variable := 123;
+	c_constant :: 123;
+	c_type1    :: int;
+	c_type2    :: []int;
+	c_proc     :: proc() { /* code here */ };
+
+
+/*
+	x += 1;
+	x -= 1;
+	// ++ and -- have been removed
+	// x++;
+	// x--;
+	// Question: Should they be added again?
+	// They were removed as they are redundant and statements, not expressions
+	// like in C/C++
+*/
+
+	// You can now build files as a `.dll`
+	// `odin build_dll demo.odin`
+
+
+	// New vector syntax
+	u, v: [vector 3]f32;
+	v[0] = 123;
+	v.x  = 123; // valid for all vectors with count 1 to 4
+
+	// Next part
+	prefixes();
+}
+
+
+Prefix_Type :: struct {x: int, y: f32, z: rawptr};
+
+#thread_local my_tls: Prefix_Type;
+
+prefixes :: proc() {
+	using var: Prefix_Type;
+	var.x = 123;
+	x = 123;
+
+
+	foo :: proc(using pt: Prefix_Type) {
+	}
+
+
+
+	// Same as C99's `restrict`
+	bar :: proc(#no_alias a, b: ^int) {
+		// Assumes a never equals b so it can perform optimizations with that fact
+	}
+
+
+	when_statements();
+}
+
+
+
+
+
+when_statements :: proc() {
+	X :: 123 + 12;
+	Y :: X/5;
+	COND :: Y > 0;
+
+	when COND {
+		fmt.println("Y > 0");
+	} else {
+		fmt.println("Y <= 0");
+	}
+
+
+	when false {
+		this_code_does_not_exist(123, 321);
+		but_its_syntax_is_valid();
+		x :: ^^^^int;
+	}
+
+	foreign_procedures();
+}
+
+when ODIN_OS == "windows" {
+	foreign_system_library win32_user "user32.lib";
+}
+// NOTE: This is done on purpose for two reasons:
+// * Makes it clear where the platform specific stuff is
+// * Removes the need to solve the travelling salesman problem when importing files :P
+
+foreign_procedures :: proc() {
+	foreign win32_user {
+		ShowWindow  :: proc(hwnd: rawptr, cmd_show: i32) -> i32 ---;
+		show_window :: proc(hwnd: rawptr, cmd_show: i32) -> i32 #link_name "ShowWindow" ---;
+	}
+	// NOTE: If that library doesn't get used, it doesn't get linked with
+	// NOTE: There is not link checking yet to see if that procedure does come from that library
+
+	// See sys/windows.odin for more examples
+
+	special_expressions();
+}
+
+special_expressions :: proc() {
+/*
+	// Block expression
+	x := {
+		a: f32 = 123;
+		b := a-123;
+		c := b/a;
+		give c;
+	}; // semicolon is required as it's an expression
+
+	y := if x < 50 {
+		give x;
+	} else {
+		// TODO: Type cohesion is not yet finished
+		give 123;
+	}; // semicolon is required as it's an expression
+*/
+
+	// This is allows for inline blocks of code and will be a useful feature to have when
+	// macros will be implemented into the language
+
+	loops();
+}
+
+loops :: proc() {
+	// The C-style for loop
+	for i := 0; i < 123; i += 1 {
+		break;
+	}
+	for i := 0; i < 123; {
+		break;
+	}
+	for false {
+		break;
+	}
+	for {
+		break;
+	}
+
+	for i in 0..123 { // 123 exclusive
+	}
+
+	for i in 0..123-1 { // 122 inclusive
+	}
+
+	for val, idx in 12..16 {
+		fmt.println(val, idx);
+	}
+
+	primes := [...]int{2, 3, 5, 7, 11, 13, 17, 19};
+
+	for p in primes {
+		fmt.println(p);
+	}
+
+	// Pointers to arrays, slices, or strings are allowed
+	for _ in &primes {
+		// ignore the value and just iterate across it
+	}
+
+
+
+	name := "你好，世界";
+	fmt.println(name);
+	for r in name {
+		compile_assert(type_of(r) == rune);
+		fmt.printf("%r\n", r);
+	}
+
+	when false {
+		for i, size := 0; i < name.count; i += size {
+			r: rune;
+			r, size = utf8.decode_rune(name[i..]);
+			fmt.printf("%r\n", r);
+		}
+	}
+
+	procedure_overloading();
+}
+
+
+procedure_overloading :: proc() {
+	THINGF :: 14451.1;
+	THINGI :: 14451;
+
+	foo :: proc() {
+		fmt.printf("Zero args\n");
+	}
+	foo :: proc(i: int) {
+		fmt.printf("int arg, i=%d\n", i);
+	}
+	foo :: proc(f: f64) {
+		i := cast(int)f;
+		fmt.printf("f64 arg, f=%d\n", i);
+	}
+
+	foo();
+	foo(THINGF);
+	// foo(THINGI); // 14451 is just a number so it could go to either procedures
+	foo(cast(int)THINGI);
+
+
+
+
+	foo :: proc(x: ^i32) -> (int, int) {
+		fmt.println("^int");
+		return 123, cast(int)(x^);
+	}
+	foo :: proc(x: rawptr) {
+		fmt.println("rawptr");
+	}
+
+
+	a: i32 = 123;
+	b: f32;
+	c: rawptr;
+	fmt.println(foo(&a));
+	foo(&b);
+	foo(c);
+	// foo(nil); // nil could go to numerous types thus the ambiguity
+
+	f: proc();
+	f = foo; // The correct `foo` to chosen
+	f();
+
+
+	// See math.odin and atomic.odin for more examples
+}
@@ -0,0 +1,310 @@
+// import "core:atomic.odin";
+import "core:hash.odin";
+import "core:mem.odin";
+import "core:opengl.odin";
+import "core:strconv.odin";
+import "core:sync.odin";
+import win32 "core:sys/windows.odin";
+
+import "core:fmt.odin";
+import "core:os.odin";
+import "core:math.odin";
+
+
+main :: proc() {
+when true {
+/*
+	Added:
+		* Unexported entities and fields using an underscore prefix
+			- See `sync.odin` and explain
+
+	Removed:
+	 * Maybe/option types
+	 * Remove `type` keyword and other "reserved" keywords
+	 * ..< and ... removed and replace with .. (half-closed range)
+
+	Changed:
+	 * `compile_assert` and `assert` return the value of the condition for semantic reasons
+	 * thread_local -> #thread_local
+	 * #include -> #load
+	 * Files only get checked if they are actually used
+	 * match x in y {} // For type match statements
+	 * Version numbering now starts from 0.1.0 and uses the convention:
+	 	- major.minor.patch
+	 * Core library additions to Windows specific stuff
+ */
+
+	{
+		Fruit :: enum {
+			APPLE,
+			BANANA,
+			COCONUT,
+		}
+		fmt.println(Fruit.names);
+	}
+
+	{
+		A :: struct           {x, y: f32};
+		B :: struct #align 16 {x, y: f32};
+		fmt.println("align_of(A) =", align_of(A));
+		fmt.println("align_of(B) =", align_of(B));
+	}
+
+	{
+		// Removal of ..< and ...
+		for i in 0..16 {
+		}
+		// Is similar to
+		for i := 0; i < 16; i += 1 {
+		}
+	}
+
+	{
+		thing: for i in 0..10 {
+			for j in i+1..10 {
+				if j == 2 {
+					fmt.println(i, j);
+					continue thing;
+				}
+				if j == 3 {
+					break thing;
+				}
+			}
+		}
+
+		// Works with, `for`, `for in`, `match`, `match in`
+		// NOTE(bill): This solves most of the problems I need `goto` for
+	}
+
+	{
+		t := type_info_of(int);
+		match i in t.variant {
+		case Type_Info_Integer, Type_Info_Float:
+			fmt.println("It's a number");
+		}
+
+
+		x: any = 123;
+		foo: match i in x {
+		case int, f32:
+			fmt.println("It's an int or f32");
+			break foo;
+		}
+	}
+
+	{
+		cond := true;
+		x: int;
+		if cond {
+			x = 3;
+		} else {
+			x = 4;
+		}
+
+
+		// Ternary operator
+		y := cond ? 3 : 4;
+
+		FOO :: true ? 123 : 432; // Constant ternary expression
+		fmt.println("Ternary values:", y, FOO);
+	}
+
+	{
+		// Slices now store a capacity
+		buf: [256]u8;
+		s: []u8;
+		s = buf[..0]; // == buf[0..0];
+		fmt.println("count =", len(s));
+		fmt.println("capacity =", cap(s));
+		append(&s, 1, 2, 3);
+		fmt.println(s);
+
+		s = buf[1..2..3];
+		fmt.println("count =", len(s));
+		fmt.println("capacity =", cap(s));
+		fmt.println(s);
+
+		clear(&s); // Sets count to zero
+	}
+
+	{
+		Foo :: struct {
+			x, y, z: f32,
+			ok:      bool,
+			flags:   u32,
+		}
+		foo_array: [256]Foo;
+		foo_as_bytes: []u8 = mem.slice_to_bytes(foo_array[..]);
+		// Useful for things like
+		// os.write(handle, foo_as_bytes);
+
+		foo_slice := mem.slice_ptr(cast(^Foo)&foo_as_bytes[0], len(foo_as_bytes)/size_of(Foo), cap(foo_as_bytes)/size_of(Foo));
+		// Question: Should there be a bytes_to_slice procedure or is it clearer to do this even if it is error prone?
+		// And if so what would the syntax be?
+		// slice_transmute([]Foo, foo_as_bytes);
+	}
+
+	{
+		Vec3 :: [vector 3]f32;
+
+		x := Vec3{1, 2, 3};
+		y := Vec3{4, 5, 6};
+		fmt.println(x < y);
+		fmt.println(x + y);
+		fmt.println(x - y);
+		fmt.println(x * y);
+		fmt.println(x / y);
+
+		for i in x {
+			fmt.println(i);
+		}
+
+		compile_assert(size_of([vector 7]bool) >= size_of([7]bool));
+		compile_assert(size_of([vector 7]i32) >= size_of([7]i32));
+		// align_of([vector 7]i32) != align_of([7]i32) // this may be the case
+	}
+
+	{
+		// fmt.* changes
+		// bprint* returns `string`
+
+		data: [256]u8;
+		str := fmt.bprintf(data[..], "Hellope %d %s %c", 123, "others", '!');
+		fmt.println(str);
+	}
+
+	{
+		x: [dynamic]f64;
+		reserve(&x, 16);
+		defer free(x); // `free` is overloaded for numerous types
+		// Number literals can have underscores in them for readability
+		append(&x, 2_000_000.500_000, 123, 5, 7); // variadic append
+
+		for p, i in x {
+			if i > 0 { fmt.print(", "); }
+			fmt.print(p);
+		}
+		fmt.println();
+	}
+
+	{
+		// Dynamic array "literals"
+		x := [dynamic]f64{2_000_000.500_000, 3, 5, 7};
+		defer free(x);
+		fmt.println(x); // fmt.print* supports printing of dynamic types
+		clear(&x);
+		fmt.println(x);
+	}
+
+	{
+		m: map[f32]int;
+		reserve(&m, 16);
+		defer free(m);
+
+		m[1.0] = 1278;
+		m[2.0] = 7643;
+		m[3.0] = 564;
+		_, ok := m[3.0];
+		c := m[3.0];
+		assert(ok && c == 564);
+
+		fmt.print("map[");
+		i := 0;
+		for val, key in m {
+			if i > 0 {
+				fmt.print(", ");
+			}
+			fmt.printf("%v=%v", key, val);
+			i += 1;
+		}
+		fmt.println("]");
+	}
+	{
+		m := map[string]u32{
+			"a" = 56,
+			"b" = 13453,
+			"c" = 7654,
+		};
+		defer free(m);
+
+		c := m["c"];
+		_, ok := m["c"];
+		assert(ok && c == 7654);
+		fmt.println(m);
+
+		delete(&m, "c"); // deletes entry with key "c"
+		_, found := m["c"];
+		assert(!found);
+
+		fmt.println(m);
+		clear(&m);
+		fmt.println(m);
+
+		// NOTE: Fixed size maps are planned but we have not yet implemented
+		// them as we have had no need for them as of yet
+	}
+
+	{
+		Vector3 :: struct{x, y, z: f32};
+		Quaternion :: struct{x, y, z, w: f32};
+
+		// Variants
+		Frog :: struct {
+			ribbit_volume: f32,
+			jump_height:   f32,
+		}
+		Door :: struct {
+			openness: f32,
+		}
+		Map :: struct {
+			width, height:   f32,
+			place_positions: []Vector3,
+			place_names:     []string,
+		}
+
+		Entity :: struct {
+			// Common Fields
+			id:             u64,
+			name:           string,
+			using position: Vector3,
+			orientation:    Quaternion,
+			flags:          u32,
+
+			variant: union { Frog, Door, Map },
+		}
+
+		entity: Entity;
+		entity.id = 1337;
+		// implicit conversion from variant to base type
+		entity.variant = Frog{
+			ribbit_volume = 0.5,
+			jump_height = 2.1,
+			/*other data */
+		};
+
+		entity.name = "Frank";
+		entity.position = Vector3{1, 4, 9};
+
+		match e in entity.variant {
+		case Frog:
+			fmt.println("Ribbit");
+		case Door:
+			fmt.println("Creak");
+		case Map:
+			fmt.println("Rustle");
+		case:
+			fmt.println("Just a normal entity");
+		}
+
+		if frog, ok := entity.variant.(Frog); ok {
+			fmt.printf("The frog jumps %f feet high at %v\n", frog.jump_height, entity.position);
+		}
+
+		// Panics if not the correct type
+		frog: Frog;
+		frog = entity.variant.(Frog);
+		frog, _ = entity.variant.(Frog); // ignore error and force cast
+	}
+}
+}
+
@@ -0,0 +1,430 @@
+import (
+	"fmt.odin";
+	"atomics.odin";
+	"bits.odin";
+	"decimal.odin";
+	"hash.odin";
+	"math.odin";
+	"mem.odin";
+	"opengl.odin";
+	"os.odin";
+	"raw.odin";
+	"strconv.odin";
+	"strings.odin";
+	"sync.odin";
+	"sort.odin";
+	"types.odin";
+	"utf8.odin";
+	"utf16.odin";
+/*
+*/
+)
+
+
+general_stuff :: proc() {
+	// Complex numbers
+	a := 3 + 4i;
+	b: complex64 = 3 + 4i;
+	c: complex128 = 3 + 4i;
+	d := complex(2, 3);
+
+	e := a / conj(a);
+	fmt.println("(3+4i)/(3-4i) =", e);
+	fmt.println(real(e), "+", imag(e), "i");
+
+
+	// C-style variadic procedures
+	foreign __llvm_core {
+		// The variadic part allows for extra type checking too which C does not provide
+		c_printf :: proc(fmt: ^u8, #c_vararg args: ...any) -> i32 #link_name "printf" ---;
+	}
+	str := "%d\n\x00";
+	// c_printf(&str[0], i32(789456123));
+
+
+	Foo :: struct {
+		x: int;
+		y: f32;
+		z: string;
+	}
+	foo := Foo{123, 0.513, "A string"};
+	x, y, z := expand_to_tuple(foo);
+	fmt.println(x, y, z);
+	compile_assert(type_of(x) == int);
+	compile_assert(type_of(y) == f32);
+	compile_assert(type_of(z) == string);
+
+
+	// By default, all variables are zeroed
+	// This can be overridden with the "uninitialized value"
+	// This is similar to `nil` but applied to everything
+	undef_int: int = ---;
+
+
+	// Context system is now implemented using Implicit Parameter Passing (IPP)
+	// The previous implementation was Thread Local Storage (TLS)
+	// IPP has the advantage that it works on systems without TLS and that you can
+	// link the context to the stack frame and thus look at previous contexts
+	//
+	// It does mean that a pointer is implicitly passed procedures with the default
+	// Odin calling convention (#cc_odin)
+	// This can be overridden with something like #cc_contextless or #cc_c if performance
+	// is worried about
+
+}
+
+foreign_blocks :: proc() {
+	// See sys/windows.odin
+}
+
+default_arguments :: proc() {
+	hello :: proc(a: int = 9, b: int = 9) do fmt.printf("a is %d; b is %d\n", a, b);
+	fmt.println("\nTesting default arguments:");
+	hello(1, 2);
+	hello(1);
+	hello();
+}
+
+named_arguments :: proc() {
+	Colour :: enum {
+		Red,
+		Orange,
+		Yellow,
+		Green,
+		Blue,
+		Octarine,
+	};
+	using Colour;
+
+	make_character :: proc(name, catch_phrase: string, favourite_colour, least_favourite_colour: Colour) {
+		fmt.println();
+		fmt.printf("My name is %v and I like %v.  %v\n", name, favourite_colour, catch_phrase);
+	}
+
+	make_character("Frank", "¡Ay, caramba!", Blue, Green);
+
+
+	// As the procedures have more and more parameters, it is very easy
+	// to get many of the arguments in the wrong order especialy if the
+	// types are the same
+	make_character("¡Ay, caramba!", "Frank", Green, Blue);
+
+	// Named arguments help to disambiguate this problem
+	make_character(catch_phrase = "¡Ay, caramba!", name = "Frank",
+	               least_favourite_colour = Green, favourite_colour = Blue);
+
+
+	// The named arguments can be specifed in any order.
+	make_character(favourite_colour = Octarine, catch_phrase = "U wot m8!",
+	               least_favourite_colour = Green, name = "Dennis");
+
+
+	// NOTE: You cannot mix named arguments with normal values
+	/*
+	make_character("Dennis",
+	               favourite_colour = Octarine, catch_phrase = "U wot m8!",
+	               least_favourite_colour = Green);
+	*/
+
+
+	// Named arguments can also aid with default arguments
+	numerous_things :: proc(s: string, a := 1, b := 2, c := 3.14,
+	                        d := "The Best String!", e := false, f := 10.3/3.1, g := false) {
+		g_str := g ? "true" : "false";
+		fmt.printf("How many?! %s: %v\n", s, g_str);
+	}
+
+	numerous_things("First");
+	numerous_things(s = "Second", g = true);
+
+
+	// Default values can be placed anywhere, not just at the end like in other languages
+	weird :: proc(pre: string, mid: int = 0, post: string) {
+		fmt.println(pre, mid, post);
+	}
+
+	weird("How many things", 42, "huh?");
+	weird(pre = "Prefix", post = "Pat");
+
+}
+
+
+default_return_values :: proc() {
+	foo :: proc(x: int) -> (first: string = "Hellope", second := "world!") {
+		match x {
+		case 0: return;
+		case 1: return "Goodbye";
+		case 2: return "Goodbye", "cruel world...";
+		case 3: return second = "cruel world...", first = "Goodbye";
+		}
+
+		return second = "my old friend.";
+	}
+
+	fmt.printf("%s %s\n", foo(0));
+	fmt.printf("%s %s\n", foo(1));
+	fmt.printf("%s %s\n", foo(2));
+	fmt.printf("%s %s\n", foo(3));
+	fmt.printf("%s %s\n", foo(4));
+	fmt.println();
+
+
+	// A more "real" example
+	Error :: enum {
+		None,
+		WhyTheNumberThree,
+		TenIsTooBig,
+	};
+
+	Entity :: struct {
+		name: string;
+		id:   u32;
+	}
+
+	some_thing :: proc(input: int) -> (result: ^Entity = nil, err := Error.None) {
+		match {
+		case input == 3:  return err = Error.WhyTheNumberThree;
+		case input >= 10: return err = Error.TenIsTooBig;
+		}
+
+		e := new(Entity);
+		e.id = u32(input);
+
+		return result = e;
+	}
+}
+
+call_location :: proc() {
+	amazing :: proc(n: int, using loc := #caller_location) {
+		fmt.printf("%s(%d:%d) just asked to do something amazing.\n",
+				   fully_pathed_filename, line, column);
+		fmt.printf("Normal -> %d\n", n);
+		fmt.printf("Amazing -> %d\n", n+1);
+		fmt.println();
+	}
+
+	loc := #location(main);
+	fmt.println("`main` is located at", loc);
+
+	fmt.println("This line is located at", #location());
+	fmt.println();
+
+	amazing(3);
+	amazing(4, #location(call_location));
+
+	// See _preload.odin for the implementations of `assert` and `panic`
+
+}
+
+
+explicit_parametric_polymorphic_procedures :: proc() {
+	// This is how `new` is actually implemented, see _preload.odin
+	alloc_type :: proc(T: type) -> ^T do return cast(^T)alloc(size_of(T), align_of(T));
+
+	int_ptr := alloc_type(int);
+	defer free(int_ptr);
+	int_ptr^ = 137;
+	fmt.println(int_ptr, int_ptr^);
+
+	// Named arguments work too!
+	another_ptr := alloc_type(T = f32);
+	defer free(another_ptr);
+
+
+	add :: proc(T: type, args: ...T) -> T {
+		res: T;
+		for arg in args do res += arg;
+		return res;
+	}
+
+	fmt.println("add =", add(int, 1, 2, 3, 4, 5, 6));
+
+	swap :: proc(T: type, a, b: ^T) {
+		tmp := a^;
+		a^ = b^;
+		b^ = tmp;
+	}
+
+	a, b: int = 3, 4;
+	fmt.println("Pre-swap:", a, b);
+	swap(int, &a, &b);
+	fmt.println("Post-swap:", a, b);
+	a, b = b, a; // Or use this syntax for this silly example case
+
+
+	Vector2 :: struct {x, y: f32;};
+	{
+		// A more complicated example using subtyping
+		// Something like this could be used in a game
+
+		Entity :: struct {
+			using position: Vector2;
+			flags:          u64;
+			id:             u64;
+			derived:        any;
+		}
+
+		Rock :: struct {
+			using entity: Entity;
+			heavy: bool;
+		}
+		Door :: struct {
+			using entity: Entity;
+			open:         bool;
+		}
+		Monster :: struct {
+			using entity: Entity;
+			is_robot:     bool;
+			is_zombie:    bool;
+		}
+
+		new_entity :: proc(T: type, x, y: f32) -> ^T {
+			result := new(T);
+			result.derived = result^;
+			result.x = x;
+			result.y = y;
+
+			return result;
+		}
+
+		entities: [dynamic]^Entity;
+
+		rock := new_entity(Rock, 3, 5);
+
+		// Named arguments work too!
+		door := new_entity(T = Door, x = 3, y = 6);
+
+		// And named arguments can be any order
+		monster := new_entity(
+			y = 1,
+			x = 2,
+			T = Monster,
+		);
+
+		append(&entities, rock, door, monster);
+
+		fmt.println("Subtyping");
+		for entity in entities {
+			match e in entity.derived {
+			case Rock:    fmt.println("Rock",    e.x, e.y);
+			case Door:    fmt.println("Door",    e.x, e.y);
+			case Monster: fmt.println("Monster", e.x, e.y);
+			}
+		}
+	}
+	{
+		Entity :: struct {
+			using position: Vector2;
+			flags:          u64;
+			id:             u64;
+			variant: union { Rock, Door, Monster };
+		}
+
+		Rock :: struct {
+			using entity: ^Entity;
+			heavy: bool;
+		}
+		Door :: struct {
+			using entity: ^Entity;
+			open:         bool;
+		}
+		Monster :: struct {
+			using entity: ^Entity;
+			is_robot:     bool;
+			is_zombie:    bool;
+		}
+
+		new_entity :: proc(T: type, x, y: f32) -> ^T {
+			result := new(Entity);
+			result.variant = T{entity = result};
+			result.x = x;
+			result.y = y;
+
+			return cast(^T)&result.variant;
+		}
+
+		entities: [dynamic]^Entity;
+
+		rock := new_entity(Rock, 3, 5);
+
+		// Named arguments work too!
+		door := new_entity(T = Door, x = 3, y = 6);
+
+		// And named arguments can be any order
+		monster := new_entity(
+			y = 1,
+			x = 2,
+			T = Monster,
+		);
+
+		append(&entities, rock, door, monster);
+
+		fmt.println("Union");
+		for entity in entities {
+			match e in entity.variant {
+			case Rock:    fmt.println("Rock",    e.x, e.y);
+			case Door:    fmt.println("Door",    e.x, e.y);
+			case Monster: fmt.println("Monster", e.x, e.y);
+			}
+		}
+	}
+}
+
+
+implicit_polymorphic_assignment :: proc() {
+	yep :: proc(p: proc(x: int)) {
+		p(123);
+	}
+
+	frank :: proc(x: $T)    do fmt.println("frank ->", x);
+	tim   :: proc(x, y: $T) do fmt.println("tim ->", x, y);
+	yep(frank);
+	// yep(tim);
+}
+
+
+
+
+main :: proc() {
+/*
+	foo :: proc(x: i64,  y: f32) do fmt.println("#1", x, y);
+	foo :: proc(x: type, y: f32) do fmt.println("#2", type_info(x), y);
+	foo :: proc(x: type)         do fmt.println("#3", type_info(x));
+
+	f :: foo;
+
+	f(y = 3785.1546, x = 123);
+	f(x = int, y = 897.513);
+	f(x = f32);
+
+	general_stuff();
+	foreign_blocks();
+	default_arguments();
+	named_arguments();
+	default_return_values();
+	call_location();
+	explicit_parametric_polymorphic_procedures();
+	implicit_polymorphic_assignment();
+
+
+	// Command line argument(s)!
+	// -opt=0,1,2,3
+*/
+/*
+	program := "+ + * - /";
+	accumulator := 0;
+
+	for token in program {
+		match token {
+		case '+': accumulator += 1;
+		case '-': accumulator -= 1;
+		case '*': accumulator *= 2;
+		case '/': accumulator /= 2;
+		case: // Ignore everything else
+		}
+	}
+
+	fmt.printf("The program \"%s\" calculates the value %d\n",
+			   program, accumulator);
+*/
+}
@@ -0,0 +1,479 @@
+import win32 "core:sys/windows.odin";
+import "core:fmt.odin";
+import "core:os.odin";
+import "core:mem.odin";
+
+
+CANVAS_WIDTH  :: 128;
+CANVAS_HEIGHT :: 128;
+CANVAS_SCALE  :: 3;
+FRAME_TIME    :: 1.0/30.0;
+WINDOW_TITLE  :: "Punity\x00";
+
+_ :: compile_assert(CANVAS_WIDTH % 16 == 0);
+
+
+WINDOW_WIDTH  :: CANVAS_WIDTH  * CANVAS_SCALE;
+WINDOW_HEIGHT :: CANVAS_HEIGHT * CANVAS_SCALE;
+
+
+STACK_CAPACITY   :: 1<<20;
+STORAGE_CAPACITY :: 1<<20;
+
+DRAW_LIST_RESERVE :: 128;
+
+MAX_KEYS :: 256;
+
+Core :: struct {
+	stack:   ^Bank,
+	storage: ^Bank,
+
+	running:       bool,
+	key_modifiers: u32,
+	key_states:    [MAX_KEYS]u8,
+	key_deltas:    [MAX_KEYS]u8,
+
+	perf_frame,
+	perf_frame_inner,
+	perf_step,
+	perf_audio,
+	perf_blit,
+	perf_blit_cvt,
+	perf_blit_gdi: Perf_Span,
+
+	frame: i64,
+
+	canvas:    Canvas,
+	draw_list: ^Draw_List,
+}
+
+Perf_Span :: struct {
+	stamp: f64,
+	delta: f32,
+}
+
+Bank :: struct {
+	memory: []u8,
+	cursor: int,
+}
+
+Bank_State :: struct {
+	state: Bank,
+	bank: ^Bank,
+}
+
+
+Color :: struct #raw_union {
+	using channels: struct{a, b, g, r: u8},
+	rgba: u32,
+}
+
+Palette :: struct {
+	colors: [256]Color,
+	colors_count: u8,
+}
+
+
+Rect :: struct #raw_union {
+	using minmax: struct {min_x, min_y, max_x, max_y: int},
+	using pos: struct {left, top, right, bottom: int},
+	e: [4]int,
+}
+
+Bitmap :: struct {
+	pixels: []u8,
+	width:  int,
+	height: int,
+}
+
+Font :: struct {
+	using bitmap: Bitmap,
+	char_width:   int,
+	char_height:  int,
+}
+
+Canvas :: struct {
+	using bitmap: ^Bitmap,
+	palette:      Palette,
+	translate_x:  int,
+	translate_y:  int,
+	clip:         Rect,
+	font:         ^Font,
+}
+
+DrawFlag :: enum {
+	NONE   = 0,
+	FLIP_H = 1<<0,
+	FLIP_V = 1<<1,
+	MASK   = 1<<2,
+}
+
+Draw_Item :: struct {}
+Draw_List :: struct {
+	items: []Draw_Item,
+}
+
+Key :: enum {
+	Mod_Shift   = 0x0001,
+	Mod_Control = 0x0002,
+	Mod_Alt     = 0x0004,
+	Mod_Super   = 0x0008,
+
+
+	Unknown            =-1,
+	Invalid            =-2,
+
+
+	Lbutton            = 1,
+	Rbutton            = 2,
+	Cancel             = 3,
+	Mbutton            = 4,
+
+
+	Back               = 8,
+	Tab                = 9,
+	Clear              = 12,
+	Return             = 13,
+	Shift              = 16,
+	Control            = 17,
+	Menu               = 18,
+	Pause              = 19,
+	Capital            = 20,
+	Kana               = 0x15,
+	Hangeul            = 0x15,
+	Hangul             = 0x15,
+	Junja              = 0x17,
+	Final              = 0x18,
+	Hanja              = 0x19,
+	Kanji              = 0x19,
+	Escape             = 0x1B,
+	Convert            = 0x1C,
+	Non_Convert        = 0x1D,
+	Accept             = 0x1E,
+	Mode_Change        = 0x1F,
+	Space              = 32,
+	Prior              = 33,
+	Next               = 34,
+	End                = 35,
+	Home               = 36,
+	Left               = 37,
+	Up                 = 38,
+	Right              = 39,
+	Down               = 40,
+	Select             = 41,
+	Print              = 42,
+	Exec               = 43,
+	Snapshot           = 44,
+	Insert             = 45,
+	Delete             = 46,
+	Help               = 47,
+	Lwin               = 0x5B,
+	Rwin               = 0x5C,
+	Apps               = 0x5D,
+	Sleep              = 0x5F,
+	Numpad0            = 0x60,
+	Numpad1            = 0x61,
+	Numpad2            = 0x62,
+	Numpad3            = 0x63,
+	Numpad4            = 0x64,
+	Numpad5            = 0x65,
+	Numpad6            = 0x66,
+	Numpad7            = 0x67,
+	Numpad8            = 0x68,
+	Numpad9            = 0x69,
+	Multiply           = 0x6A,
+	Add                = 0x6B,
+	Separator          = 0x6C,
+	Subtract           = 0x6D,
+	Decimal            = 0x6E,
+	Divide             = 0x6F,
+	F1                 = 0x70,
+	F2                 = 0x71,
+	F3                 = 0x72,
+	F4                 = 0x73,
+	F5                 = 0x74,
+	F6                 = 0x75,
+	F7                 = 0x76,
+	F8                 = 0x77,
+	F9                 = 0x78,
+	F10                = 0x79,
+	F11                = 0x7A,
+	F12                = 0x7B,
+	F13                = 0x7C,
+	F14                = 0x7D,
+	F15                = 0x7E,
+	F16                = 0x7F,
+	F17                = 0x80,
+	F18                = 0x81,
+	F19                = 0x82,
+	F20                = 0x83,
+	F21                = 0x84,
+	F22                = 0x85,
+	F23                = 0x86,
+	F24                = 0x87,
+	Numlock            = 0x90,
+	Scroll             = 0x91,
+	Lshift             = 0xA0,
+	Rshift             = 0xA1,
+	Lcontrol           = 0xA2,
+	Rcontrol           = 0xA3,
+	Lmenu              = 0xA4,
+	Rmenu              = 0xA5,
+
+
+	Apostrophe         = 39,  /* ' */
+	Comma              = 44,  /* , */
+	Minus              = 45,  /* - */
+	Period             = 46,  /* . */
+	Slash              = 47,  /* / */
+	Num0               = 48,
+	Num1               = 49,
+	Num2               = 50,
+	Num3               = 51,
+	Num4               = 52,
+	Num5               = 53,
+	Num6               = 54,
+	Num7               = 55,
+	Num8               = 56,
+	Num9               = 57,
+	Semicolon          = 59,  /* ; */
+	Equal              = 61,  /* = */
+	A                  = 65,
+	B                  = 66,
+	C                  = 67,
+	D                  = 68,
+	E                  = 69,
+	F                  = 70,
+	G                  = 71,
+	H                  = 72,
+	I                  = 73,
+	J                  = 74,
+	K                  = 75,
+	L                  = 76,
+	M                  = 77,
+	N                  = 78,
+	O                  = 79,
+	P                  = 80,
+	Q                  = 81,
+	R                  = 82,
+	S                  = 83,
+	T                  = 84,
+	U                  = 85,
+	V                  = 86,
+	W                  = 87,
+	X                  = 88,
+	Y                  = 89,
+	Z                  = 90,
+	Left_Bracket       = 91,  /* [ */
+	Backslash          = 92,  /* \ */
+	Right_Bracket      = 93,  /* ] */
+	Grave_Accent       = 96,  /* ` */
+};
+
+
+key_down :: proc(k: Key) -> bool {
+	return _core.key_states[k] != 0;
+}
+
+key_pressed :: proc(k: Key) -> bool {
+	return (_core.key_deltas[k] != 0) && key_down(k);
+}
+
+
+
+
+win32_perf_count_freq := win32.get_query_performance_frequency();
+time_now :: proc() -> f64 {
+	assert(win32_perf_count_freq != 0);
+
+	counter: i64;
+	win32.query_performance_counter(&counter);
+	return f64(counter) / f64(win32_perf_count_freq);
+}
+
+_core: Core;
+
+run :: proc(user_init, user_step: proc(c: ^Core)) {
+	using win32;
+
+	_core.running = true;
+
+	win32_proc :: proc(hwnd: win32.Hwnd, msg: u32, wparam: win32.Wparam, lparam: win32.Lparam) -> win32.Lresult #no_inline #cc_c {
+		win32_app_key_mods :: proc() -> u32 {
+			mods: u32 = 0;
+
+			if is_key_down(Key_Code.Shift)   do mods |= u32(Key.Mod_Shift);
+			if is_key_down(Key_Code.Control) do mods |= u32(Key.Mod_Control);
+			if is_key_down(Key_Code.Menu)    do mods |= u32(Key.Mod_Alt);
+			if is_key_down(Key_Code.Lwin)    do mods |= u32(Key.Mod_Super);
+			if is_key_down(Key_Code.Rwin)    do mods |= u32(Key.Mod_Super);
+
+			return mods;
+		}
+
+		match msg {
+		case WM_KEYDOWN:
+			_core.key_modifiers = win32_app_key_mods();
+			if wparam < MAX_KEYS {
+				_core.key_states[wparam] = 1;
+				_core.key_deltas[wparam] = 1;
+			}
+			return 0;
+
+		case WM_KEYUP:
+			_core.key_modifiers = win32_app_key_mods();
+			if wparam < MAX_KEYS {
+				_core.key_states[wparam] = 0;
+				_core.key_deltas[wparam] = 1;
+			}
+			return 0;
+
+		case WM_CLOSE:
+			post_quit_message(0);
+			_core.running = false;
+			return 0;
+		}
+
+		return def_window_proc_a(hwnd, msg, wparam, lparam);
+	}
+
+
+	class_name := "Punity\x00";
+	window_class := Wnd_Class_Ex_A{
+		class_name = &class_name[0],
+		size       = size_of(Wnd_Class_Ex_A),
+		style      = CS_HREDRAW | CS_VREDRAW | CS_OWNDC,
+		instance   = Hinstance(get_module_handle_a(nil)),
+		wnd_proc   = win32_proc,
+		background = Hbrush(get_stock_object(BLACK_BRUSH)),
+	};
+
+	if register_class_ex_a(&window_class) == 0 {
+		fmt.fprintln(os.stderr, "register_class_ex_a failed");
+		return;
+	}
+
+	screen_width  := get_system_metrics(SM_CXSCREEN);
+	screen_height := get_system_metrics(SM_CYSCREEN);
+
+	rc: Rect;
+	rc.left   = (screen_width - WINDOW_WIDTH)   / 2;
+	rc.top    = (screen_height - WINDOW_HEIGHT) / 2;
+	rc.right  = rc.left + WINDOW_WIDTH;
+	rc.bottom = rc.top + WINDOW_HEIGHT;
+
+	style: u32 = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
+	assert(adjust_window_rect(&rc, style, 0) != 0);
+
+	wt := WINDOW_TITLE;
+
+	win32_window := create_window_ex_a(0,
+	                                   window_class.class_name,
+	                                   &wt[0],
+	                                   style,
+	                                   rc.left, rc.top,
+	                                   rc.right-rc.left, rc.bottom-rc.top,
+	                                   nil, nil, window_class.instance,
+	                                   nil);
+
+	if win32_window == nil {
+		fmt.fprintln(os.stderr, "create_window_ex_a failed");
+		return;
+	}
+
+
+	window_bmi: Bitmap_Info;
+	window_bmi.size        = size_of(Bitmap_Info_Header);
+	window_bmi.width       = CANVAS_WIDTH;
+	window_bmi.height      = CANVAS_HEIGHT;
+	window_bmi.planes      = 1;
+	window_bmi.bit_count   = 32;
+	window_bmi.compression = BI_RGB;
+
+
+	user_init(&_core);
+
+	show_window(win32_window, SW_SHOW);
+
+	window_buffer := make([]u32, CANVAS_WIDTH * CANVAS_HEIGHT);
+	defer free(window_buffer);
+
+	for _, i in window_buffer do window_buffer[i] = 0xff00ff;
+
+	dt: f64;
+	prev_time := time_now();
+	curr_time := time_now();
+	total_time: f64 = 0;
+	offset_x := 0;
+	offset_y := 0;
+
+	message: Msg;
+	for _core.running {
+		curr_time = time_now();
+		dt = curr_time - prev_time;
+		prev_time = curr_time;
+		total_time += dt;
+
+		offset_x += 1;
+		offset_y += 2;
+
+		{
+			buf: [128]u8;
+			s := fmt.bprintf(buf[..], "Punity: %.4f ms\x00", dt*1000);
+			win32.set_window_text_a(win32_window, &s[0]);
+		}
+
+
+		for y in 0..CANVAS_HEIGHT {
+			for x in 0..CANVAS_WIDTH {
+				g := (x % 32) * 8;
+				b := (y % 32) * 8;
+				window_buffer[x + y*CANVAS_WIDTH] = u32(g << 8 | b);
+			}
+		}
+
+		mem.zero(&_core.key_deltas[0], size_of(_core.key_deltas));
+
+		for peek_message_a(&message, nil, 0, 0, PM_REMOVE) != 0 {
+			if message.message == WM_QUIT {
+				_core.running = false;
+			}
+			translate_message(&message);
+			dispatch_message_a(&message);
+		}
+
+		user_step(&_core);
+
+		dc := get_dc(win32_window);
+		stretch_dibits(dc,
+		               0, 0, CANVAS_WIDTH * CANVAS_SCALE, CANVAS_HEIGHT * CANVAS_SCALE,
+		               0, 0, CANVAS_WIDTH, CANVAS_HEIGHT,
+		               &window_buffer[0],
+		               &window_bmi,
+		               DIB_RGB_COLORS,
+		               SRCCOPY);
+		release_dc(win32_window, dc);
+
+
+
+		delta := time_now() - prev_time;
+		if ms := i32((FRAME_TIME - delta) * 1000); ms > 0 {
+			win32.sleep(ms);
+		}
+
+		_core.frame += 1;
+	}
+}
+
+
+main :: proc() {
+	user_init :: proc(c: ^Core) {
+
+	}
+
+	user_step :: proc(c: ^Core) {
+
+	}
+
+	run(user_init, user_step);
+}
@@ -0,0 +1,11 @@
+@echo off
+setlocal EnableDelayedExpansion
+
+set file_input=%1
+set name=%1
+FOR %%f IN (name) do (
+   FOR %%g in (!%%f!) do set "%%f=%%~ng"
+)
+
+call clang -O2 -c %file_input% -o %name%.o ^
+	&& call ar %name%.o -rcs %name%.lib
@@ -1,8 +1,10 @@
@echo off

+rem call "C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat" x86 1> NUL
 rem call "C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat" x64 1> NUL
 call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x64 1> NUL
-rem call "C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat" x86 1> NUL
+rem call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" x86 1> NUL
+rem call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" x64 1> NUL
 set _NO_DEBUG_HEAP=1

 set path=w:\Odin\misc;%path%
@@ -1,4 +0,0 @@
-@echo off
-
-
-rem call clang -c -emit-llvm -DGB_IMPLEMENTATION -DGB_DEF=GB_DLL_EXPORT ..\src\gb\gb.h
@@ -1,104 +1,7 @@
 #define ARRAY_GROW_FORMULA(x) (2*(x) + 8)
 GB_STATIC_ASSERT(ARRAY_GROW_FORMULA(0) > 0);

-#define Array(Type_) struct { \
-	gbAllocator allocator; \
-	Type_ *     e; \
-	isize       count; \
-	isize       capacity; \
-}
-
-typedef Array(void) ArrayVoid;
-
-#define array_init_reserve(x_, allocator_, init_capacity_) do { \
-	void **e = cast(void **)&((x_)->e); \
-	GB_ASSERT((x_) != NULL); \
-	(x_)->allocator = (allocator_); \
-	(x_)->count = 0; \
-	(x_)->capacity = (init_capacity_); \
-	*e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_capacity_)); \
-} while (0)
-
-#define array_init_count(x_, allocator_, init_count_) do { \
-	void **e = cast(void **)&((x_)->e); \
-	GB_ASSERT((x_) != NULL); \
-	(x_)->allocator = (allocator_); \
-	(x_)->count = (init_count_); \
-	(x_)->capacity = (init_count_); \
-	*e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_count_)); \
-} while (0)
-
-#define array_init(x_, allocator_)        do { array_init_reserve(x_, allocator_, ARRAY_GROW_FORMULA(0)); } while (0)
-#define array_free(x_)                    do { gb_free((x_)->allocator, (x_)->e); } while (0)
-#define array_set_capacity(x_, capacity_) do { array__set_capacity((x_), (capacity_), gb_size_of(*(x_)->e)); } while (0)
-
-#define array_grow(x_, min_capacity_) do { \
-	isize new_capacity = ARRAY_GROW_FORMULA((x_)->capacity); \
-	if (new_capacity < (min_capacity_)) { \
-		new_capacity = (min_capacity_); \
-	} \
-	array_set_capacity(x_, new_capacity); \
-} while (0)
-
-#define array_add(x_, item_) do { \
-	if ((x_)->capacity < (x_)->count+1) { \
-		array_grow(x_, 0); \
-	} \
-	(x_)->e[(x_)->count++] = item_; \
-} while (0)
-
-#define array_pop(x_)   do { GB_ASSERT((x_)->count > 0); (x_)->count--; } while (0)
-#define array_clear(x_) do { (x_)->count = 0; } while (0)
-
-#define array_resize(x_, new_count_) do { \
-	if ((x_)->capacity < (new_count_)) { \
-		array_grow((x_), (new_count_)); \
-	} \
-	(x_)->count = (new_count_); \
-} while (0)
-
-#define array_reserve(x_, new_capacity_) do { \
-	if ((x_)->capacity < (new_capacity_)) { \
-		array_set_capacity((x_), (new_capacity_)); \
-	} \
-} while (0)
-
-
-
-
-void array__set_capacity(void *ptr, isize capacity, isize element_size) {
-	ArrayVoid *x = cast(ArrayVoid *)ptr;
-	GB_ASSERT(ptr != NULL);
-
-	GB_ASSERT(element_size > 0);
-
-	if (capacity == x->capacity) {
-		return;
-	}
-
-	if (capacity < x->count) {
-		if (x->capacity < capacity) {
-			isize new_capacity = ARRAY_GROW_FORMULA(x->capacity);
-			if (new_capacity < capacity) {
-				new_capacity = capacity;
-			}
-			array__set_capacity(ptr, new_capacity, element_size);
-		}
-		x->count = capacity;
-	}
-
-	{
-		// TODO(bill): Resize rather than copy and delete
-		void *new_data = gb_alloc(x->allocator, element_size*capacity);
-		gb_memmove(new_data, x->e, element_size*x->count);
-		gb_free(x->allocator, x->e);
-		x->capacity = capacity;
-		x->e = new_data;
-	}
-}
-
-
-#if 0
+#if 1
 template <typename T>
 struct Array {
 	gbAllocator allocator;
@@ -107,12 +10,16 @@ struct Array {
 	isize       capacity;

 	T &operator[](isize index) {
-		GB_ASSERT_MSG(0 <= index && index < count, "Index out of bounds");
+		#if !defined(NO_ARRAY_BOUNDS_CHECK)
+			GB_ASSERT_MSG(0 <= index && index < count, "Index %td is out of bounds ranges 0..<%td", index, count);
+		#endif
 		return data[index];
 	}

 	T const &operator[](isize index) const {
-		GB_ASSERT_MSG(0 <= index && index < count, "Index out of bounds");
+		#if !defined(NO_ARRAY_BOUNDS_CHECK)
+			GB_ASSERT_MSG(0 <= index && index < count, "Index %td is out of bounds ranges 0..<%td", index, count);
+		#endif
 		return data[index];
 	}
 };
@@ -128,7 +35,6 @@ template <typename T> void     array_reserve     (Array<T> *array, isize capacit
 template <typename T> void     array_resize      (Array<T> *array, isize count);
 template <typename T> void     array_set_capacity(Array<T> *array, isize capacity);

-
 template <typename T>
 void array_init(Array<T> *array, gbAllocator a, isize init_capacity) {
 	array->allocator = a;
@@ -158,7 +64,7 @@ Array<T> array_make(T *data, isize count, isize capacity) {

 template <typename T>
 void array_free(Array<T> *array) {
-	if (array->allocator.proc != NULL) {
+	if (array->allocator.proc != nullptr) {
 		gb_free(array->allocator, array->data);
 	}
 	array->count = 0;
@@ -220,7 +126,7 @@ void array_set_capacity(Array<T> *array, isize capacity) {
 		array_resize(array, capacity);
 	}

-	T *new_data = NULL;
+	T *new_data = nullptr;
 	if (capacity > 0) {
 		new_data = gb_alloc_array(array->allocator, T, capacity);
 		gb_memmove(new_data, array->data, gb_size_of(T) * array->capacity);
@@ -230,6 +136,97 @@ void array_set_capacity(Array<T> *array, isize capacity) {
 	array->capacity = capacity;
 }

-
-
 #endif
+
+#if 0
+#define Array(Type_) struct { \
+	gbAllocator allocator; \
+	Type_ *     e; \
+	isize       count; \
+	isize       capacity; \
+}
+
+typedef Array(void) ArrayVoid;
+
+#define array_init_reserve(x_, allocator_, init_capacity_) do { \
+	void **e = cast(void **)&((x_)->e); \
+	GB_ASSERT((x_) != nullptr); \
+	(x_)->allocator = (allocator_); \
+	(x_)->count = 0; \
+	(x_)->capacity = (init_capacity_); \
+	*e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_capacity_)); \
+} while (0)
+
+#define array_init_count(x_, allocator_, init_count_) do { \
+	void **e = cast(void **)&((x_)->e); \
+	GB_ASSERT((x_) != nullptr); \
+	(x_)->allocator = (allocator_); \
+	(x_)->count = (init_count_); \
+	(x_)->capacity = (init_count_); \
+	*e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_count_)); \
+} while (0)
+
+#define array_init(x_, allocator_)        do { array_init_reserve(x_, allocator_, ARRAY_GROW_FORMULA(0)); } while (0)
+#define array_free(x_)                    do { gb_free((x_)->allocator, (x_)->e); } while (0)
+#define array_set_capacity(x_, capacity_) do { array__set_capacity((x_), (capacity_), gb_size_of(*(x_)->e)); } while (0)
+
+#define array_grow(x_, min_capacity_) do { \
+	isize new_capacity = ARRAY_GROW_FORMULA((x_)->capacity); \
+	if (new_capacity < (min_capacity_)) { \
+		new_capacity = (min_capacity_); \
+	} \
+	array_set_capacity(x_, new_capacity); \
+} while (0)
+
+#define array_add(x_, item_) do { \
+	if ((x_)->capacity < (x_)->count+1) { \
+		array_grow(x_, 0); \
+	} \
+	(x_)->e[(x_)->count++] = item_; \
+} while (0)
+
+#define array_pop(x_)   do { GB_ASSERT((x_)->count > 0); (x_)->count--; } while (0)
+#define array_clear(x_) do { (x_)->count = 0; } while (0)
+
+#define array_resize(x_, new_count_) do { \
+	if ((x_)->capacity < (new_count_)) { \
+		array_grow((x_), (new_count_)); \
+	} \
+	(x_)->count = (new_count_); \
+} while (0)
+
+#define array_reserve(x_, new_capacity_) do { \
+	if ((x_)->capacity < (new_capacity_)) { \
+		array_set_capacity((x_), (new_capacity_)); \
+	} \
+} while (0)
+
+
+
+
+void array__set_capacity(void *ptr, isize capacity, isize element_size) {
+	ArrayVoid *x = cast(ArrayVoid *)ptr;
+	GB_ASSERT(ptr != nullptr);
+
+	GB_ASSERT(element_size > 0);
+
+	if (capacity == x->capacity) {
+		return;
+	}
+
+	if (capacity < x->count) {
+		if (x->capacity < capacity) {
+			isize new_capacity = ARRAY_GROW_FORMULA(x->capacity);
+			if (new_capacity < capacity) {
+				new_capacity = capacity;
+			}
+			array__set_capacity(ptr, new_capacity, element_size);
+		}
+		x->count = capacity;
+	}
+
+	x->e = gb_resize(x->allocator, x->e, element_size*x->capacity, element_size*capacity);
+	x->capacity = capacity;
+}
+#endif
+
@@ -1,172 +0,0 @@
-typedef struct BuildContext {
-	String ODIN_OS;      // target operating system
-	String ODIN_ARCH;    // target architecture
-	String ODIN_VENDOR;  // compiler vendor
-	String ODIN_VERSION; // compiler version
-	String ODIN_ROOT;    // Odin ROOT
-
-	i64    word_size;
-	i64    max_align;
-	String llc_flags;
-	String link_flags;
-	bool   is_dll;
-} BuildContext;
-
-// TODO(bill): OS dependent versions for the BuildContext
-// join_path
-// is_dir
-// is_file
-// is_abs_path
-// has_subdir
-
-String const WIN32_SEPARATOR_STRING = {cast(u8 *)"\\", 1};
-String const NIX_SEPARATOR_STRING   = {cast(u8 *)"/",  1};
-
-String odin_root_dir(void) {
-	String path = global_module_path;
-	Array(wchar_t) path_buf;
-	isize len, i;
-	gbTempArenaMemory tmp;
-	wchar_t *text;
-
-	if (global_module_path_set) {
-		return global_module_path;
-	}
-
-	array_init_count(&path_buf, heap_allocator(), 300);
-
-	len = 0;
-	for (;;) {
-		len = GetModuleFileNameW(NULL, &path_buf.e[0], path_buf.count);
-		if (len == 0) {
-			return make_string(NULL, 0);
-		}
-		if (len < path_buf.count) {
-			break;
-		}
-		array_resize(&path_buf, 2*path_buf.count + 300);
-	}
-
-	tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
-
-	text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1);
-
-	GetModuleFileNameW(NULL, text, len);
-	path = string16_to_string(heap_allocator(), make_string16(text, len));
-	for (i = path.len-1; i >= 0; i--) {
-		u8 c = path.text[i];
-		if (c == '/' || c == '\\') {
-			break;
-		}
-		path.len--;
-	}
-
-	global_module_path = path;
-	global_module_path_set = true;
-
-	gb_temp_arena_memory_end(tmp);
-
-	array_free(&path_buf);
-
-	return path;
-}
-
-String path_to_fullpath(gbAllocator a, String s) {
-	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
-	String16 string16 = string_to_string16(string_buffer_allocator, s);
-	String result = {0};
-
-	DWORD len = GetFullPathNameW(string16.text, 0, NULL, NULL);
-	if (len != 0) {
-		wchar_t *text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1);
-		GetFullPathNameW(string16.text, len, text, NULL);
-		text[len] = 0;
-		result = string16_to_string(a, make_string16(text, len));
-	}
-	gb_temp_arena_memory_end(tmp);
-	return result;
-}
-
-
-String get_fullpath_relative(gbAllocator a, String base_dir, String path) {
-	String res = {0};
-	isize str_len = base_dir.len+path.len;
-
-	u8 *str = gb_alloc_array(heap_allocator(), u8, str_len+1);
-
-	isize i = 0;
-	gb_memmove(str+i, base_dir.text, base_dir.len); i += base_dir.len;
-	gb_memmove(str+i, path.text, path.len);
-	str[str_len] = '\0';
-	res = path_to_fullpath(a, make_string(str, str_len));
-	gb_free(heap_allocator(), str);
-	return res;
-}
-
-String get_fullpath_core(gbAllocator a, String path) {
-	String module_dir = odin_root_dir();
-	String res = {0};
-
-	char core[] = "core/";
-	isize core_len = gb_size_of(core)-1;
-
-	isize str_len = module_dir.len + core_len + path.len;
-	u8 *str = gb_alloc_array(heap_allocator(), u8, str_len+1);
-
-	gb_memmove(str, module_dir.text, module_dir.len);
-	gb_memmove(str+module_dir.len, core, core_len);
-	gb_memmove(str+module_dir.len+core_len, path.text, path.len);
-	str[str_len] = '\0';
-
-	res = path_to_fullpath(a, make_string(str, str_len));
-	gb_free(heap_allocator(), str);
-	return res;
-}
-
-String get_filepath_extension(String path) {
-	isize dot = 0;
-	bool seen_slash = false;
-	for (isize i = path.len-1; i >= 0; i--) {
-		u8 c = path.text[i];
-		if (c == '/' || c == '\\') {
-			seen_slash = true;
-		}
-
-		if (c == '.') {
-			if (seen_slash) {
-				return str_lit("");
-			}
-
-			dot = i;
-			break;
-		}
-	}
-	return make_string(path.text, dot);
-}
-
-
-
-void init_build_context(BuildContext *bc) {
-	bc->ODIN_VENDOR  = str_lit("odin");
-	bc->ODIN_VERSION = str_lit("0.0.5e");
-	bc->ODIN_ROOT    = odin_root_dir();
-
-#if defined(GB_SYSTEM_WINDOWS)
-	bc->ODIN_OS      = str_lit("windows");
-	bc->ODIN_ARCH    = str_lit("amd64");
-#else
-#error Implement system
-#endif
-
-	if (str_eq(bc->ODIN_ARCH, str_lit("amd64"))) {
-		bc->word_size = 8;
-		bc->max_align = 16;
-		bc->llc_flags = str_lit("-march=x86-64 ");
-		bc->link_flags = str_lit("/machine:x64 ");
-	} else if (str_eq(bc->ODIN_ARCH, str_lit("x86"))) {
-		bc->word_size = 4;
-		bc->max_align = 8;
-		bc->llc_flags = str_lit("-march=x86 ");
-		bc->link_flags = str_lit("/machine:x86 ");
-	}
-}
@@ -0,0 +1,419 @@
+// This stores the information for the specify architecture of this build
+struct BuildContext {
+	// Constants
+	String ODIN_OS;      // target operating system
+	String ODIN_ARCH;    // target architecture
+	String ODIN_ENDIAN;  // target endian
+	String ODIN_VENDOR;  // compiler vendor
+	String ODIN_VERSION; // compiler version
+	String ODIN_ROOT;    // Odin ROOT
+	bool   ODIN_DEBUG;   // Odin in debug mode
+
+	// In bytes
+	i64    word_size; // Size of a pointer, must be >= 4
+	i64    max_align; // max alignment, must be >= 1 (and typically >= word_size)
+
+	String command;
+
+	String opt_flags;
+	String llc_flags;
+	String link_flags;
+	bool   is_dll;
+	bool   generate_docs;
+	i32    optimization_level;
+	bool   show_timings;
+	bool   keep_temp_files;
+	bool   no_bounds_check;
+
+	gbAffinity affinity;
+	isize      thread_count;
+};
+
+
+gb_global BuildContext build_context = {0};
+
+
+struct LibraryCollections {
+	String name;
+	String path;
+};
+
+gb_global Array<LibraryCollections> library_collections = {0};
+
+void add_library_collection(String name, String path) {
+	// TODO(bill): Check the path is valid and a directory
+	LibraryCollections lc = {name, string_trim_whitespace(path)};
+	array_add(&library_collections, lc);
+}
+
+bool find_library_collection_path(String name, String *path) {
+	for_array(i, library_collections) {
+		if (library_collections[i].name == name) {
+			if (path) *path = library_collections[i].path;
+			return true;
+		}
+	}
+	return false;
+}
+
+
+// TODO(bill): OS dependent versions for the BuildContext
+// join_path
+// is_dir
+// is_file
+// is_abs_path
+// has_subdir
+
+String const WIN32_SEPARATOR_STRING = {cast(u8 *)"\\", 1};
+String const NIX_SEPARATOR_STRING   = {cast(u8 *)"/",  1};
+
+#if defined(GB_SYSTEM_WINDOWS)
+String odin_root_dir(void) {
+	String path = global_module_path;
+	Array<wchar_t> path_buf;
+	isize len, i;
+	gbTempArenaMemory tmp;
+	wchar_t *text;
+
+	if (global_module_path_set) {
+		return global_module_path;
+	}
+
+	array_init_count(&path_buf, heap_allocator(), 300);
+
+	len = 0;
+	for (;;) {
+		len = GetModuleFileNameW(nullptr, &path_buf[0], cast(int)path_buf.count);
+		if (len == 0) {
+			return make_string(nullptr, 0);
+		}
+		if (len < path_buf.count) {
+			break;
+		}
+		array_resize(&path_buf, 2*path_buf.count + 300);
+	}
+	len += 1; // NOTE(bill): It needs an extra 1 for some reason
+
+	gb_mutex_lock(&string_buffer_mutex);
+	defer (gb_mutex_unlock(&string_buffer_mutex));
+
+	tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
+	defer (gb_temp_arena_memory_end(tmp));
+
+	text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1);
+
+	GetModuleFileNameW(nullptr, text, cast(int)len);
+	path = string16_to_string(heap_allocator(), make_string16(text, len));
+
+	for (i = path.len-1; i >= 0; i--) {
+		u8 c = path[i];
+		if (c == '/' || c == '\\') {
+			break;
+		}
+		path.len--;
+	}
+
+	global_module_path = path;
+	global_module_path_set = true;
+
+
+	array_free(&path_buf);
+
+	return path;
+}
+
+#elif defined(GB_SYSTEM_OSX)
+
+#include <mach-o/dyld.h>
+
+String odin_root_dir(void) {
+	String path = global_module_path;
+	Array<char> path_buf;
+	isize len, i;
+	gbTempArenaMemory tmp;
+	u8 *text;
+
+	if (global_module_path_set) {
+		return global_module_path;
+	}
+
+	array_init_count(&path_buf, heap_allocator(), 300);
+
+	len = 0;
+	for (;;) {
+		u32 sz = path_buf.count;
+		int res = _NSGetExecutablePath(&path_buf[0], &sz);
+		if(res == 0) {
+			len = sz;
+			break;
+		} else {
+			array_resize(&path_buf, sz + 1);
+		}
+	}
+
+	gb_mutex_lock(&string_buffer_mutex);
+	defer (gb_mutex_unlock(&string_buffer_mutex));
+
+	tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
+	defer (gb_temp_arena_memory_end(tmp));
+
+	text = gb_alloc_array(string_buffer_allocator, u8, len + 1);
+	gb_memmove(text, &path_buf[0], len);
+
+	path = make_string(text, len);
+	for (i = path.len-1; i >= 0; i--) {
+		u8 c = path[i];
+		if (c == '/' || c == '\\') {
+			break;
+		}
+		path.len--;
+	}
+
+	global_module_path = path;
+	global_module_path_set = true;
+
+
+	// array_free(&path_buf);
+
+	return path;
+}
+#else
+
+// NOTE: Linux / Unix is unfinished and not tested very well.
+#include <sys/stat.h>
+
+String odin_root_dir(void) {
+	String path = global_module_path;
+	Array<char> path_buf;
+	isize len, i;
+	gbTempArenaMemory tmp;
+	u8 *text;
+
+	if (global_module_path_set) {
+		return global_module_path;
+	}
+
+	array_init_count(&path_buf, heap_allocator(), 300);
+	defer (array_free(&path_buf));
+
+	len = 0;
+	for (;;) {
+		// This is not a 100% reliable system, but for the purposes
+		// of this compiler, it should be _good enough_.
+		// That said, there's no solid 100% method on Linux to get the program's
+		// path without checking this link. Sorry.
+		len = readlink("/proc/self/exe", &path_buf[0], path_buf.count);
+		if(len == 0) {
+			return make_string(nullptr, 0);
+		}
+		if (len < path_buf.count) {
+			break;
+		}
+		array_resize(&path_buf, 2*path_buf.count + 300);
+	}
+
+	gb_mutex_lock(&string_buffer_mutex);
+	defer (gb_mutex_unlock(&string_buffer_mutex));
+
+	tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
+	defer (gb_temp_arena_memory_end(tmp));
+
+	text = gb_alloc_array(string_buffer_allocator, u8, len + 1);
+
+	gb_memmove(text, &path_buf[0], len);
+
+	path = make_string(text, len);
+	for (i = path.len-1; i >= 0; i--) {
+		u8 c = path[i];
+		if (c == '/' || c == '\\') {
+			break;
+		}
+		path.len--;
+	}
+
+	global_module_path = path;
+	global_module_path_set = true;
+
+	return path;
+}
+#endif
+
+
+#if defined(GB_SYSTEM_WINDOWS)
+String path_to_fullpath(gbAllocator a, String s) {
+	String result = {};
+	gb_mutex_lock(&string_buffer_mutex);
+	defer (gb_mutex_unlock(&string_buffer_mutex));
+
+	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
+	String16 string16 = string_to_string16(string_buffer_allocator, s);
+
+	DWORD len = GetFullPathNameW(&string16[0], 0, nullptr, nullptr);
+	if (len != 0) {
+		wchar_t *text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1);
+		GetFullPathNameW(&string16[0], len, text, nullptr);
+		text[len] = 0;
+		result = string16_to_string(a, make_string16(text, len));
+	}
+	gb_temp_arena_memory_end(tmp);
+	return result;
+}
+#elif defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_UNIX)
+String path_to_fullpath(gbAllocator a, String s) {
+	char *p;
+	gb_mutex_lock(&string_buffer_mutex);
+	p = realpath(cast(char *)s.text, 0);
+	gb_mutex_unlock(&string_buffer_mutex);
+	if(p == nullptr) return String{};
+	return make_string_c(p);
+}
+#else
+#error Implement system
+#endif
+
+
+String get_fullpath_relative(gbAllocator a, String base_dir, String path) {
+	u8 *str = gb_alloc_array(heap_allocator(), u8, base_dir.len+1+path.len+1);
+	defer (gb_free(heap_allocator(), str));
+
+	isize i = 0;
+	gb_memmove(str+i, base_dir.text, base_dir.len); i += base_dir.len;
+	gb_memmove(str+i, "/", 1);                      i += 1;
+	gb_memmove(str+i, path.text,     path.len);     i += path.len;
+	str[i] = 0;
+
+	String res = make_string(str, i);
+	res = string_trim_whitespace(res);
+	return path_to_fullpath(a, res);
+}
+
+
+String get_fullpath_core(gbAllocator a, String path) {
+	String module_dir = odin_root_dir();
+
+	String core = str_lit("core/");
+
+	isize str_len = module_dir.len + core.len + path.len;
+	u8 *str = gb_alloc_array(heap_allocator(), u8, str_len+1);
+	defer (gb_free(heap_allocator(), str));
+
+	isize i = 0;
+	gb_memmove(str+i, module_dir.text, module_dir.len); i += module_dir.len;
+	gb_memmove(str+i, core.text, core.len);             i += core.len;
+	gb_memmove(str+i, path.text, path.len);             i += path.len;
+	str[i] = 0;
+
+	String res = make_string(str, i);
+	res = string_trim_whitespace(res);
+	return path_to_fullpath(a, res);
+}
+
+
+String const ODIN_VERSION = str_lit("0.8.1");
+String cross_compile_target = str_lit("");
+String cross_compile_lib_dir = str_lit("");
+
+void init_build_context(void) {
+	BuildContext *bc = &build_context;
+
+	gb_affinity_init(&bc->affinity);
+	if (bc->thread_count == 0) {
+		bc->thread_count = gb_max(bc->affinity.thread_count, 1);
+	}
+
+	bc->ODIN_VENDOR  = str_lit("odin");
+	bc->ODIN_VERSION = ODIN_VERSION;
+	bc->ODIN_ROOT    = odin_root_dir();
+
+#if defined(GB_SYSTEM_WINDOWS)
+	bc->ODIN_OS      = str_lit("windows");
+#elif defined(GB_SYSTEM_OSX)
+	bc->ODIN_OS      = str_lit("osx");
+#else
+	bc->ODIN_OS      = str_lit("linux");
+#endif
+
+	if (cross_compile_target.len) {
+		bc->ODIN_OS = cross_compile_target;
+	}
+
+#if defined(GB_ARCH_64_BIT)
+	bc->ODIN_ARCH = str_lit("amd64");
+#else
+	bc->ODIN_ARCH = str_lit("x86");
+#endif
+
+	{
+		u16 x = 1;
+		bool big = !(*cast(u8 *)&x);
+		bc->ODIN_ENDIAN = big ? str_lit("big") : str_lit("little");
+	}
+
+
+	// NOTE(zangent): The linker flags to set the build architecture are different
+	// across OSs. It doesn't make sense to allocate extra data on the heap
+	// here, so I just #defined the linker flags to keep things concise.
+	#if defined(GB_SYSTEM_WINDOWS)
+		#define LINK_FLAG_X64 "/machine:x64"
+		#define LINK_FLAG_X86 "/machine:x86"
+
+	#elif defined(GB_SYSTEM_OSX)
+		// NOTE(zangent): MacOS systems are x64 only, so ld doesn't have
+		// an architecture option. All compilation done on MacOS must be x64.
+		GB_ASSERT(bc->ODIN_ARCH == "amd64");
+
+		#define LINK_FLAG_X64 ""
+		#define LINK_FLAG_X86 ""
+	#else
+		// Linux, but also BSDs and the like.
+		// NOTE(zangent): When clang is swapped out with ld as the linker,
+		//   the commented flags here should be used. Until then, we'll have
+		//   to use alternative build flags made for clang.
+		/*
+			#define LINK_FLAG_X64 "-m elf_x86_64"
+			#define LINK_FLAG_X86 "-m elf_i386"
+		*/
+		#define LINK_FLAG_X64 "-arch x86-64"
+		#define LINK_FLAG_X86 "-arch x86"
+	#endif
+
+
+	if (bc->ODIN_ARCH == "amd64") {
+		bc->word_size = 8;
+		bc->max_align = 16;
+
+		bc->llc_flags = str_lit("-march=x86-64 ");
+		if (str_eq_ignore_case(cross_compile_target, str_lit("Essence"))) {
+			bc->link_flags = str_lit(" ");
+		} else {
+			bc->link_flags = str_lit(LINK_FLAG_X64 " ");
+		}
+	} else if (bc->ODIN_ARCH == "x86") {
+		bc->word_size = 4;
+		bc->max_align = 8;
+		bc->llc_flags = str_lit("-march=x86 ");
+		bc->link_flags = str_lit(LINK_FLAG_X86 " ");
+	} else {
+		gb_printf_err("This current architecture is not supported");
+		gb_exit(1);
+	}
+
+
+	isize opt_max = 1023;
+	char *opt_flags_string = gb_alloc_array(heap_allocator(), char, opt_max+1);
+	isize opt_len = 0;
+	bc->optimization_level = gb_clamp(bc->optimization_level, 0, 3);
+	if (bc->optimization_level != 0) {
+		opt_len = gb_snprintf(opt_flags_string, opt_max, "-O%d", bc->optimization_level);
+	} else {
+		opt_len = gb_snprintf(opt_flags_string, opt_max, "");
+	}
+	if (opt_len > 0) {
+		opt_len--;
+	}
+	bc->opt_flags = make_string(cast(u8 *)opt_flags_string, opt_len);
+
+
+	#undef LINK_FLAG_X64
+	#undef LINK_FLAG_X86
+}
@@ -0,0 +1,405 @@
+// checker.hpp
+
+struct Type;
+struct Entity;
+struct Scope;
+struct DeclInfo;
+struct AstFile;
+
+enum AddressingMode {
+	Addressing_Invalid,       // invalid addressing mode
+	Addressing_NoValue,       // no value (void in C)
+	Addressing_Value,         // computed value (rvalue)
+	Addressing_Immutable,     // immutable computed value (const rvalue)
+	Addressing_Variable,      // addressable variable (lvalue)
+	Addressing_Constant,      // constant
+	Addressing_Type,          // type
+	Addressing_Builtin,       // built-in procedure
+	Addressing_ProcGroup,     // procedure group (overloaded procedure)
+	Addressing_MapIndex,      // map index expression -
+	                          // 	lhs: acts like a Variable
+	                          // 	rhs: acts like OptionalOk
+	Addressing_OptionalOk,    // rhs: acts like a value with an optional boolean part (for existence check)
+};
+
+struct TypeAndValue {
+	AddressingMode mode;
+	Type *         type;
+	ExactValue     value;
+};
+
+
+// ExprInfo stores information used for "untyped" expressions
+struct ExprInfo {
+	AddressingMode mode;
+	Type *         type; // Type_Basic
+	ExactValue     value;
+	bool           is_lhs; // Debug info
+};
+
+gb_inline ExprInfo make_expr_info(AddressingMode mode, Type *type, ExactValue value, bool is_lhs) {
+	ExprInfo ei = {};
+	ei.is_lhs = is_lhs;
+	ei.mode   = mode;
+	ei.type   = type;
+	ei.value  = value;
+	return ei;
+}
+
+
+
+
+enum ExprKind {
+	Expr_Expr,
+	Expr_Stmt,
+};
+
+// Statements and Declarations
+enum StmtFlag {
+	Stmt_BreakAllowed       = 1<<0,
+	Stmt_ContinueAllowed    = 1<<1,
+	Stmt_FallthroughAllowed = 1<<2,
+
+	Stmt_CheckScopeDecls    = 1<<5,
+};
+
+struct BuiltinProc {
+	String   name;
+	isize    arg_count;
+	bool     variadic;
+	ExprKind kind;
+};
+enum BuiltinProcId {
+	BuiltinProc_Invalid,
+
+	BuiltinProc_len,
+	BuiltinProc_cap,
+
+	// BuiltinProc_new,
+	BuiltinProc_make,
+	// BuiltinProc_free,
+
+	// BuiltinProc_reserve,
+	// BuiltinProc_clear,
+	// BuiltinProc_append,
+	// BuiltinProc_delete,
+
+	BuiltinProc_size_of,
+	BuiltinProc_align_of,
+	BuiltinProc_offset_of,
+	BuiltinProc_type_of,
+	BuiltinProc_type_info_of,
+
+	BuiltinProc_compile_assert,
+
+	BuiltinProc_swizzle,
+
+	BuiltinProc_complex,
+	BuiltinProc_real,
+	BuiltinProc_imag,
+	BuiltinProc_conj,
+
+	// BuiltinProc_slice_ptr,
+	// BuiltinProc_slice_to_bytes,
+
+	BuiltinProc_expand_to_tuple,
+
+	BuiltinProc_min,
+	BuiltinProc_max,
+	BuiltinProc_abs,
+	BuiltinProc_clamp,
+
+	BuiltinProc_DIRECTIVE, // NOTE(bill): This is used for specialized hash-prefixed procedures
+
+	BuiltinProc_COUNT,
+};
+gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = {
+	{STR_LIT(""),                 0, false, Expr_Stmt},
+
+	{STR_LIT("len"),              1, false, Expr_Expr},
+	{STR_LIT("cap"),              1, false, Expr_Expr},
+
+	// {STR_LIT("new"),              1, false, Expr_Expr},
+	{STR_LIT("make"),             1, true,  Expr_Expr},
+	// {STR_LIT("free"),             1, false, Expr_Stmt},
+
+	// {STR_LIT("reserve"),          2, false, Expr_Stmt},
+	// {STR_LIT("clear"),            1, false, Expr_Stmt},
+	// {STR_LIT("append"),           1, true,  Expr_Expr},
+	// {STR_LIT("delete"),           2, false, Expr_Stmt},
+
+	{STR_LIT("size_of"),          1, false, Expr_Expr},
+	{STR_LIT("align_of"),         1, false, Expr_Expr},
+	{STR_LIT("offset_of"),        2, false, Expr_Expr},
+	{STR_LIT("type_of"),          1, false, Expr_Expr},
+	{STR_LIT("type_info_of"),     1, false, Expr_Expr},
+
+	{STR_LIT("compile_assert"),   1, false, Expr_Expr},
+
+	{STR_LIT("swizzle"),          1, true,  Expr_Expr},
+
+	{STR_LIT("complex"),          2, false, Expr_Expr},
+	{STR_LIT("real"),             1, false, Expr_Expr},
+	{STR_LIT("imag"),             1, false, Expr_Expr},
+	{STR_LIT("conj"),             1, false, Expr_Expr},
+
+	// {STR_LIT("slice_ptr"),        2, true,  Expr_Expr},
+	// {STR_LIT("slice_to_bytes"),   1, false, Expr_Expr},
+
+	{STR_LIT("expand_to_tuple"),  1, false, Expr_Expr},
+
+	{STR_LIT("min"),              2, false, Expr_Expr},
+	{STR_LIT("max"),              2, false, Expr_Expr},
+	{STR_LIT("abs"),              1, false, Expr_Expr},
+	{STR_LIT("clamp"),            3, false, Expr_Expr},
+
+	{STR_LIT(""),                 0, true,  Expr_Expr}, // DIRECTIVE
+};
+
+
+// Operand is used as an intermediate value whilst checking
+// Operands store an addressing mode, the expression being evaluated,
+// its type and node, and other specific information for certain
+// addressing modes
+// Its zero-value is a valid "invalid operand"
+struct Operand {
+	AddressingMode mode;
+	Type *         type;
+	ExactValue     value;
+	AstNode *      expr;
+	BuiltinProcId  builtin_id;
+	Entity *       proc_group;
+};
+
+
+struct BlockLabel {
+	String   name;
+	AstNode *label; //  AstNode_Label;
+};
+
+// DeclInfo is used to store information of certain declarations to allow for "any order" usage
+struct DeclInfo {
+	DeclInfo *        parent; // NOTE(bill): only used for procedure literals at the moment
+	Scope *           scope;
+
+	Entity **         entities;
+	isize             entity_count;
+
+	AstNode *         type_expr;
+	AstNode *         init_expr;
+	Array<AstNode *>  init_expr_list;
+	Array<AstNode *>  attributes;
+	AstNode *         proc_lit;      // AstNode_ProcLit
+	Type *            gen_proc_type; // Precalculated
+
+	PtrSet<Entity *>  deps;
+	Array<BlockLabel> labels;
+};
+
+// ProcedureInfo stores the information needed for checking a procedure
+
+
+struct ProcedureInfo {
+	AstFile *             file;
+	Token                 token;
+	DeclInfo *            decl;
+	Type *                type; // Type_Procedure
+	AstNode *             body; // AstNode_BlockStmt
+	u64                   tags;
+	bool                  generated_from_polymorphic;
+};
+
+
+struct Scope {
+	AstNode *        node;
+	Scope *          parent;
+	Scope *          prev, *next;
+	Scope *          first_child;
+	Scope *          last_child;
+	Map<Entity *>    elements; // Key: String
+	PtrSet<Entity *> implicit;
+
+	Array<Scope *>   shared;
+	Array<AstNode *> delayed_file_decls;
+	PtrSet<Scope *>  imported;
+	PtrSet<Scope *>  exported; // NOTE(bhall): Contains 'using import' too
+	bool             is_proc;
+	bool             is_global;
+	bool             is_file;
+	bool             is_init;
+	bool             is_struct;
+	bool             has_been_imported; // This is only applicable to file scopes
+	AstFile *        file;
+};
+
+
+
+
+struct EntityGraphNode;
+typedef PtrSet<EntityGraphNode *> EntityGraphNodeSet;
+
+struct EntityGraphNode {
+	Entity *     entity; // Procedure, Variable, Constant
+	EntityGraphNodeSet pred;
+	EntityGraphNodeSet succ;
+	isize        index; // Index in array/queue
+	isize        dep_count;
+};
+
+
+
+struct ImportGraphNode;
+typedef PtrSet<ImportGraphNode *> ImportGraphNodeSet;
+
+
+struct ImportGraphNode {
+	Scope *            scope;
+	String             path;
+	isize              file_id;
+	ImportGraphNodeSet pred;
+	ImportGraphNodeSet succ;
+	isize              index; // Index in array/queue
+	isize              dep_count;
+};
+
+
+struct ForeignContext {
+	AstNode *             curr_library;
+	ProcCallingConvention default_cc;
+	String                link_prefix;
+	bool                  in_export;
+};
+
+struct CheckerContext {
+	Scope *    file_scope;
+	Scope *    scope;
+	DeclInfo * decl;
+	u32        stmt_state_flags;
+	bool       in_defer; // TODO(bill): Actually handle correctly
+	String     proc_name;
+	Type *     type_hint;
+	DeclInfo * curr_proc_decl;
+	Type *     curr_proc_sig;
+	ForeignContext foreign_context;
+
+	bool       collect_delayed_decls;
+	bool       allow_polymorphic_types;
+	bool       no_polymorphic_errors;
+	Scope *    polymorphic_scope;
+};
+
+
+// CheckerInfo stores all the symbol information for a type-checked program
+struct CheckerInfo {
+	Map<TypeAndValue>     types;           // Key: AstNode * | Expression -> Type (and value)
+	Map<ExprInfo>         untyped;         // Key: AstNode * | Expression -> ExprInfo
+	Map<AstFile *>        files;           // Key: String (full path)
+	Map<Entity *>         foreigns;        // Key: String
+	Array<Entity *>       definitions;
+	Array<Entity *>       entities;
+	Array<DeclInfo *>     variable_init_order;
+
+	Map<Array<Entity *> > gen_procs;       // Key: AstNode * | Identifier -> Entity
+	Map<Array<Entity *> > gen_types;       // Key: Type *
+
+	Array<Type *>         type_info_types;
+	Map<isize>            type_info_map;   // Key: Type *
+
+	Scope *               init_scope;
+	Entity *              entry_point;
+	PtrSet<Entity *>      minimum_dependency_set;
+};
+
+struct Checker {
+	Parser *    parser;
+	CheckerInfo info;
+	gbMutex     mutex;
+
+	AstFile *                  curr_ast_file;
+	Scope *                    global_scope;
+	// NOTE(bill): Procedures to check
+	Array<ProcedureInfo>       procs;
+	Map<Scope *>               file_scopes; // Key: String (fullpath)
+	Array<ImportGraphNode *>   file_order;
+
+	gbAllocator                allocator;
+	gbArena                    arena;
+	gbArena                    tmp_arena;
+	gbAllocator                tmp_allocator;
+
+	CheckerContext             context;
+
+	Array<Type *>              proc_stack;
+	bool                       done_preload;
+
+	PtrSet<AstFile *>          checked_files;
+
+};
+
+
+
+HashKey hash_node     (AstNode *node)  { return hash_pointer(node); }
+HashKey hash_ast_file (AstFile *file)  { return hash_pointer(file); }
+HashKey hash_entity   (Entity *e)      { return hash_pointer(e); }
+HashKey hash_type     (Type *t)        { return hash_pointer(t); }
+HashKey hash_decl_info(DeclInfo *decl) { return hash_pointer(decl); }
+
+
+
+// CheckerInfo API
+TypeAndValue type_and_value_of_expr (CheckerInfo *i, AstNode *expr);
+Type *       type_of_expr           (CheckerInfo *i, AstNode *expr);
+Entity *     entity_of_ident        (CheckerInfo *i, AstNode *identifier);
+Entity *     implicit_entity_of_node(CheckerInfo *i, AstNode *clause);
+Scope *      scope_of_node          (CheckerInfo *i, AstNode *node);
+DeclInfo *   decl_info_of_ident     (CheckerInfo *i, AstNode *ident);
+DeclInfo *   decl_info_of_entity    (CheckerInfo *i, Entity * e);
+AstFile *    ast_file_of_filename   (CheckerInfo *i, String   filename);
+// IMPORTANT: Only to use once checking is done
+isize        type_info_index        (CheckerInfo *i, Type *   type, bool error_on_failure = true);
+
+
+Entity *current_scope_lookup_entity(Scope *s, String name);
+Entity *scope_lookup_entity        (Scope *s, String name);
+void    scope_lookup_parent_entity (Scope *s, String name, Scope **scope_, Entity **entity_);
+Entity *scope_insert_entity        (Scope *s, Entity *entity);
+
+
+ExprInfo *check_get_expr_info     (CheckerInfo *i, AstNode *expr);
+void      check_set_expr_info     (CheckerInfo *i, AstNode *expr, ExprInfo info);
+void      check_remove_expr_info  (CheckerInfo *i, AstNode *expr);
+void      add_untyped             (CheckerInfo *i, AstNode *expression, bool lhs, AddressingMode mode, Type *basic_type, ExactValue value);
+void      add_type_and_value      (CheckerInfo *i, AstNode *expression, AddressingMode mode, Type *type, ExactValue value);
+void      add_entity_use          (Checker *c, AstNode *identifier, Entity *entity);
+void      add_implicit_entity     (Checker *c, AstNode *node, Entity *e);
+void      add_entity_and_decl_info(Checker *c, AstNode *identifier, Entity *e, DeclInfo *d);
+
+void check_add_import_decl(Checker *c, AstNodeImportDecl *id);
+void check_add_export_decl(Checker *c, AstNodeExportDecl *ed);
+void check_add_foreign_import_decl(Checker *c, AstNode *decl);
+
+
+
+bool check_arity_match(Checker *c, AstNodeValueDecl *vd, bool is_global = false);
+void check_collect_entities(Checker *c, Array<AstNode *> nodes);
+void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws);
+void check_delayed_file_import_entity(Checker *c, AstNode *decl);
+
+
+struct AttributeContext {
+	String  link_name;
+	String  link_prefix;
+	isize   init_expr_list_count;
+	String  thread_local_model;
+};
+
+AttributeContext make_attribute_context(String link_prefix) {
+	AttributeContext ac = {};
+	ac.link_prefix = link_prefix;
+	return ac;
+}
+
+#define DECL_ATTRIBUTE_PROC(_name) bool _name(Checker *c, AstNode *elem, String name, ExactValue value, AttributeContext *ac)
+typedef DECL_ATTRIBUTE_PROC(DeclAttributeProc);
+
+void check_decl_attributes(Checker *c, Array<AstNode *> attributes, DeclAttributeProc *proc, AttributeContext *ac);
@@ -1,594 +0,0 @@
-bool check_is_terminating(AstNode *node);
-void check_stmt          (Checker *c, AstNode *node, u32 flags);
-void check_stmt_list     (Checker *c, AstNodeArray stmts, u32 flags);
-
-// NOTE(bill): `content_name` is for debugging and error messages
-Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String context_name) {
-	if (operand->mode == Addressing_Invalid ||
-	    operand->type == t_invalid ||
-	    e->type == t_invalid) {
-
-		if (operand->mode == Addressing_Builtin) {
-			gbString expr_str = expr_to_string(operand->expr);
-
-			// TODO(bill): is this a good enough error message?
-			error_node(operand->expr,
-			      "Cannot assign builtin procedure `%s` in %.*s",
-			      expr_str,
-			      LIT(context_name));
-
-			operand->mode = Addressing_Invalid;
-
-			gb_string_free(expr_str);
-		}
-
-
-		if (e->type == NULL) {
-			e->type = t_invalid;
-		}
-		return NULL;
-	}
-
-	if (e->type == NULL) {
-		// NOTE(bill): Use the type of the operand
-		Type *t = operand->type;
-		if (is_type_untyped(t)) {
-			if (t == t_invalid || is_type_untyped_nil(t)) {
-				error(e->token, "Use of untyped nil in %.*s", LIT(context_name));
-				e->type = t_invalid;
-				return NULL;
-			}
-			t = default_type(t);
-		}
-		e->type = t;
-	}
-
-	check_assignment(c, operand, e->type, context_name);
-	if (operand->mode == Addressing_Invalid) {
-		return NULL;
-	}
-
-	return e->type;
-}
-
-void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, AstNodeArray inits, String context_name) {
-	if ((lhs == NULL || lhs_count == 0) && inits.count == 0) {
-		return;
-	}
-
-	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena);
-
-	// NOTE(bill): If there is a bad syntax error, rhs > lhs which would mean there would need to be
-	// an extra allocation
-	Array(Operand) operands;
-	array_init_reserve(&operands, c->tmp_allocator, 2*lhs_count);
-
-	for_array(i, inits) {
-		AstNode *rhs = inits.e[i];
-		Operand o = {0};
-		check_multi_expr(c, &o, rhs);
-		if (o.type->kind != Type_Tuple) {
-			array_add(&operands, o);
-		} else {
-			TypeTuple *tuple = &o.type->Tuple;
-			for (isize j = 0; j < tuple->variable_count; j++) {
-				o.type = tuple->variables[j]->type;
-				array_add(&operands, o);
-			}
-		}
-	}
-
-	isize rhs_count = operands.count;
-	for_array(i, operands) {
-		if (operands.e[i].mode == Addressing_Invalid) {
-			rhs_count--;
-		}
-	}
-
-
-	isize max = gb_min(lhs_count, rhs_count);
-	for (isize i = 0; i < max; i++) {
-		check_init_variable(c, lhs[i], &operands.e[i], context_name);
-	}
-
-	if (rhs_count > 0 && lhs_count != rhs_count) {
-		error(lhs[0]->token, "Assignment count mismatch `%td` = `%td`", lhs_count, rhs_count);
-	}
-
-#if 0
-	if (lhs[0]->kind == Entity_Variable &&
-	    lhs[0]->Variable.is_let) {
-		if (lhs_count != rhs_count) {
-			error(lhs[0]->token, "`let` variables must be initialized, `%td` = `%td`", lhs_count, rhs_count);
-		}
-	}
-#endif
-
-	gb_temp_arena_memory_end(tmp);
-}
-
-void check_var_decl_node(Checker *c, AstNodeValueDecl *vd) {
-	GB_ASSERT(vd->is_var == true);
-	isize entity_count = vd->names.count;
-	isize entity_index = 0;
-	Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_count);
-
-	for_array(i, vd->names) {
-		AstNode *name = vd->names.e[i];
-		Entity *entity = NULL;
-		if (name->kind == AstNode_Ident) {
-			Token token = name->Ident;
-			String str = token.string;
-			Entity *found = NULL;
-			// NOTE(bill): Ignore assignments to `_`
-			if (str_ne(str, str_lit("_"))) {
-				found = current_scope_lookup_entity(c->context.scope, str);
-			}
-			if (found == NULL) {
-				entity = make_entity_variable(c->allocator, c->context.scope, token, NULL);
-				add_entity_definition(&c->info, name, entity);
-			} else {
-				TokenPos pos = found->token.pos;
-				error(token,
-				      "Redeclaration of `%.*s` in this scope\n"
-				      "\tat %.*s(%td:%td)",
-				      LIT(str), LIT(pos.file), pos.line, pos.column);
-				entity = found;
-			}
-		} else {
-			error_node(name, "A variable declaration must be an identifier");
-		}
-		if (entity == NULL) {
-			entity = make_entity_dummy_variable(c->allocator, c->global_scope, ast_node_token(name));
-		}
-		entities[entity_index++] = entity;
-	}
-
-	Type *init_type = NULL;
-	if (vd->type) {
-		init_type = check_type_extra(c, vd->type, NULL);
-		if (init_type == NULL) {
-			init_type = t_invalid;
-		}
-	}
-
-	for (isize i = 0; i < entity_count; i++) {
-		Entity *e = entities[i];
-		GB_ASSERT(e != NULL);
-		if (e->flags & EntityFlag_Visited) {
-			e->type = t_invalid;
-			continue;
-		}
-		e->flags |= EntityFlag_Visited;
-
-		if (e->type == NULL) {
-			e->type = init_type;
-		}
-	}
-
-	check_arity_match(c, vd);
-	check_init_variables(c, entities, entity_count, vd->values, str_lit("variable declaration"));
-
-	for_array(i, vd->names) {
-		if (entities[i] != NULL) {
-			add_entity(c, c->context.scope, vd->names.e[i], entities[i]);
-		}
-	}
-
-}
-
-
-
-void check_init_constant(Checker *c, Entity *e, Operand *operand) {
-	if (operand->mode == Addressing_Invalid ||
-	    operand->type == t_invalid ||
-	    e->type == t_invalid) {
-		if (e->type == NULL) {
-			e->type = t_invalid;
-		}
-		return;
-	}
-
-	if (operand->mode != Addressing_Constant) {
-		// TODO(bill): better error
-		gbString str = expr_to_string(operand->expr);
-		error_node(operand->expr, "`%s` is not a constant", str);
-		gb_string_free(str);
-		if (e->type == NULL) {
-			e->type = t_invalid;
-		}
-		return;
-	}
-	if (!is_type_constant_type(operand->type)) {
-		gbString type_str = type_to_string(operand->type);
-		error_node(operand->expr, "Invalid constant type: `%s`", type_str);
-		gb_string_free(type_str);
-		if (e->type == NULL) {
-			e->type = t_invalid;
-		}
-		return;
-	}
-
-	if (e->type == NULL) { // NOTE(bill): type inference
-		e->type = operand->type;
-	}
-
-	check_assignment(c, operand, e->type, str_lit("constant declaration"));
-	if (operand->mode == Addressing_Invalid) {
-		return;
-	}
-
-	e->Constant.value = operand->value;
-}
-
-void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def) {
-	GB_ASSERT(e->type == NULL);
-	Type *named = make_type_named(c->allocator, e->token.string, NULL, e);
-	named->Named.type_name = e;
-	if (def != NULL && def->kind == Type_Named) {
-		def->Named.base = named;
-	}
-	e->type = named;
-
-	// gb_printf_err("%.*s %p\n", LIT(e->token.string), e);
-
-	Type *bt = check_type_extra(c, type_expr, named);
-	named->Named.base = base_type(bt);
-	if (named->Named.base == t_invalid) {
-		// gb_printf("check_type_decl: %s\n", type_to_string(named));
-	}
-}
-
-void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, Type *named_type) {
-	GB_ASSERT(e->type == NULL);
-	GB_ASSERT(e->kind == Entity_Constant);
-
-	if (e->flags & EntityFlag_Visited) {
-		e->type = t_invalid;
-		return;
-	}
-	e->flags |= EntityFlag_Visited;
-
-	c->context.iota = e->Constant.value;
-	e->Constant.value = (ExactValue){0};
-
-	if (type_expr) {
-		Type *t = check_type(c, type_expr);
-		if (!is_type_constant_type(t)) {
-			gbString str = type_to_string(t);
-			error_node(type_expr, "Invalid constant type `%s`", str);
-			gb_string_free(str);
-			e->type = t_invalid;
-			c->context.iota = (ExactValue){0};
-			return;
-		}
-		e->type = t;
-	}
-
-	Operand operand = {0};
-	if (init != NULL) {
-		check_expr_or_type(c, &operand, init);
-	}
-	if (operand.mode == Addressing_Type) {
-		c->context.iota = (ExactValue){0};
-
-		e->Constant.value = (ExactValue){0};
-		e->kind = Entity_TypeName;
-
-		DeclInfo *d = c->context.decl;
-		d->type_expr = d->init_expr;
-		check_type_decl(c, e, d->type_expr, named_type);
-		return;
-	}
-
-	check_init_constant(c, e, &operand);
-	c->context.iota = (ExactValue){0};
-
-	if (operand.mode == Addressing_Invalid) {
-		error(e->token, "Illegal cyclic declaration");
-	}
-}
-
-
-
-bool are_signatures_similar_enough(Type *a_, Type *b_) {
-	GB_ASSERT(a_->kind == Type_Proc);
-	GB_ASSERT(b_->kind == Type_Proc);
-	TypeProc *a = &a_->Proc;
-	TypeProc *b = &b_->Proc;
-
-	if (a->param_count != b->param_count) {
-		return false;
-	}
-	if (a->result_count != b->result_count) {
-		return false;
-	}
-	for (isize i = 0; i < a->param_count; i++) {
-		Type *x = base_type(a->params->Tuple.variables[i]->type);
-		Type *y = base_type(b->params->Tuple.variables[i]->type);
-		if (is_type_pointer(x) && is_type_pointer(y)) {
-			continue;
-		}
-
-		if (!are_types_identical(x, y)) {
-			return false;
-		}
-	}
-	for (isize i = 0; i < a->result_count; i++) {
-		Type *x = base_type(a->results->Tuple.variables[i]->type);
-		Type *y = base_type(b->results->Tuple.variables[i]->type);
-		if (is_type_pointer(x) && is_type_pointer(y)) {
-			continue;
-		}
-
-		if (!are_types_identical(x, y)) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-void check_proc_lit(Checker *c, Entity *e, DeclInfo *d) {
-	GB_ASSERT(e->type == NULL);
-	if (d->proc_lit->kind != AstNode_ProcLit) {
-		// TOOD(bill): Better error message
-		error_node(d->proc_lit, "Expected a procedure to check");
-		return;
-	}
-
-	Type *proc_type = make_type_proc(c->allocator, e->scope, NULL, 0, NULL, 0, false, ProcCC_Odin);
-	e->type = proc_type;
-	ast_node(pd, ProcLit, d->proc_lit);
-
-	check_open_scope(c, pd->type);
-	check_procedure_type(c, proc_type, pd->type);
-
-	bool is_foreign      = (pd->tags & ProcTag_foreign)   != 0;
-	bool is_link_name    = (pd->tags & ProcTag_link_name) != 0;
-	bool is_export       = (pd->tags & ProcTag_export)    != 0;
-	bool is_inline       = (pd->tags & ProcTag_inline)    != 0;
-	bool is_no_inline    = (pd->tags & ProcTag_no_inline) != 0;
-
-	if ((d->scope->is_file || d->scope->is_global) &&
-	    str_eq(e->token.string, str_lit("main"))) {
-		if (proc_type != NULL) {
-			TypeProc *pt = &proc_type->Proc;
-			if (pt->param_count != 0 ||
-			    pt->result_count != 0) {
-				gbString str = type_to_string(proc_type);
-				error(e->token, "Procedure type of `main` was expected to be `proc()`, got %s", str);
-				gb_string_free(str);
-			}
-		}
-	}
-
-	if (is_inline && is_no_inline) {
-		error_node(pd->type, "You cannot apply both `inline` and `no_inline` to a procedure");
-	}
-
-	if (is_foreign && is_link_name) {
-		error_node(pd->type, "You cannot apply both `foreign` and `link_name` to a procedure");
-	} else if (is_foreign && is_export) {
-		error_node(pd->type, "You cannot apply both `foreign` and `export` to a procedure");
-	}
-
-
-	if (pd->body != NULL) {
-		if (is_foreign) {
-			error_node(pd->body, "A procedure tagged as `#foreign` cannot have a body");
-		}
-
-		if (proc_type->Proc.calling_convention != ProcCC_Odin) {
-			error_node(d->proc_lit, "An internal procedure may only have the Odin calling convention");
-			proc_type->Proc.calling_convention = ProcCC_Odin;
-		}
-
-		d->scope = c->context.scope;
-
-		GB_ASSERT(pd->body->kind == AstNode_BlockStmt);
-		check_procedure_later(c, c->curr_ast_file, e->token, d, proc_type, pd->body, pd->tags);
-	}
-
-	if (is_foreign) {
-		MapEntity *fp = &c->info.foreign_procs;
-		String name = e->token.string;
-		if (pd->foreign_name.len > 0) {
-			name = pd->foreign_name;
-		}
-
-		e->Procedure.is_foreign = true;
-		e->Procedure.foreign_name = name;
-
-		HashKey key = hash_string(name);
-		Entity **found = map_entity_get(fp, key);
-		if (found) {
-			Entity *f = *found;
-			TokenPos pos = f->token.pos;
-			Type *this_type = base_type(e->type);
-			Type *other_type = base_type(f->type);
-			if (!are_signatures_similar_enough(this_type, other_type)) {
-				error_node(d->proc_lit,
-				           "Redeclaration of #foreign procedure `%.*s` with different type signatures\n"
-				           "\tat %.*s(%td:%td)",
-				           LIT(name), LIT(pos.file), pos.line, pos.column);
-			}
-		} else {
-			map_entity_set(fp, key, e);
-		}
-	} else {
-		String name = e->token.string;
-		if (is_link_name) {
-			name = pd->link_name;
-		}
-
-		if (is_link_name || is_export) {
-			MapEntity *fp = &c->info.foreign_procs;
-
-			e->Procedure.link_name = name;
-
-			HashKey key = hash_string(name);
-			Entity **found = map_entity_get(fp, key);
-			if (found) {
-				Entity *f = *found;
-				TokenPos pos = f->token.pos;
-				// TODO(bill): Better error message?
-				error_node(d->proc_lit,
-				           "Non unique linking name for procedure `%.*s`\n"
-				           "\tother at %.*s(%td:%td)",
-				           LIT(name), LIT(pos.file), pos.line, pos.column);
-			} else {
-				map_entity_set(fp, key, e);
-			}
-		}
-	}
-
-	check_close_scope(c);
-}
-
-void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count, AstNode *type_expr, AstNode *init_expr) {
-	GB_ASSERT(e->type == NULL);
-	GB_ASSERT(e->kind == Entity_Variable);
-
-	if (e->flags & EntityFlag_Visited) {
-		e->type = t_invalid;
-		return;
-	}
-	e->flags |= EntityFlag_Visited;
-
-	if (type_expr != NULL) {
-		e->type = check_type_extra(c, type_expr, NULL);
-	}
-
-	if (init_expr == NULL) {
-		if (type_expr == NULL) {
-			e->type = t_invalid;
-		}
-		return;
-	}
-
-	if (entities == NULL || entity_count == 1) {
-		GB_ASSERT(entities == NULL || entities[0] == e);
-		Operand operand = {0};
-		check_expr(c, &operand, init_expr);
-		check_init_variable(c, e, &operand, str_lit("variable declaration"));
-	}
-
-	if (type_expr != NULL) {
-		for (isize i = 0; i < entity_count; i++) {
-			entities[i]->type = e->type;
-		}
-	}
-
-	AstNodeArray inits;
-	array_init_reserve(&inits, c->allocator, 1);
-	array_add(&inits, init_expr);
-	check_init_variables(c, entities, entity_count, inits, str_lit("variable declaration"));
-}
-
-
-void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) {
-	if (e->type != NULL) {
-		return;
-	}
-
-	if (d == NULL) {
-		DeclInfo **found = map_decl_info_get(&c->info.entities, hash_pointer(e));
-		if (found) {
-			d = *found;
-		} else {
-			// TODO(bill): Err here?
-			e->type = t_invalid;
-			set_base_type(named_type, t_invalid);
-			return;
-			// GB_PANIC("`%.*s` should been declared!", LIT(e->token.string));
-		}
-	}
-
-	CheckerContext prev = c->context;
-	c->context.scope = d->scope;
-	c->context.decl  = d;
-
-	switch (e->kind) {
-	case Entity_Variable:
-		check_var_decl(c, e, d->entities, d->entity_count, d->type_expr, d->init_expr);
-		break;
-	case Entity_Constant:
-		check_const_decl(c, e, d->type_expr, d->init_expr, named_type);
-		break;
-	case Entity_TypeName:
-		check_type_decl(c, e, d->type_expr, named_type);
-		break;
-	case Entity_Procedure:
-		check_proc_lit(c, e, d);
-		break;
-	}
-
-	c->context = prev;
-}
-
-
-
-void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNode *body) {
-	GB_ASSERT(body->kind == AstNode_BlockStmt);
-
-	CheckerContext old_context = c->context;
-	c->context.scope = decl->scope;
-	c->context.decl = decl;
-
-	GB_ASSERT(type->kind == Type_Proc);
-	if (type->Proc.param_count > 0) {
-		TypeTuple *params = &type->Proc.params->Tuple;
-		for (isize i = 0; i < params->variable_count; i++) {
-			Entity *e = params->variables[i];
-			GB_ASSERT(e->kind == Entity_Variable);
-			if (!(e->flags & EntityFlag_Anonymous)) {
-				continue;
-			}
-			String name = e->token.string;
-			Type *t = base_type(type_deref(e->type));
-			if (is_type_struct(t) || is_type_raw_union(t)) {
-				Scope **found = map_scope_get(&c->info.scopes, hash_pointer(t->Record.node));
-				GB_ASSERT(found != NULL);
-				for_array(i, (*found)->elements.entries) {
-					Entity *f = (*found)->elements.entries.e[i].value;
-					if (f->kind == Entity_Variable) {
-						Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type);
-						Entity *prev = scope_insert_entity(c->context.scope, uvar);
-						if (prev != NULL) {
-							error(e->token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string));
-							break;
-						}
-					}
-				}
-			} else {
-				error(e->token, "`using` can only be applied to variables of type struct or raw_union");
-				break;
-			}
-		}
-	}
-
-	push_procedure(c, type);
-	{
-		ast_node(bs, BlockStmt, body);
-		check_stmt_list(c, bs->stmts, 0);
-		if (type->Proc.result_count > 0) {
-			if (!check_is_terminating(body)) {
-				if (token.kind == Token_Ident) {
-					error(bs->close, "Missing return statement at the end of the procedure `%.*s`", LIT(token.string));
-				} else {
-					error(bs->close, "Missing return statement at the end of the procedure");
-				}
-			}
-		}
-	}
-	pop_procedure(c);
-
-
-	check_scope_usage(c, c->context.scope);
-
-	c->context = old_context;
-}
-
-
-
@@ -1,190 +0,0 @@
-typedef struct Scope Scope;
-typedef struct Checker Checker;
-typedef struct Type Type;
-typedef enum BuiltinProcId BuiltinProcId;
-typedef enum ImplicitValueId ImplicitValueId;
-
-#define ENTITY_KINDS \
-	ENTITY_KIND(Invalid) \
-	ENTITY_KIND(Constant) \
-	ENTITY_KIND(Variable) \
-	ENTITY_KIND(TypeName) \
-	ENTITY_KIND(Procedure) \
-	ENTITY_KIND(Builtin) \
-	ENTITY_KIND(ImportName) \
-	ENTITY_KIND(Nil) \
-	ENTITY_KIND(ImplicitValue) \
-	ENTITY_KIND(Count)
-
-typedef enum EntityKind {
-#define ENTITY_KIND(k) GB_JOIN2(Entity_, k),
-	ENTITY_KINDS
-#undef ENTITY_KIND
-} EntityKind;
-
-String const entity_strings[] = {
-#define ENTITY_KIND(k) {cast(u8 *)#k, gb_size_of(#k)-1},
-	ENTITY_KINDS
-#undef ENTITY_KIND
-};
-
-typedef enum EntityFlag {
-	EntityFlag_Visited    = 1<<0,
-	EntityFlag_Used       = 1<<1,
-	EntityFlag_Anonymous  = 1<<2,
-	EntityFlag_Field      = 1<<3,
-	EntityFlag_Param      = 1<<4,
-	EntityFlag_VectorElem = 1<<5,
-} EntityFlag;
-
-typedef struct Entity Entity;
-struct Entity {
-	EntityKind kind;
-	u32        flags;
-	Token      token;
-	Scope *    scope;
-	Type *     type;
-	AstNode *  identifier; // Can be NULL
-
-	// TODO(bill): Cleanup how `using` works for entities
-	Entity *   using_parent;
-	AstNode *  using_expr;
-
-	union {
-		struct {
-			ExactValue value;
-		} Constant;
-		struct {
-			i32  field_index;
-			i32  field_src_index;
-			bool is_immutable;
-		} Variable;
-		i32 TypeName;
-		struct {
-			bool   is_foreign;
-			String foreign_name;
-			String link_name;
-			u64    tags;
-		} Procedure;
-		struct {
-			BuiltinProcId id;
-		} Builtin;
-		struct {
-			String path;
-			String name;
-			Scope *scope;
-			bool   used;
-		} ImportName;
-		i32 Nil;
-		struct {
-			// TODO(bill): Should this be a user-level construct rather than compiler-level?
-			ImplicitValueId id;
-			Entity *        backing;
-		} ImplicitValue;
-	};
-};
-
-
-Entity *e_iota = NULL;
-
-
-Entity *alloc_entity(gbAllocator a, EntityKind kind, Scope *scope, Token token, Type *type) {
-	Entity *entity = gb_alloc_item(a, Entity);
-	entity->kind   = kind;
-	entity->scope  = scope;
-	entity->token  = token;
-	entity->type   = type;
-	return entity;
-}
-
-Entity *make_entity_variable(gbAllocator a, Scope *scope, Token token, Type *type) {
-	Entity *entity = alloc_entity(a, Entity_Variable, scope, token, type);
-	return entity;
-}
-
-Entity *make_entity_using_variable(gbAllocator a, Entity *parent, Token token, Type *type) {
-	GB_ASSERT(parent != NULL);
-	Entity *entity = alloc_entity(a, Entity_Variable, parent->scope, token, type);
-	entity->using_parent = parent;
-	entity->flags |= EntityFlag_Anonymous;
-	return entity;
-}
-
-
-Entity *make_entity_constant(gbAllocator a, Scope *scope, Token token, Type *type, ExactValue value) {
-	Entity *entity = alloc_entity(a, Entity_Constant, scope, token, type);
-	entity->Constant.value = value;
-	return entity;
-}
-
-Entity *make_entity_type_name(gbAllocator a, Scope *scope, Token token, Type *type) {
-	Entity *entity = alloc_entity(a, Entity_TypeName, scope, token, type);
-	return entity;
-}
-
-Entity *make_entity_param(gbAllocator a, Scope *scope, Token token, Type *type, bool anonymous) {
-	Entity *entity = make_entity_variable(a, scope, token, type);
-	entity->flags |= EntityFlag_Used;
-	entity->flags |= EntityFlag_Anonymous*(anonymous != 0);
-	entity->flags |= EntityFlag_Param;
-	return entity;
-}
-
-Entity *make_entity_field(gbAllocator a, Scope *scope, Token token, Type *type, bool anonymous, i32 field_src_index) {
-	Entity *entity = make_entity_variable(a, scope, token, type);
-	entity->Variable.field_src_index = field_src_index;
-	entity->Variable.field_index = field_src_index;
-	entity->flags |= EntityFlag_Field;
-	entity->flags |= EntityFlag_Anonymous*(anonymous != 0);
-	return entity;
-}
-
-Entity *make_entity_vector_elem(gbAllocator a, Scope *scope, Token token, Type *type, i32 field_src_index) {
-	Entity *entity = make_entity_variable(a, scope, token, type);
-	entity->Variable.field_src_index = field_src_index;
-	entity->Variable.field_index = field_src_index;
-	entity->flags |= EntityFlag_Field;
-	entity->flags |= EntityFlag_VectorElem;
-	return entity;
-}
-
-Entity *make_entity_procedure(gbAllocator a, Scope *scope, Token token, Type *signature_type, u64 tags) {
-	Entity *entity = alloc_entity(a, Entity_Procedure, scope, token, signature_type);
-	entity->Procedure.tags = tags;
-	return entity;
-}
-
-Entity *make_entity_builtin(gbAllocator a, Scope *scope, Token token, Type *type, BuiltinProcId id) {
-	Entity *entity = alloc_entity(a, Entity_Builtin, scope, token, type);
-	entity->Builtin.id = id;
-	return entity;
-}
-
-Entity *make_entity_import_name(gbAllocator a, Scope *scope, Token token, Type *type,
-                                String path, String name, Scope *import_scope) {
-	Entity *entity = alloc_entity(a, Entity_ImportName, scope, token, type);
-	entity->ImportName.path = path;
-	entity->ImportName.name = name;
-	entity->ImportName.scope = import_scope;
-	return entity;
-}
-
-Entity *make_entity_nil(gbAllocator a, String name, Type *type) {
-	Token token = make_token_ident(name);
-	Entity *entity = alloc_entity(a, Entity_Nil, NULL, token, type);
-	return entity;
-}
-
-Entity *make_entity_implicit_value(gbAllocator a, String name, Type *type, ImplicitValueId id) {
-	Token token = make_token_ident(name);
-	Entity *entity = alloc_entity(a, Entity_ImplicitValue, NULL, token, type);
-	entity->ImplicitValue.id = id;
-	return entity;
-}
-
-
-Entity *make_entity_dummy_variable(gbAllocator a, Scope *scope, Token token) {
-	token.string = str_lit("_");
-	return make_entity_variable(a, scope, token, NULL);
-}
-
@@ -1,136 +0,0 @@
-#define GB_NO_DEFER
-#define GB_IMPLEMENTATION
-#include "gb/gb.h"
-
-gbAllocator heap_allocator(void) {
-	return gb_heap_allocator();
-}
-
-#include "string.c"
-#include "array.c"
-
-gb_global String global_module_path = {0};
-gb_global bool global_module_path_set = false;
-
-
-i64 next_pow2(i64 n) {
-	if (n <= 0) {
-		return 0;
-	}
-	n--;
-	n |= n >> 1;
-	n |= n >> 2;
-	n |= n >> 4;
-	n |= n >> 8;
-	n |= n >> 16;
-	n |= n >> 32;
-	n++;
-	return n;
-}
-
-i64 prev_pow2(i64 n) {
-	if (n <= 0) {
-		return 0;
-	}
-	n |= n >> 1;
-	n |= n >> 2;
-	n |= n >> 4;
-	n |= n >> 8;
-	n |= n >> 16;
-	n |= n >> 32;
-	return n - (n >> 1);
-}
-
-i16 f32_to_f16(f32 value) {
-	union { u32 i; f32 f; } v;
-	i32 i, s, e, m;
-
-	v.f = value;
-	i = (i32)v.i;
-
-	s =  (i >> 16) & 0x00008000;
-	e = ((i >> 23) & 0x000000ff) - (127 - 15);
-	m =   i        & 0x007fffff;
-
-
-	if (e <= 0) {
-		if (e < -10) return cast(i16)s;
-		m = (m | 0x00800000) >> (1 - e);
-
-		if (m & 0x00001000)
-			m += 0x00002000;
-
-		return cast(i16)(s | (m >> 13));
-	} else if (e == 0xff - (127 - 15)) {
-		if (m == 0) {
-			return cast(i16)(s | 0x7c00); /* NOTE(bill): infinity */
-		} else {
-			/* NOTE(bill): NAN */
-			m >>= 13;
-			return cast(i16)(s | 0x7c00 | m | (m == 0));
-		}
-	} else {
-		if (m & 0x00001000) {
-			m += 0x00002000;
-			if (m & 0x00800000) {
-				m = 0;
-				e += 1;
-			}
-		}
-
-		if (e > 30) {
-			float volatile f = 1e12f;
-			int j;
-			for (j = 0; j < 10; j++) {
-				f *= f; /* NOTE(bill): Cause overflow */
-			}
-
-			return cast(i16)(s | 0x7c00);
-		}
-
-		return cast(i16)(s | (e << 10) | (m >> 13));
-	}
-}
-
-
-
-#define for_array(index_, array_) for (isize index_ = 0; index_ < (array_).count; index_++)
-
-
-// Doubly Linked Lists
-
-#define DLIST_SET(curr_element, next_element)  do { \
-	(curr_element)->next = (next_element);             \
-	(curr_element)->next->prev = (curr_element);       \
-	(curr_element) = (curr_element)->next;             \
-} while (0)
-
-#define DLIST_APPEND(root_element, curr_element, next_element) do { \
-	if ((root_element) == NULL) { \
-		(root_element) = (curr_element) = (next_element); \
-	} else { \
-		DLIST_SET(curr_element, next_element); \
-	} \
-} while (0)
-
-////////////////////////////////////////////////////////////////
-//
-// Generic Data Structures
-//
-////////////////////////////////////////////////////////////////
-
-
-#define MAP_TYPE String
-#define MAP_PROC map_string_
-#define MAP_NAME MapString
-#include "map.c"
-
-#define MAP_TYPE bool
-#define MAP_PROC map_bool_
-#define MAP_NAME MapBool
-#include "map.c"
-
-#define MAP_TYPE isize
-#define MAP_PROC map_isize_
-#define MAP_NAME MapIsize
-#include "map.c"
@@ -0,0 +1,685 @@
+#if defined(GB_SYSTEM_UNIX)
+// Required for intrinsics on GCC
+#include <xmmintrin.h>
+#endif
+
+#define GB_IMPLEMENTATION
+#include "gb/gb.h"
+
+
+#include <wchar.h>
+#include <stdio.h>
+
+#include <math.h>
+
+gb_inline i64 align_formula(i64 size, i64 align) {
+	if (align > 0) {
+		i64 result = size + align-1;
+		return result - result%align;
+	}
+	return size;
+}
+gb_inline isize align_formula_isize(isize size, isize align) {
+	if (align > 0) {
+		isize result = size + align-1;
+		return result - result%align;
+	}
+	return size;
+}
+
+GB_ALLOCATOR_PROC(heap_allocator_proc);
+
+gbAllocator heap_allocator(void) {
+	gbAllocator a;
+	a.proc = heap_allocator_proc;
+	a.data = NULL;
+	return a;
+}
+
+
+GB_ALLOCATOR_PROC(heap_allocator_proc) {
+	void *ptr = NULL;
+	gb_unused(allocator_data);
+	gb_unused(old_size);
+
+
+
+// TODO(bill): Throughly test!
+	switch (type) {
+#if defined(GB_COMPILER_MSVC)
+	#if 0
+	case gbAllocation_Alloc:
+		ptr = _aligned_malloc(size, alignment);
+		if (flags & gbAllocatorFlag_ClearToZero) {
+			gb_zero_size(ptr, size);
+		}
+		break;
+	case gbAllocation_Free:
+		_aligned_free(old_memory);
+		break;
+	case gbAllocation_Resize:
+		ptr = _aligned_realloc(old_memory, size, alignment);
+		break;
+	#else
+	case gbAllocation_Alloc:
+		// TODO(bill): Make sure this is aligned correctly
+		ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, align_formula_isize(size, alignment));
+		break;
+	case gbAllocation_Free:
+		HeapFree(GetProcessHeap(), 0, old_memory);
+		break;
+	case gbAllocation_Resize:
+		ptr = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, old_memory, align_formula_isize(size, alignment));
+		break;
+	#endif
+
+#elif defined(GB_SYSTEM_LINUX)
+	// TODO(bill): *nix version that's decent
+	case gbAllocation_Alloc: {
+		ptr = aligned_alloc(alignment, size);
+		// ptr = malloc(size+alignment);
+
+		if (flags & gbAllocatorFlag_ClearToZero) {
+			gb_zero_size(ptr, size);
+		}
+		break;
+	}
+
+	case gbAllocation_Free: {
+		free(old_memory);
+		break;
+	}
+
+	case gbAllocation_Resize: {
+		// ptr = realloc(old_memory, size);
+		ptr = gb_default_resize_align(heap_allocator(), old_memory, old_size, size, alignment);
+		break;
+	}
+#else
+	// TODO(bill): *nix version that's decent
+	case gbAllocation_Alloc: {
+		posix_memalign(&ptr, alignment, size);
+
+		if (flags & gbAllocatorFlag_ClearToZero) {
+			gb_zero_size(ptr, size);
+		}
+		break;
+	}
+
+	case gbAllocation_Free: {
+		free(old_memory);
+		break;
+	}
+
+	case gbAllocation_Resize: {
+		ptr = gb_default_resize_align(heap_allocator(), old_memory, old_size, size, alignment);
+		break;
+	}
+#endif
+
+	case gbAllocation_FreeAll:
+		break;
+	}
+
+	return ptr;
+}
+
+#include "unicode.cpp"
+#include "string.cpp"
+#include "array.cpp"
+#include "murmurhash3.cpp"
+
+#define for_array(index_, array_) for (isize index_ = 0; index_ < (array_).count; index_++)
+
+
+u64 fnv64a(void const *data, isize len) {
+	u8 const *bytes = cast(u8 const *)data;
+	u64 h = 0xcbf29ce484222325ull;
+	for (isize i = 0; i < len; i++) {
+		u64 b = cast(u64)bytes[i];
+		h = (h ^ b) * 0x100000001b3ull;
+	}
+	return h;
+}
+
+u64 u64_digit_value(Rune r) {
+	if ('0' <= r && r <= '9') {
+		return r - '0';
+	} else if ('a' <= r && r <= 'f') {
+		return r - 'a' + 10;
+	} else if ('A' <= r && r <= 'F') {
+		return r - 'A' + 10;
+	}
+	return 16; // NOTE(bill): Larger than highest possible
+}
+
+
+u64 u64_from_string(String string) {
+	u64 base = 10;
+	bool has_prefix = false;
+	if (string.len > 2 && string[0] == '0') {
+		switch (string[1]) {
+		case 'b': base = 2;  has_prefix = true; break;
+		case 'o': base = 8;  has_prefix = true; break;
+		case 'd': base = 10; has_prefix = true; break;
+		case 'z': base = 12; has_prefix = true; break;
+		case 'x': base = 16; has_prefix = true; break;
+		}
+	}
+
+	u8 *text = string.text;
+	isize len = string.len;
+	if (has_prefix) {
+		text += 2;
+		len -= 2;
+	}
+
+	u64 result = 0ull;
+	for (isize i = 0; i < len; i++) {
+		Rune r = cast(Rune)text[i];
+		if (r == '_') {
+			continue;
+		}
+		u64 v = u64_digit_value(r);
+		if (v >= base) {
+			break;
+		}
+		result *= base;
+		result += v;
+	}
+	return result;
+}
+
+String u64_to_string(u64 v, char *out_buf, isize out_buf_len) {
+	char buf[200] = {0};
+	isize i = gb_size_of(buf);
+
+	u64 b = 10;
+	while (v >= b) {
+		buf[--i] = gb__num_to_char_table[v%b];
+		v /= b;
+	}
+	buf[--i] = gb__num_to_char_table[v%b];
+
+	isize len = gb_min(gb_size_of(buf)-i, out_buf_len);
+	gb_memcopy(out_buf, &buf[i], len);
+	return make_string(cast(u8 *)out_buf, len);
+}
+String i64_to_string(i64 a, char *out_buf, isize out_buf_len) {
+	char buf[200] = {0};
+	isize i = gb_size_of(buf);
+	bool negative = false;
+	if (a < 0) {
+		negative = true;
+		a = -a;
+	}
+
+	u64 v = cast(u64)a;
+	u64 b = 10;
+	while (v >= b) {
+		buf[--i] = gb__num_to_char_table[v%b];
+		v /= b;
+	}
+	buf[--i] = gb__num_to_char_table[v%b];
+
+	if (negative) {
+		buf[--i] = '-';
+	}
+
+	isize len = gb_min(gb_size_of(buf)-i, out_buf_len);
+	gb_memcopy(out_buf, &buf[i], len);
+	return make_string(cast(u8 *)out_buf, len);
+}
+
+
+
+
+
+#include "map.cpp"
+#include "ptr_set.cpp"
+#include "string_set.cpp"
+#include "priority_queue.cpp"
+
+
+
+gb_global String global_module_path = {0};
+gb_global bool global_module_path_set = false;
+
+gb_global gbScratchMemory scratch_memory = {0};
+
+void init_scratch_memory(isize size) {
+	void *memory = gb_alloc(heap_allocator(), size);
+	gb_scratch_memory_init(&scratch_memory, memory, size);
+}
+
+gbAllocator scratch_allocator(void) {
+	return gb_scratch_allocator(&scratch_memory);
+}
+
+struct Pool {
+	isize       memblock_size;
+	isize       out_of_band_size;
+	isize       alignment;
+
+	Array<u8 *> unused_memblock;
+	Array<u8 *> used_memblock;
+	Array<u8 *> out_of_band_allocations;
+
+	u8 *        current_memblock;
+	u8 *        current_pos;
+	isize       bytes_left;
+
+	gbAllocator block_allocator;
+};
+
+enum {
+	POOL_BUCKET_SIZE_DEFAULT      = 65536,
+	POOL_OUT_OF_BAND_SIZE_DEFAULT = 6554,
+};
+
+void pool_init(Pool *pool,
+               isize memblock_size = POOL_BUCKET_SIZE_DEFAULT,
+               isize out_of_band_size = POOL_OUT_OF_BAND_SIZE_DEFAULT,
+               isize alignment = 8,
+               gbAllocator block_allocator = heap_allocator(),
+               gbAllocator array_allocator = heap_allocator()) {
+	pool->memblock_size = memblock_size;
+	pool->out_of_band_size = out_of_band_size;
+	pool->alignment = alignment;
+	pool->block_allocator = block_allocator;
+
+	array_init(&pool->unused_memblock,         array_allocator);
+	array_init(&pool->used_memblock,           array_allocator);
+	array_init(&pool->out_of_band_allocations, array_allocator);
+}
+
+void pool_free_all(Pool *p) {
+	if (p->current_memblock != nullptr) {
+		array_add(&p->unused_memblock, p->current_memblock);
+		p->current_memblock = nullptr;
+	}
+
+	for_array(i, p->used_memblock) {
+		array_add(&p->unused_memblock, p->used_memblock[i]);
+	}
+	array_clear(&p->unused_memblock);
+
+	for_array(i, p->out_of_band_allocations) {
+		gb_free(p->block_allocator, p->out_of_band_allocations[i]);
+	}
+	array_clear(&p->out_of_band_allocations);
+}
+
+void pool_destroy(Pool *p) {
+	pool_free_all(p);
+
+	for_array(i, p->unused_memblock) {
+		gb_free(p->block_allocator, p->unused_memblock[i]);
+	}
+}
+
+void pool_cycle_new_block(Pool *p) {
+	GB_ASSERT_MSG(p->block_allocator.proc != nullptr,
+	              "You must call pool_init on a Pool before using it!");
+
+	if (p->current_memblock != nullptr) {
+		array_add(&p->used_memblock, p->current_memblock);
+	}
+
+	u8 *new_block = nullptr;
+
+	if (p->unused_memblock.count > 0) {
+		new_block = array_pop(&p->unused_memblock);
+	} else {
+		GB_ASSERT(p->block_allocator.proc != nullptr);
+		new_block = cast(u8 *)gb_alloc_align(p->block_allocator, p->memblock_size, p->alignment);
+	}
+
+	p->bytes_left       = p->memblock_size;
+	p->current_memblock = new_block;
+	p->current_memblock = new_block;
+}
+
+void *pool_get(Pool *p,
+               isize size, isize alignment = 0) {
+	if (alignment <= 0) alignment = p->alignment;
+
+	isize extra = alignment - (size & alignment);
+	size += extra;
+	if (size >= p->out_of_band_size) {
+		GB_ASSERT(p->block_allocator.proc != nullptr);
+		u8 *memory = cast(u8 *)gb_alloc_align(p->block_allocator, p->memblock_size, alignment);
+		if (memory != nullptr) {
+			array_add(&p->out_of_band_allocations, memory);
+		}
+		return memory;
+	}
+
+	if (p->bytes_left < size) {
+		pool_cycle_new_block(p);
+		if (p->current_memblock != nullptr) {
+			return nullptr;
+		}
+	}
+
+	u8 *res = p->current_pos;
+	p->current_pos += size;
+	p->bytes_left  -= size;
+	return res;
+}
+
+
+gbAllocator pool_allocator(Pool *pool);
+
+GB_ALLOCATOR_PROC(pool_allocator_procedure) {
+	Pool *p = cast(Pool *)allocator_data;
+	void *ptr = nullptr;
+
+	switch (type) {
+	case gbAllocation_Alloc:
+		return pool_get(p, size, alignment);
+	case gbAllocation_Free:
+		// Does nothing
+		break;
+	case gbAllocation_FreeAll:
+		pool_free_all(p);
+		break;
+	case gbAllocation_Resize:
+		return gb_default_resize_align(pool_allocator(p), old_memory, old_size, size, alignment);
+	}
+
+	return ptr;
+}
+
+gbAllocator pool_allocator(Pool *pool) {
+	gbAllocator allocator;
+	allocator.proc = pool_allocator_procedure;
+	allocator.data = pool;
+	return allocator;
+}
+
+
+
+i32 next_pow2(i32 n) {
+	if (n <= 0) {
+		return 0;
+	}
+	n--;
+	n |= n >> 1;
+	n |= n >> 2;
+	n |= n >> 4;
+	n |= n >> 8;
+	n |= n >> 16;
+	n++;
+	return n;
+}
+i64 next_pow2(i64 n) {
+	if (n <= 0) {
+		return 0;
+	}
+	n--;
+	n |= n >> 1;
+	n |= n >> 2;
+	n |= n >> 4;
+	n |= n >> 8;
+	n |= n >> 16;
+	n |= n >> 32;
+	n++;
+	return n;
+}
+
+i32 bit_set_count(u32 x) {
+	x -= ((x >> 1) & 0x55555555);
+	x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
+	x = (((x >> 4) + x) & 0x0f0f0f0f);
+	x += (x >> 8);
+	x += (x >> 16);
+
+	return cast(i32)(x & 0x0000003f);
+}
+
+i64 bit_set_count(u64 x) {
+	u32 a = *(cast(u32 *)&x);
+	u32 b = *(cast(u32 *)&x + 1);
+	return bit_set_count(a) + bit_set_count(b);
+}
+
+u32 floor_log2(u32 x) {
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+	return cast(u32)(bit_set_count(x) - 1);
+}
+
+u64 floor_log2(u64 x) {
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+	x |= x >> 32;
+	return cast(u64)(bit_set_count(x) - 1);
+}
+
+
+u32 ceil_log2(u32 x) {
+	i32 y = cast(i32)(x & (x-1));
+	y |= -y;
+	y >>= 32-1;
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+	return cast(u32)(bit_set_count(x) - 1 - y);
+}
+
+u64 ceil_log2(u64 x) {
+	i64 y = cast(i64)(x & (x-1));
+	y |= -y;
+	y >>= 64-1;
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+	x |= x >> 32;
+	return cast(u64)(bit_set_count(x) - 1 - y);
+}
+
+
+i32 prev_pow2(i32 n) {
+	if (n <= 0) {
+		return 0;
+	}
+	n |= n >> 1;
+	n |= n >> 2;
+	n |= n >> 4;
+	n |= n >> 8;
+	n |= n >> 16;
+	return n - (n >> 1);
+}
+i64 prev_pow2(i64 n) {
+	if (n <= 0) {
+		return 0;
+	}
+	n |= n >> 1;
+	n |= n >> 2;
+	n |= n >> 4;
+	n |= n >> 8;
+	n |= n >> 16;
+	n |= n >> 32;
+	return n - (n >> 1);
+}
+
+i16 f32_to_f16(f32 value) {
+	union { u32 i; f32 f; } v;
+	i32 i, s, e, m;
+
+	v.f = value;
+	i = (i32)v.i;
+
+	s =  (i >> 16) & 0x00008000;
+	e = ((i >> 23) & 0x000000ff) - (127 - 15);
+	m =   i        & 0x007fffff;
+
+
+	if (e <= 0) {
+		if (e < -10) return cast(i16)s;
+		m = (m | 0x00800000) >> (1 - e);
+
+		if (m & 0x00001000)
+			m += 0x00002000;
+
+		return cast(i16)(s | (m >> 13));
+	} else if (e == 0xff - (127 - 15)) {
+		if (m == 0) {
+			return cast(i16)(s | 0x7c00); /* NOTE(bill): infinity */
+		} else {
+			/* NOTE(bill): NAN */
+			m >>= 13;
+			return cast(i16)(s | 0x7c00 | m | (m == 0));
+		}
+	} else {
+		if (m & 0x00001000) {
+			m += 0x00002000;
+			if (m & 0x00800000) {
+				m = 0;
+				e += 1;
+			}
+		}
+
+		if (e > 30) {
+			float volatile f = 1e12f;
+			int j;
+			for (j = 0; j < 10; j++) {
+				f *= f; /* NOTE(bill): Cause overflow */
+			}
+
+			return cast(i16)(s | 0x7c00);
+		}
+
+		return cast(i16)(s | (e << 10) | (m >> 13));
+	}
+}
+
+f64 gb_sqrt(f64 x) {
+	return sqrt(x);
+}
+
+
+
+
+
+// Doubly Linked Lists
+
+#define DLIST_SET(curr_element, next_element)  do { \
+	(curr_element)->next = (next_element);             \
+	(curr_element)->next->prev = (curr_element);       \
+	(curr_element) = (curr_element)->next;             \
+} while (0)
+
+#define DLIST_APPEND(root_element, curr_element, next_element) do { \
+	if ((root_element) == nullptr) { \
+		(root_element) = (curr_element) = (next_element); \
+	} else { \
+		DLIST_SET(curr_element, next_element); \
+	} \
+} while (0)
+
+
+
+#if defined(GB_SYSTEM_WINDOWS)
+
+wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
+	u32 i, j;
+
+	u32 len = cast(u32)string16_len(cmd_line);
+	i = ((len+2)/2)*gb_size_of(void *) + gb_size_of(void *);
+
+	wchar_t **argv = cast(wchar_t **)GlobalAlloc(GMEM_FIXED, i + (len+2)*gb_size_of(wchar_t));
+	wchar_t *_argv = cast(wchar_t *)((cast(u8 *)argv)+i);
+
+	u32 argc = 0;
+	argv[argc] = _argv;
+	bool in_quote = false;
+	bool in_text = false;
+	bool in_space = true;
+	i = 0;
+	j = 0;
+
+	for (;;) {
+		wchar_t a = cmd_line[i];
+		if (a == 0) {
+			break;
+		}
+		if (in_quote) {
+			if (a == '\"') {
+				in_quote = false;
+			} else {
+				_argv[j++] = a;
+			}
+		} else {
+			switch (a) {
+			case '\"':
+				in_quote = true;
+				in_text = true;
+				if (in_space) argv[argc++] = _argv+j;
+				in_space = false;
+				break;
+			case ' ':
+			case '\t':
+			case '\n':
+			case '\r':
+				if (in_text) _argv[j++] = '\0';
+				in_text = false;
+				in_space = true;
+				break;
+			default:
+				in_text = true;
+				if (in_space) argv[argc++] = _argv+j;
+				_argv[j++] = a;
+				in_space = false;
+				break;
+			}
+		}
+		i++;
+	}
+	_argv[j] = '\0';
+	argv[argc] = nullptr;
+
+	if (_argc) *_argc = argc;
+	return argv;
+}
+
+#endif
+
+
+#if defined(GB_SYSTEM_WINDOWS)
+	bool path_is_directory(String path) {
+		gbAllocator a = heap_allocator();
+		String16 wstr = string_to_string16(a, path);
+		defer (gb_free(a, wstr.text));
+
+		i32 attribs = GetFileAttributesW(wstr.text);
+		if (attribs < 0) return false;
+
+		return (attribs & FILE_ATTRIBUTE_DIRECTORY) != 0;
+	}
+
+#else
+	bool path_is_directory(String path) {
+		gbAllocator a = heap_allocator();
+		char *copy = cast(char *)copy_string(a, path).text;
+		defer (gb_free(a, copy));
+
+		struct stat s;
+		if (stat(copy, &s) == 0) {
+			return (s.st_mode & S_IFDIR) != 0;
+		}
+		return false;
+	}
+#endif
+
@@ -0,0 +1,107 @@
+// Generates Documentation
+
+gbString expr_to_string(AstNode *expression);
+
+String alloc_comment_group_string(gbAllocator a, CommentGroup g) {
+	isize len = 0;
+	for_array(i, g.list) {
+		String comment = g.list[i].string;
+		len += comment.len;
+		len += 1; // for \n
+	}
+	if (len == 0) {
+		return make_string(nullptr, 0);
+	}
+
+	u8 *text = gb_alloc_array(a, u8, len+1);
+	len = 0;
+	for_array(i, g.list) {
+		String comment = g.list[i].string;
+		if (comment[1] == '/') {
+			comment.text += 2;
+			comment.len  -= 2;
+		} else if (comment[1] == '*') {
+			comment.text += 2;
+			comment.len  -= 4;
+		}
+		comment = string_trim_whitespace(comment);
+		gb_memmove(text+len, comment.text, comment.len);
+		len += comment.len;
+		text[len++] = '\n';
+	}
+	return make_string(text, len);
+}
+
+#if 0
+void print_type_spec(AstNode *spec) {
+	ast_node(ts, TypeSpec, spec);
+	GB_ASSERT(ts->name->kind == AstNode_Ident);
+	String name = ts->name->Ident.string;
+	if (name.len == 0) {
+		return;
+	}
+	if (name[0] == '_') {
+		return;
+	}
+	gb_printf("type %.*s\n", LIT(name));
+}
+
+void print_proc_decl(AstNodeProcDecl *pd) {
+	GB_ASSERT(pd->name->kind == AstNode_Ident);
+	String name = pd->name->Ident.string;
+	if (name.len == 0) {
+		return;
+	}
+	if (name[0] == '_') {
+		return;
+	}
+
+	String docs = alloc_comment_group_string(heap_allocator(), pd->docs);
+	defer (gb_free(heap_allocator(), docs.text));
+
+	if (docs.len > 0) {
+		gb_file_write(&gb__std_files[gbFileStandard_Output], docs.text, docs.len);
+	} else {
+		return;
+	}
+
+	ast_node(proc_type, ProcType, pd->type);
+
+	gbString params = expr_to_string(proc_type->params);
+	defer (gb_string_free(params));
+	gb_printf("proc %.*s(%s)", LIT(name), params);
+	if (proc_type->results != nullptr)  {
+		ast_node(fl, FieldList, proc_type->results);
+		isize count = fl->list.count;
+		if (count > 0) {
+			gbString results = expr_to_string(proc_type->results);
+			defer (gb_string_free(results));
+			gb_printf(" -> ");
+			if (count != 1) {
+				gb_printf("(");
+			}
+			gb_printf("%s", results);
+			if (count != 1) {
+				gb_printf(")");
+			}
+		}
+	}
+	gb_printf("\n\n");
+}
+#endif
+void print_declaration(AstNode *decl) {
+}
+
+void generate_documentation(Parser *parser) {
+	for_array(file_index, parser->files) {
+		AstFile *file = parser->files[file_index];
+		Tokenizer *tokenizer = &file->tokenizer;
+		String fullpath = tokenizer->fullpath;
+		gb_printf("%.*s\n", LIT(fullpath));
+
+		for_array(decl_index, file->decls) {
+			AstNode *decl = file->decls[decl_index];
+			print_declaration(decl);
+		}
+	}
+}
@@ -0,0 +1,312 @@
+struct Scope;
+struct Checker;
+struct Type;
+struct DeclInfo;
+
+
+#define ENTITY_KINDS \
+	ENTITY_KIND(Invalid) \
+	ENTITY_KIND(Constant) \
+	ENTITY_KIND(Variable) \
+	ENTITY_KIND(TypeName) \
+	ENTITY_KIND(Procedure) \
+	ENTITY_KIND(ProcGroup) \
+	ENTITY_KIND(Builtin) \
+	ENTITY_KIND(Alias) \
+	ENTITY_KIND(ImportName) \
+	ENTITY_KIND(LibraryName) \
+	ENTITY_KIND(Nil) \
+	ENTITY_KIND(Label)
+
+enum EntityKind {
+#define ENTITY_KIND(k) GB_JOIN2(Entity_, k),
+	ENTITY_KINDS
+#undef ENTITY_KIND
+	Entity_Count,
+};
+
+String const entity_strings[] = {
+#define ENTITY_KIND(k) {cast(u8 *)#k, gb_size_of(#k)-1},
+	ENTITY_KINDS
+#undef ENTITY_KIND
+};
+
+enum EntityFlag {
+	EntityFlag_Visited       = 1<<0,
+	EntityFlag_Used          = 1<<1,
+	EntityFlag_Using         = 1<<2,
+	EntityFlag_Field         = 1<<3,
+	EntityFlag_Param         = 1<<4,
+	EntityFlag_Result        = 1<<5,
+	EntityFlag_ArrayElem     = 1<<6,
+	EntityFlag_Ellipsis      = 1<<7,
+	EntityFlag_NoAlias       = 1<<8,
+	EntityFlag_TypeField     = 1<<9,
+	EntityFlag_Value         = 1<<10,
+	EntityFlag_Sret          = 1<<11,
+	EntityFlag_BitFieldValue = 1<<12,
+	EntityFlag_PolyConst     = 1<<13,
+
+	EntityFlag_CVarArg       = 1<<20,
+};
+
+// Zero value means the overloading process is not yet done
+enum OverloadKind {
+	Overload_Unknown = 0,
+	Overload_No      = 1,
+	Overload_Yes     = 2,
+};
+
+
+// An Entity is a named "thing" in the language
+struct Entity {
+	EntityKind kind;
+	u64        id;
+	u32        flags;
+	Token      token;
+	Scope *    scope;
+	Type *     type;
+	AstNode *  identifier; // Can be nullptr
+	DeclInfo * decl_info;
+	DeclInfo * parent_proc_decl; // nullptr if in file/global scope
+
+	// TODO(bill): Cleanup how `using` works for entities
+	Entity *   using_parent;
+	AstNode *  using_expr;
+
+	isize      order_in_src;
+
+	union {
+		struct {
+			ExactValue value;
+		} Constant;
+		struct {
+			i32        field_index;
+			i32        field_src_index;
+			ExactValue default_value;
+			Entity *   foreign_library;
+			AstNode *  foreign_library_ident;
+			String     link_name;
+			String     link_prefix;
+			String     thread_local_model;
+			bool       default_is_nil;
+			bool       default_is_undef;
+			bool       default_is_location;
+			bool       is_immutable;
+			bool       is_foreign;
+			bool       is_export;
+		} Variable;
+		struct {
+			bool   is_type_alias;
+			Type * type_parameter_specialization;
+			String ir_mangled_name;
+		} TypeName;
+		struct {
+			OverloadKind overload_kind;
+			String       link_name;
+			String       link_prefix;
+			u64          tags;
+			bool         is_export;
+			bool         is_foreign;
+			Entity *     foreign_library;
+			AstNode *    foreign_library_ident;
+		} Procedure;
+		struct {
+			Array<Entity *> entities;
+		} ProcGroup;
+		struct {
+			i32 id;
+		} Builtin;
+		struct {
+			Entity *base;
+		} Alias;
+		struct {
+			String path;
+			String name;
+			Scope *scope;
+			bool   used;
+		} ImportName;
+		struct {
+			String path;
+			String name;
+			bool   used;
+		} LibraryName;
+		i32 Nil;
+		struct {
+			String   name;
+			AstNode *node;
+		} Label;
+	};
+};
+
+gb_global Entity *e_context = nullptr;
+
+bool is_entity_kind_exported(EntityKind kind) {
+	switch (kind) {
+	case Entity_Builtin:
+	case Entity_ImportName:
+	case Entity_LibraryName:
+	case Entity_Nil:
+		return false;
+	}
+	return true;
+}
+
+bool is_entity_exported(Entity *e) {
+	// TODO(bill): Determine the actual exportation rules for imports of entities
+	GB_ASSERT(e != nullptr);
+	if (!is_entity_kind_exported(e->kind)) {
+		return false;
+	}
+
+	String name = e->token.string;
+	if (name.len == 0) {
+		return false;
+	}
+	return name[0] != '_';
+}
+
+
+gb_global u64 global_entity_id = 0;
+
+Entity *alloc_entity(gbAllocator a, EntityKind kind, Scope *scope, Token token, Type *type) {
+	Entity *entity = gb_alloc_item(a, Entity);
+	entity->kind   = kind;
+	entity->scope  = scope;
+	entity->token  = token;
+	entity->type   = type;
+	entity->id     = ++global_entity_id;
+	return entity;
+}
+
+Entity *make_entity_variable(gbAllocator a, Scope *scope, Token token, Type *type, bool is_immutable) {
+	Entity *entity = alloc_entity(a, Entity_Variable, scope, token, type);
+	entity->Variable.is_immutable = is_immutable;
+	return entity;
+}
+
+Entity *make_entity_using_variable(gbAllocator a, Entity *parent, Token token, Type *type) {
+	GB_ASSERT(parent != nullptr);
+	token.pos = parent->token.pos;
+	Entity *entity = alloc_entity(a, Entity_Variable, parent->scope, token, type);
+	entity->using_parent = parent;
+	entity->parent_proc_decl = parent->parent_proc_decl;
+	entity->flags |= EntityFlag_Using;
+	entity->flags |= EntityFlag_Used;
+	return entity;
+}
+
+
+Entity *make_entity_constant(gbAllocator a, Scope *scope, Token token, Type *type, ExactValue value) {
+	Entity *entity = alloc_entity(a, Entity_Constant, scope, token, type);
+	entity->Constant.value = value;
+	return entity;
+}
+
+Entity *make_entity_type_name(gbAllocator a, Scope *scope, Token token, Type *type) {
+	Entity *entity = alloc_entity(a, Entity_TypeName, scope, token, type);
+	return entity;
+}
+
+Entity *make_entity_param(gbAllocator a, Scope *scope, Token token, Type *type, bool is_using, bool is_value) {
+	bool is_immutable = false;
+	Entity *entity = make_entity_variable(a, scope, token, type, is_immutable);
+	entity->flags |= EntityFlag_Used;
+	entity->flags |= EntityFlag_Param;
+	if (is_using) entity->flags |= EntityFlag_Using;
+	if (is_value) entity->flags |= EntityFlag_Value;
+	return entity;
+}
+
+
+Entity *make_entity_const_param(gbAllocator a, Scope *scope, Token token, Type *type, ExactValue value, bool poly_const) {
+	Entity *entity = make_entity_constant(a, scope, token, type, value);
+	entity->flags |= EntityFlag_Used;
+	if (poly_const) entity->flags |= EntityFlag_PolyConst;
+	entity->flags |= EntityFlag_Param;
+	return entity;
+}
+
+
+Entity *make_entity_field(gbAllocator a, Scope *scope, Token token, Type *type, bool is_using, i32 field_src_index) {
+	Entity *entity = make_entity_variable(a, scope, token, type, false);
+	entity->Variable.field_src_index = field_src_index;
+	entity->Variable.field_index = field_src_index;
+	if (is_using) entity->flags |= EntityFlag_Using;
+	entity->flags |= EntityFlag_Field;
+	return entity;
+}
+
+Entity *make_entity_array_elem(gbAllocator a, Scope *scope, Token token, Type *type, i32 field_src_index) {
+	Entity *entity = make_entity_variable(a, scope, token, type, false);
+	entity->Variable.field_src_index = field_src_index;
+	entity->Variable.field_index = field_src_index;
+	entity->flags |= EntityFlag_Field;
+	entity->flags |= EntityFlag_ArrayElem;
+	return entity;
+}
+
+Entity *make_entity_procedure(gbAllocator a, Scope *scope, Token token, Type *signature_type, u64 tags) {
+	Entity *entity = alloc_entity(a, Entity_Procedure, scope, token, signature_type);
+	entity->Procedure.tags = tags;
+	return entity;
+}
+
+Entity *make_entity_proc_group(gbAllocator a, Scope *scope, Token token, Type *type) {
+	Entity *entity = alloc_entity(a, Entity_ProcGroup, scope, token, type);
+	return entity;
+}
+
+
+Entity *make_entity_builtin(gbAllocator a, Scope *scope, Token token, Type *type, i32 id) {
+	Entity *entity = alloc_entity(a, Entity_Builtin, scope, token, type);
+	entity->Builtin.id = id;
+	return entity;
+}
+
+Entity *make_entity_alias(gbAllocator a, Scope *scope, Token token, Type *type, Entity *base) {
+	Entity *entity = alloc_entity(a, Entity_Alias, scope, token, type);
+	entity->Alias.base = base;
+	return entity;
+}
+
+Entity *make_entity_import_name(gbAllocator a, Scope *scope, Token token, Type *type,
+                                String path, String name, Scope *import_scope) {
+	Entity *entity = alloc_entity(a, Entity_ImportName, scope, token, type);
+	entity->ImportName.path = path;
+	entity->ImportName.name = name;
+	entity->ImportName.scope = import_scope;
+	return entity;
+}
+
+Entity *make_entity_library_name(gbAllocator a, Scope *scope, Token token, Type *type,
+                                 String path, String name) {
+	Entity *entity = alloc_entity(a, Entity_LibraryName, scope, token, type);
+	entity->LibraryName.path = path;
+	entity->LibraryName.name = name;
+	return entity;
+}
+
+
+
+
+
+Entity *make_entity_nil(gbAllocator a, String name, Type *type) {
+	Entity *entity = alloc_entity(a, Entity_Nil, nullptr, make_token_ident(name), type);
+	return entity;
+}
+
+Entity *make_entity_label(gbAllocator a, Scope *scope, Token token, Type *type,
+                          AstNode *node) {
+	Entity *entity = alloc_entity(a, Entity_Label, scope, token, type);
+	entity->Label.node = node;
+	return entity;
+}
+
+
+
+Entity *make_entity_dummy_variable(gbAllocator a, Scope *scope, Token token) {
+	token.string = str_lit("_");
+	return make_entity_variable(a, scope, token, nullptr, false);
+}
+
@@ -1,401 +0,0 @@
-#include <math.h>
-
-// TODO(bill): Big numbers
-// IMPORTANT TODO(bill): This needs to be completely fixed!!!!!!!!
-
-typedef struct AstNode AstNode;
-
-typedef enum ExactValueKind {
-	ExactValue_Invalid,
-
-	ExactValue_Bool,
-	ExactValue_String,
-	ExactValue_Integer,
-	ExactValue_Float,
-	ExactValue_Pointer,
-	ExactValue_Compound, // TODO(bill): Is this good enough?
-
-	ExactValue_Count,
-} ExactValueKind;
-
-typedef struct ExactValue {
-	ExactValueKind kind;
-	union {
-		bool     value_bool;
-		String   value_string;
-		i64      value_integer; // NOTE(bill): This must be an integer and not a pointer
-		f64      value_float;
-		i64      value_pointer;
-		AstNode *value_compound;
-	};
-} ExactValue;
-
-HashKey hash_exact_value(ExactValue v) {
-	return hashing_proc(&v, gb_size_of(ExactValue));
-}
-
-
-ExactValue make_exact_value_compound(AstNode *node) {
-	ExactValue result = {ExactValue_Compound};
-	result.value_compound = node;
-	return result;
-}
-
-ExactValue make_exact_value_bool(bool b) {
-	ExactValue result = {ExactValue_Bool};
-	result.value_bool = (b != 0);
-	return result;
-}
-
-ExactValue make_exact_value_string(String string) {
-	// TODO(bill): Allow for numbers with underscores in them
-	ExactValue result = {ExactValue_String};
-	result.value_string = string;
-	return result;
-}
-
-ExactValue make_exact_value_integer_from_string(String string) {
-	// TODO(bill): Allow for numbers with underscores in them
-	ExactValue result = {ExactValue_Integer};
-	i32 base = 10;
-	if (string.len > 2 && string.text[0] == '0') {
-		switch (string.text[1]) {
-		case 'b': base = 2;  break;
-		case 'o': base = 8;  break;
-		case 'd': base = 10; break;
-		case 'x': base = 16; break;
-		}
-	}
-
-	result.value_integer = gb_str_to_i64(cast(char *)string.text, NULL, base);
-
-	return result;
-}
-
-ExactValue make_exact_value_integer(i64 i) {
-	ExactValue result = {ExactValue_Integer};
-	result.value_integer = i;
-	return result;
-}
-
-ExactValue make_exact_value_float_from_string(String string) {
-	// TODO(bill): Allow for numbers with underscores in them
-	ExactValue result = {ExactValue_Float};
-	result.value_float = gb_str_to_f64(cast(char *)string.text, NULL);
-	return result;
-}
-
-ExactValue make_exact_value_float(f64 f) {
-	ExactValue result = {ExactValue_Float};
-	result.value_float = f;
-	return result;
-}
-
-ExactValue make_exact_value_pointer(i64 ptr) {
-	ExactValue result = {ExactValue_Pointer};
-	result.value_pointer = ptr;
-	return result;
-}
-
-ExactValue make_exact_value_from_basic_literal(Token token) {
-	switch (token.kind) {
-	case Token_String:  return make_exact_value_string(token.string);
-	case Token_Integer: return make_exact_value_integer_from_string(token.string);
-	case Token_Float:   return make_exact_value_float_from_string(token.string);
-	case Token_Rune: {
-		Rune r = GB_RUNE_INVALID;
-		gb_utf8_decode(token.string.text, token.string.len, &r);
-		// gb_printf("%.*s rune: %d\n", LIT(token.string), r);
-		return make_exact_value_integer(r);
-	}
-	default:
-		GB_PANIC("Invalid token for basic literal");
-		break;
-	}
-
-	ExactValue result = {ExactValue_Invalid};
-	return result;
-}
-
-ExactValue exact_value_to_integer(ExactValue v) {
-	switch (v.kind) {
-	case ExactValue_Integer:
-		return v;
-	case ExactValue_Float: {
-		i64 i = cast(i64)v.value_float;
-		f64 f = cast(f64)i;
-		if (f == v.value_float) {
-			return make_exact_value_integer(i);
-		}
-	} break;
-
-	case ExactValue_Pointer:
-		return make_exact_value_integer(cast(i64)cast(intptr)v.value_pointer);
-	}
-	ExactValue r = {ExactValue_Invalid};
-	return r;
-}
-
-ExactValue exact_value_to_float(ExactValue v) {
-	switch (v.kind) {
-	case ExactValue_Integer:
-		return make_exact_value_float(cast(i64)v.value_integer);
-	case ExactValue_Float:
-		return v;
-	}
-	ExactValue r = {ExactValue_Invalid};
-	return r;
-}
-
-
-ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision) {
-	switch (op) {
-	case Token_Add:	{
-		switch (v.kind) {
-		case ExactValue_Invalid:
-		case ExactValue_Integer:
-		case ExactValue_Float:
-			return v;
-		}
-	} break;
-
-	case Token_Sub:	{
-		switch (v.kind) {
-		case ExactValue_Invalid:
-			return v;
-		case ExactValue_Integer: {
-			ExactValue i = v;
-			i.value_integer = -i.value_integer;
-			return i;
-		}
-		case ExactValue_Float: {
-			ExactValue i = v;
-			i.value_float = -i.value_float;
-			return i;
-		}
-		}
-	} break;
-
-	case Token_Xor: {
-		i64 i = 0;
-		switch (v.kind) {
-		case ExactValue_Invalid:
-			return v;
-		case ExactValue_Integer:
-			i = v.value_integer;
-			i = ~i;
-			break;
-		default:
-			goto failure;
-		}
-
-		// NOTE(bill): unsigned integers will be negative and will need to be
-		// limited to the types precision
-		if (precision > 0)
-			i &= ~((~0ll)<<precision);
-
-		return make_exact_value_integer(i);
-	} break;
-
-	case Token_Not: {
-		switch (v.kind) {
-		case ExactValue_Invalid: return v;
-		case ExactValue_Bool:
-			return make_exact_value_bool(!v.value_bool);
-		}
-	} break;
-	}
-
-failure:
-	GB_PANIC("Invalid unary operation, %.*s", LIT(token_strings[op]));
-
-	ExactValue error_value = {0};
-	return error_value;
-}
-
-// NOTE(bill): Make sure things are evaluated in correct order
-i32 exact_value_order(ExactValue v) {
-	switch (v.kind) {
-	case ExactValue_Invalid:
-		return 0;
-	case ExactValue_Bool:
-	case ExactValue_String:
-		return 1;
-	case ExactValue_Integer:
-		return 2;
-	case ExactValue_Float:
-		return 3;
-	case ExactValue_Pointer:
-		return 4;
-
-	default:
-		GB_PANIC("How'd you get here? Invalid Value.kind");
-		return -1;
-	}
-}
-
-void match_exact_values(ExactValue *x, ExactValue *y) {
-	if (exact_value_order(*y) < exact_value_order(*x)) {
-		match_exact_values(y, x);
-		return;
-	}
-
-	switch (x->kind) {
-	case ExactValue_Invalid:
-		*y = *x;
-		return;
-
-	case ExactValue_Bool:
-	case ExactValue_String:
-		return;
-
-	case ExactValue_Integer:
-		switch (y->kind) {
-		case ExactValue_Integer:
-			return;
-		case ExactValue_Float:
-			// TODO(bill): Is this good enough?
-			*x = make_exact_value_float(cast(f64)x->value_integer);
-			return;
-		}
-		break;
-
-	case ExactValue_Float:
-		if (y->kind == ExactValue_Float)
-			return;
-		break;
-	}
-
-	compiler_error("How'd you get here? Invalid ExactValueKind");
-}
-
-// TODO(bill): Allow for pointer arithmetic? Or are pointer slices good enough?
-ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y) {
-	match_exact_values(&x, &y);
-
-	switch (x.kind) {
-	case ExactValue_Invalid:
-		return x;
-
-	case ExactValue_Bool:
-		switch (op) {
-		case Token_CmpAnd: return make_exact_value_bool(x.value_bool && y.value_bool);
-		case Token_CmpOr:  return make_exact_value_bool(x.value_bool || y.value_bool);
-		case Token_And:    return make_exact_value_bool(x.value_bool & y.value_bool);
-		case Token_Or:     return make_exact_value_bool(x.value_bool | y.value_bool);
-		default: goto error;
-		}
-		break;
-
-	case ExactValue_Integer: {
-		i64 a = x.value_integer;
-		i64 b = y.value_integer;
-		i64 c = 0;
-		switch (op) {
-		case Token_Add:    c = a + b;  break;
-		case Token_Sub:    c = a - b;  break;
-		case Token_Mul:    c = a * b;  break;
-		case Token_Quo:    return make_exact_value_float(fmod(cast(f64)a, cast(f64)b));
-		case Token_QuoEq:  c = a / b;  break; // NOTE(bill): Integer division
-		case Token_Mod:    c = a % b;  break;
-		case Token_And:    c = a & b;  break;
-		case Token_Or:     c = a | b;  break;
-		case Token_Xor:    c = a ^ b;  break;
-		case Token_AndNot: c = a&(~b); break;
-		case Token_Shl:    c = a << b; break;
-		case Token_Shr:    c = a >> b; break;
-		default: goto error;
-		}
-
-		return make_exact_value_integer(c);
-	} break;
-
-	case ExactValue_Float: {
-		f64 a = x.value_float;
-		f64 b = y.value_float;
-		switch (op) {
-		case Token_Add: return make_exact_value_float(a + b);
-		case Token_Sub: return make_exact_value_float(a - b);
-		case Token_Mul: return make_exact_value_float(a * b);
-		case Token_Quo: return make_exact_value_float(a / b);
-		default: goto error;
-		}
-	} break;
-	}
-
-error:
-	ExactValue error_value = {0};
-	// gb_printf_err("Invalid binary operation: %s\n", token_kind_to_string(op));
-	return error_value;
-}
-
-gb_inline ExactValue exact_value_add(ExactValue x, ExactValue y) { return exact_binary_operator_value(Token_Add, x, y); }
-gb_inline ExactValue exact_value_sub(ExactValue x, ExactValue y) { return exact_binary_operator_value(Token_Sub, x, y); }
-gb_inline ExactValue exact_value_mul(ExactValue x, ExactValue y) { return exact_binary_operator_value(Token_Mul, x, y); }
-gb_inline ExactValue exact_value_quo(ExactValue x, ExactValue y) { return exact_binary_operator_value(Token_Quo, x, y); }
-gb_inline ExactValue exact_value_shift(TokenKind op, ExactValue x, ExactValue y) { return exact_binary_operator_value(op, x, y); }
-
-
-i32 cmp_f64(f64 a, f64 b) {
-	return (a > b) - (a < b);
-}
-
-bool compare_exact_values(TokenKind op, ExactValue x, ExactValue y) {
-	match_exact_values(&x, &y);
-
-	switch (x.kind) {
-	case ExactValue_Invalid:
-		return false;
-
-	case ExactValue_Bool:
-		switch (op) {
-		case Token_CmpEq: return x.value_bool == y.value_bool;
-		case Token_NotEq: return x.value_bool != y.value_bool;
-		}
-		break;
-
-	case ExactValue_Integer: {
-		i64 a = x.value_integer;
-		i64 b = y.value_integer;
-		switch (op) {
-		case Token_CmpEq: return a == b;
-		case Token_NotEq: return a != b;
-		case Token_Lt:    return a <  b;
-		case Token_LtEq:  return a <= b;
-		case Token_Gt:    return a >  b;
-		case Token_GtEq:  return a >= b;
-		}
-	} break;
-
-	case ExactValue_Float: {
-		f64 a = x.value_float;
-		f64 b = y.value_float;
-		switch (op) {
-		case Token_CmpEq: return cmp_f64(a, b) == 0;
-		case Token_NotEq: return cmp_f64(a, b) != 0;
-		case Token_Lt:    return cmp_f64(a, b) <  0;
-		case Token_LtEq:  return cmp_f64(a, b) <= 0;
-		case Token_Gt:    return cmp_f64(a, b) >  0;
-		case Token_GtEq:  return cmp_f64(a, b) >= 0;
-		}
-	} break;
-
-	case ExactValue_String: {
-		String a = x.value_string;
-		String b = y.value_string;
-		isize len = gb_min(a.len, b.len);
-		// TODO(bill): gb_memcompare is used because the strings are UTF-8
-		switch (op) {
-		case Token_CmpEq: return gb_memcompare(a.text, b.text, len) == 0;
-		case Token_NotEq: return gb_memcompare(a.text, b.text, len) != 0;
-		case Token_Lt:    return gb_memcompare(a.text, b.text, len) <  0;
-		case Token_LtEq:  return gb_memcompare(a.text, b.text, len) <= 0;
-		case Token_Gt:    return gb_memcompare(a.text, b.text, len) >  0;
-		case Token_GtEq:  return gb_memcompare(a.text, b.text, len) >= 0;
-		}
-	} break;
-	}
-
-	GB_PANIC("Invalid comparison");
-	return false;
-}
@@ -0,0 +1,690 @@
+#include <math.h>
+
+// TODO(bill): Big numbers
+// IMPORTANT TODO(bill): This needs to be completely fixed!!!!!!!!
+
+struct AstNode;
+struct HashKey;
+struct Type;
+bool are_types_identical(Type *x, Type *y);
+
+struct Complex128 {
+	f64 real, imag;
+};
+
+enum ExactValueKind {
+	ExactValue_Invalid,
+
+	ExactValue_Bool,
+	ExactValue_String,
+	ExactValue_Integer,
+	ExactValue_Float,
+	ExactValue_Complex,
+	ExactValue_Pointer,
+	ExactValue_Compound, // TODO(bill): Is this good enough?
+	ExactValue_Procedure, // TODO(bill): Is this good enough?
+	ExactValue_Type,
+
+	ExactValue_Count,
+};
+
+struct ExactValue {
+	ExactValueKind kind;
+	union {
+		bool          value_bool;
+		String        value_string;
+		i64           value_integer; // NOTE(bill): This must be an integer and not a pointer
+		f64           value_float;
+		i64           value_pointer;
+		Complex128    value_complex;
+		AstNode *     value_compound;
+		AstNode *     value_procedure;
+		Type *        value_type;
+	};
+};
+
+gb_global ExactValue const empty_exact_value = {};
+
+HashKey hash_exact_value(ExactValue v) {
+	return hashing_proc(&v, gb_size_of(ExactValue));
+}
+
+
+ExactValue exact_value_compound(AstNode *node) {
+	ExactValue result = {ExactValue_Compound};
+	result.value_compound = node;
+	return result;
+}
+
+ExactValue exact_value_bool(bool b) {
+	ExactValue result = {ExactValue_Bool};
+	result.value_bool = (b != 0);
+	return result;
+}
+
+ExactValue exact_value_string(String string) {
+	// TODO(bill): Allow for numbers with underscores in them
+	ExactValue result = {ExactValue_String};
+	result.value_string = string;
+	return result;
+}
+
+ExactValue exact_value_i64(i64 i) {
+	ExactValue result = {ExactValue_Integer};
+	result.value_integer = i;
+	return result;
+}
+
+ExactValue exact_value_u64(u64 i) {
+	ExactValue result = {ExactValue_Integer};
+	result.value_integer = i64(i);
+	return result;
+}
+
+ExactValue exact_value_float(f64 f) {
+	ExactValue result = {ExactValue_Float};
+	result.value_float = f;
+	return result;
+}
+
+ExactValue exact_value_complex(f64 real, f64 imag) {
+	ExactValue result = {ExactValue_Complex};
+	result.value_complex.real = real;
+	result.value_complex.imag = imag;
+	return result;
+}
+
+ExactValue exact_value_pointer(i64 ptr) {
+	ExactValue result = {ExactValue_Pointer};
+	result.value_pointer = ptr;
+	return result;
+}
+
+ExactValue exact_value_type(Type *type) {
+	ExactValue result = {ExactValue_Type};
+	result.value_type = type;
+	return result;
+}
+
+ExactValue exact_value_procedure(AstNode *node) {
+	ExactValue result = {ExactValue_Procedure};
+	result.value_procedure = node;
+	return result;
+}
+
+
+ExactValue exact_value_integer_from_string(String string) {
+	u64 u = u64_from_string(string);
+	return exact_value_u64(u);
+}
+
+f64 float_from_string(String string) {
+	isize i = 0;
+	u8 *str = string.text;
+	isize len = string.len;
+
+	f64 sign = 1.0;
+	if (str[i] == '-') {
+		sign = -1.0;
+		i++;
+	} else if (*str == '+') {
+		i++;
+	}
+
+#if 0
+	if (len-i > 2 &&
+	    str[i] == '0' &&
+	    str[i+1] == 'h') {
+		i += 2;
+		u8 *text = string.text;
+		isize len = string.len;
+		if (has_prefix) {
+			text += 2;
+			len -= 2;
+		}
+
+		u64 base = 16;
+
+		u64 result = {0};
+		for (isize i = 0; i < len; i++) {
+			Rune r = cast(Rune)text[i];
+			if (r == '_') {
+				continue;
+			}
+			u64 v = bit128__digit_value(r);
+			if (v >= base) {
+				break;
+			}
+			result *= base;
+			result += v;
+		}
+
+
+		return *cast(f64 *)&result;
+	}
+#endif
+
+	f64 value = 0.0;
+	for (; i < len; i++) {
+		Rune r = cast(Rune)str[i];
+		if (r == '_') {
+			continue;
+		}
+		i64 v = digit_value(r);
+		if (v >= 10) {
+			break;
+		}
+		value *= 10.0;
+		value += v;
+	}
+
+	if (str[i] == '.') {
+		f64 pow10 = 10.0;
+		i++;
+		for (; i < string.len; i++) {
+			Rune r = cast(Rune)str[i];
+			if (r == '_') {
+				continue;
+			}
+			i64 v = digit_value(r);
+			if (v >= 10) {
+				break;
+			}
+			value += v/pow10;
+			pow10 *= 10.0;
+		}
+	}
+
+	bool frac = false;
+	f64 scale = 1.0;
+	if ((str[i] == 'e') || (str[i] == 'E')) {
+		i++;
+
+		if (str[i] == '-') {
+			frac = true;
+			i++;
+		} else if (str[i] == '+') {
+			i++;
+		}
+
+		u32 exp = 0;
+		for (; i < len; i++) {
+			Rune r = cast(Rune)str[i];
+			if (r == '_') {
+				continue;
+			}
+			u32 d = cast(u32)digit_value(r);
+			if (d >= 10) {
+				break;
+			}
+			exp = exp * 10 + d;
+		}
+		if (exp > 308) exp = 308;
+
+		while (exp >= 50) { scale *= 1e50; exp -= 50; }
+		while (exp >=  8) { scale *= 1e8;  exp -=  8; }
+		while (exp >   0) { scale *= 10.0; exp -=  1; }
+	}
+
+	return sign * (frac ? (value / scale) : (value * scale));
+}
+
+ExactValue exact_value_float_from_string(String string) {
+	return exact_value_float(float_from_string(string));
+}
+
+
+ExactValue exact_value_from_basic_literal(Token token) {
+	switch (token.kind) {
+	case Token_String:  return exact_value_string(token.string);
+	case Token_Integer: return exact_value_integer_from_string(token.string);
+	case Token_Float:   return exact_value_float_from_string(token.string);
+	case Token_Imag: {
+		String str = token.string;
+		Rune last_rune = cast(Rune)str[str.len-1];
+		str.len--; // Ignore the 'i|j|k'
+		f64 imag = float_from_string(str);
+
+		if (last_rune == 'i') {
+			return exact_value_complex(0, imag);
+		}
+	}
+	case Token_Rune: {
+		Rune r = GB_RUNE_INVALID;
+		gb_utf8_decode(token.string.text, token.string.len, &r);
+		// gb_printf("%.*s rune: %d\n", LIT(token.string), r);
+		return exact_value_i64(r);
+	}
+	default:
+		GB_PANIC("Invalid token for basic literal");
+		break;
+	}
+
+	ExactValue result = {ExactValue_Invalid};
+	return result;
+}
+
+ExactValue exact_value_to_integer(ExactValue v) {
+	switch (v.kind) {
+	case ExactValue_Integer:
+		return v;
+	case ExactValue_Float: {
+		i64 i = cast(i64)v.value_float;
+		f64 f = cast(f64)i;
+		if (f == v.value_float) {
+			return exact_value_i64(i);
+		}
+		break;
+	}
+
+	case ExactValue_Pointer:
+		return exact_value_i64(cast(i64)cast(intptr)v.value_pointer);
+	}
+	ExactValue r = {ExactValue_Invalid};
+	return r;
+}
+
+ExactValue exact_value_to_float(ExactValue v) {
+	switch (v.kind) {
+	case ExactValue_Integer:
+		return exact_value_float(cast(f64)v.value_integer);
+	case ExactValue_Float:
+		return v;
+	}
+	ExactValue r = {ExactValue_Invalid};
+	return r;
+}
+
+ExactValue exact_value_to_complex(ExactValue v) {
+	switch (v.kind) {
+	case ExactValue_Integer:
+		return exact_value_complex(cast(f64)v.value_integer, 0);
+	case ExactValue_Float:
+		return exact_value_complex(v.value_float, 0);
+	case ExactValue_Complex:
+		return v;
+	}
+	ExactValue r = {ExactValue_Invalid};
+	return r;
+}
+
+
+ExactValue exact_value_real(ExactValue v) {
+	switch (v.kind) {
+	case ExactValue_Integer:
+	case ExactValue_Float:
+		return v;
+	case ExactValue_Complex:
+		return exact_value_float(v.value_complex.real);
+	}
+	ExactValue r = {ExactValue_Invalid};
+	return r;
+}
+
+ExactValue exact_value_imag(ExactValue v) {
+	switch (v.kind) {
+	case ExactValue_Integer:
+	case ExactValue_Float:
+		return exact_value_i64(0);
+	case ExactValue_Complex:
+		return exact_value_float(v.value_complex.imag);
+	}
+	ExactValue r = {ExactValue_Invalid};
+	return r;
+}
+
+ExactValue exact_value_make_imag(ExactValue v) {
+	switch (v.kind) {
+	case ExactValue_Integer:
+		return exact_value_complex(0, exact_value_to_float(v).value_float);
+	case ExactValue_Float:
+		return exact_value_complex(0, v.value_float);
+	default:
+		GB_PANIC("Expected an integer or float type for 'exact_value_make_imag'");
+	}
+	ExactValue r = {ExactValue_Invalid};
+	return r;
+}
+
+
+ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision) {
+	switch (op) {
+	case Token_Add:	{
+		switch (v.kind) {
+		case ExactValue_Invalid:
+		case ExactValue_Integer:
+		case ExactValue_Float:
+		case ExactValue_Complex:
+			return v;
+		}
+		break;
+	}
+
+	case Token_Sub:	{
+		switch (v.kind) {
+		case ExactValue_Invalid:
+			return v;
+		case ExactValue_Integer: {
+			ExactValue i = v;
+			i.value_integer = -i.value_integer;
+			return i;
+		}
+		case ExactValue_Float: {
+			ExactValue i = v;
+			i.value_float = -i.value_float;
+			return i;
+		}
+		case ExactValue_Complex: {
+			f64 real = v.value_complex.real;
+			f64 imag = v.value_complex.imag;
+			return exact_value_complex(-real, -imag);
+		}
+		}
+		break;
+	}
+
+	case Token_Xor: {
+		i64 i = 0;
+		switch (v.kind) {
+		case ExactValue_Invalid:
+			return v;
+		case ExactValue_Integer:
+			i = ~v.value_integer;
+			break;
+		default:
+			goto failure;
+		}
+
+		// NOTE(bill): unsigned integers will be negative and will need to be
+		// limited to the types precision
+		// IMPORTANT NOTE(bill): Max precision is 64 bits as that's how integers are stored
+		if (0 < precision && precision < 64) {
+			i = i & ~(-1ll << precision);
+		}
+
+		return exact_value_i64(i);
+	}
+
+	case Token_Not: {
+		switch (v.kind) {
+		case ExactValue_Invalid: return v;
+		case ExactValue_Bool:
+			return exact_value_bool(!v.value_bool);
+		}
+		break;
+	}
+	}
+
+failure:
+	GB_PANIC("Invalid unary operation, %.*s", LIT(token_strings[op]));
+
+	ExactValue error_value = {};
+	return error_value;
+}
+
+// NOTE(bill): Make sure things are evaluated in correct order
+i32 exact_value_order(ExactValue v) {
+	switch (v.kind) {
+	case ExactValue_Invalid:
+		return 0;
+	case ExactValue_Bool:
+	case ExactValue_String:
+		return 1;
+	case ExactValue_Integer:
+		return 2;
+	case ExactValue_Float:
+		return 3;
+	case ExactValue_Complex:
+		return 4;
+	case ExactValue_Pointer:
+		return 5;
+
+	default:
+		GB_PANIC("How'd you get here? Invalid Value.kind");
+		return -1;
+	}
+}
+
+void match_exact_values(ExactValue *x, ExactValue *y) {
+	if (exact_value_order(*y) < exact_value_order(*x)) {
+		match_exact_values(y, x);
+		return;
+	}
+
+	switch (x->kind) {
+	case ExactValue_Invalid:
+		*y = *x;
+		return;
+
+	case ExactValue_Bool:
+	case ExactValue_String:
+	case ExactValue_Complex:
+		return;
+
+	case ExactValue_Integer:
+		switch (y->kind) {
+		case ExactValue_Integer:
+			return;
+		case ExactValue_Float:
+			// TODO(bill): Is this good enough?
+			*x = exact_value_float(cast(f64)x->value_integer);
+			return;
+		case ExactValue_Complex:
+			*x = exact_value_complex(cast(f64)x->value_integer, 0);
+			return;
+		}
+		break;
+
+	case ExactValue_Float:
+		switch (y->kind) {
+		case ExactValue_Float:
+			return;
+		case ExactValue_Complex:
+			*x = exact_value_to_complex(*x);
+			return;
+		}
+		break;
+	}
+
+	compiler_error("match_exact_values: How'd you get here? Invalid ExactValueKind %d", x->kind);
+}
+
+// TODO(bill): Allow for pointer arithmetic? Or are pointer slices good enough?
+ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y) {
+	match_exact_values(&x, &y);
+
+	switch (x.kind) {
+	case ExactValue_Invalid:
+		return x;
+
+	case ExactValue_Bool:
+		switch (op) {
+		case Token_CmpAnd: return exact_value_bool(x.value_bool && y.value_bool);
+		case Token_CmpOr:  return exact_value_bool(x.value_bool || y.value_bool);
+		case Token_And:    return exact_value_bool(x.value_bool & y.value_bool);
+		case Token_Or:     return exact_value_bool(x.value_bool | y.value_bool);
+		default: goto error;
+		}
+		break;
+
+	case ExactValue_Integer: {
+		i64 a = x.value_integer;
+		i64 b = y.value_integer;
+		i64 c = 0ll;
+		switch (op) {
+		case Token_Add:    c = a + b;                        break;
+		case Token_Sub:    c = a - b;                        break;
+		case Token_Mul:    c = a * b;                        break;
+		case Token_Quo:    return exact_value_float(fmod(cast(f64)a, cast(f64)b));
+		case Token_QuoEq:  c = a / b;                        break; // NOTE(bill): Integer division
+		case Token_Mod:    c = a % b;                        break;
+		case Token_ModMod: c = ((a % b) + b) % b;            break;
+		case Token_And:    c = a & b;                        break;
+		case Token_Or:     c = a | b;                        break;
+		case Token_Xor:    c = a ^ b;                        break;
+		case Token_AndNot: c = a & (~b);                     break;
+		case Token_Shl:    c = a << b;                       break;
+		case Token_Shr:    c = a >> b;                       break;
+		default: goto error;
+		}
+
+		return exact_value_i64(c);
+		break;
+	}
+
+	case ExactValue_Float: {
+		f64 a = x.value_float;
+		f64 b = y.value_float;
+		switch (op) {
+		case Token_Add: return exact_value_float(a + b);
+		case Token_Sub: return exact_value_float(a - b);
+		case Token_Mul: return exact_value_float(a * b);
+		case Token_Quo: return exact_value_float(a / b);
+		default: goto error;
+		}
+		break;
+	}
+
+	case ExactValue_Complex: {
+		y = exact_value_to_complex(y);
+		f64 a = x.value_complex.real;
+		f64 b = x.value_complex.imag;
+		f64 c = y.value_complex.real;
+		f64 d = y.value_complex.imag;
+		f64 real = 0;
+		f64 imag = 0;
+		switch (op) {
+		case Token_Add:
+			real = a + c;
+			imag = b + d;
+			break;
+		case Token_Sub:
+			real = a - c;
+			imag = b - d;
+			break;
+		case Token_Mul:
+			real = (a*c - b*d);
+			imag = (b*c + a*d);
+			break;
+		case Token_Quo: {
+			f64 s = c*c + d*d;
+			real = (a*c + b*d)/s;
+			imag = (b*c - a*d)/s;
+			break;
+		}
+		default: goto error;
+		}
+		return exact_value_complex(real, imag);
+		break;
+	}
+
+	case ExactValue_String: {
+		if (op != Token_Add) goto error;
+
+		// NOTE(bill): How do you minimize this over allocation?
+		String sx = x.value_string;
+		String sy = y.value_string;
+		isize len = sx.len+sy.len;
+		u8 *data = gb_alloc_array(heap_allocator(), u8, len);
+		gb_memmove(data,        sx.text, sx.len);
+		gb_memmove(data+sx.len, sy.text, sy.len);
+		return exact_value_string(make_string(data, len));
+		break;
+	}
+	}
+
+error:; // NOTE(bill): MSVC accepts this??? apparently you cannot declare variables immediately after labels...
+	return empty_exact_value;
+}
+
+gb_inline ExactValue exact_value_add(ExactValue x, ExactValue y) { return exact_binary_operator_value(Token_Add, x, y); }
+gb_inline ExactValue exact_value_sub(ExactValue x, ExactValue y) { return exact_binary_operator_value(Token_Sub, x, y); }
+gb_inline ExactValue exact_value_mul(ExactValue x, ExactValue y) { return exact_binary_operator_value(Token_Mul, x, y); }
+gb_inline ExactValue exact_value_quo(ExactValue x, ExactValue y) { return exact_binary_operator_value(Token_Quo, x, y); }
+gb_inline ExactValue exact_value_shift(TokenKind op, ExactValue x, ExactValue y) { return exact_binary_operator_value(op, x, y); }
+
+
+i32 cmp_f64(f64 a, f64 b) {
+	return (a > b) - (a < b);
+}
+
+bool compare_exact_values(TokenKind op, ExactValue x, ExactValue y) {
+	match_exact_values(&x, &y);
+
+	switch (x.kind) {
+	case ExactValue_Invalid:
+		return false;
+
+	case ExactValue_Bool:
+		switch (op) {
+		case Token_CmpEq: return x.value_bool == y.value_bool;
+		case Token_NotEq: return x.value_bool != y.value_bool;
+		}
+		break;
+
+	case ExactValue_Integer: {
+		i64 a = x.value_integer;
+		i64 b = y.value_integer;
+		switch (op) {
+		case Token_CmpEq: return a == b;
+		case Token_NotEq: return a != b;
+		case Token_Lt:    return a <  b;
+		case Token_LtEq:  return a <= b;
+		case Token_Gt:    return a >  b;
+		case Token_GtEq:  return a >= b;
+		}
+		break;
+	}
+
+	case ExactValue_Float: {
+		f64 a = x.value_float;
+		f64 b = y.value_float;
+		switch (op) {
+		case Token_CmpEq: return cmp_f64(a, b) == 0;
+		case Token_NotEq: return cmp_f64(a, b) != 0;
+		case Token_Lt:    return cmp_f64(a, b) <  0;
+		case Token_LtEq:  return cmp_f64(a, b) <= 0;
+		case Token_Gt:    return cmp_f64(a, b) >  0;
+		case Token_GtEq:  return cmp_f64(a, b) >= 0;
+		}
+		break;
+	}
+
+	case ExactValue_Complex: {
+		f64 a = x.value_complex.real;
+		f64 b = x.value_complex.imag;
+		f64 c = y.value_complex.real;
+		f64 d = y.value_complex.imag;
+		switch (op) {
+		case Token_CmpEq: return cmp_f64(a, c) == 0 && cmp_f64(b, d) == 0;
+		case Token_NotEq: return cmp_f64(a, c) != 0 || cmp_f64(b, d) != 0;
+		}
+		break;
+	}
+
+	case ExactValue_String: {
+		String a = x.value_string;
+		String b = y.value_string;
+		// TODO(bill): gb_memcompare is used because the strings are UTF-8
+		switch (op) {
+		case Token_CmpEq: return a == b;
+		case Token_NotEq: return a != b;
+		case Token_Lt:    return a <  b;
+		case Token_LtEq:  return a <= b;
+		case Token_Gt:    return a >  b;
+		case Token_GtEq:  return a >= b;
+		}
+		break;
+	}
+
+	case ExactValue_Type:
+		switch (op) {
+		case Token_CmpEq: return are_types_identical(x.value_type, y.value_type);
+		case Token_NotEq: return !are_types_identical(x.value_type, y.value_type);
+		}
+		break;
+	}
+
+	GB_PANIC("Invalid comparison");
+	return false;
+}
@@ -0,0 +1,744 @@
+
+#if defined(GB_COMPILER_MSVC) && defined(GB_ARCH_64_BIT) && defined(GB_CPU_X86)
+	#define MSVC_AMD64_INTRINSICS
+	#include <intrin.h>
+	#pragma intrinsic(_mul128)
+#endif
+
+#define BIT128_U64_HIGHBIT 0x8000000000000000ull
+#define BIT128_U64_BITS62  0x7fffffffffffffffull
+#define BIT128_U64_ALLBITS 0xffffffffffffffffull
+
+
+typedef struct u128 { u64 lo; u64 hi; } u128;
+typedef struct i128 { u64 lo; i64 hi; } i128;
+
+
+static u128 const U128_ZERO = {0, 0};
+static u128 const U128_ONE  = {1, 0};
+static i128 const I128_ZERO = {0, 0};
+static i128 const I128_ONE  = {1, 0};
+static u128 const U128_NEG_ONE = {BIT128_U64_ALLBITS, BIT128_U64_ALLBITS};
+static i128 const I128_NEG_ONE = {BIT128_U64_ALLBITS, cast(i64)BIT128_U64_ALLBITS};
+
+u128 u128_lo_hi      (u64 lo, u64 hi);
+u128 u128_from_u32   (u32 u);
+u128 u128_from_u64   (u64 u);
+u128 u128_from_i64   (i64 u);
+u128 u128_from_f32   (f32 f);
+u128 u128_from_f64   (f64 f);
+u128 u128_from_string(String string);
+
+i128 i128_lo_hi      (u64 lo, i64 hi);
+i128 i128_from_u32   (u32 u);
+i128 i128_from_u64   (u64 u);
+i128 i128_from_i64   (i64 u);
+i128 i128_from_f32   (f32 f);
+i128 i128_from_f64   (f64 f);
+i128 i128_from_string(String string);
+
+u64 u128_to_u64(u128 a);
+i64 u128_to_i64(u128 a);
+f64 u128_to_f64(u128 a);
+i128 u128_to_i128(u128 a);
+
+u64 i128_to_u64(i128 a);
+i64 i128_to_i64(i128 a);
+f64 i128_to_f64(i128 a);
+u128 i128_to_u128(i128 a);
+
+String u128_to_string(u128 a, char *buf, isize len);
+String i128_to_string(i128 a, char *buf, isize len);
+
+i32  u128_cmp    (u128 a, u128 b);
+bool u128_eq     (u128 a, u128 b);
+bool u128_ne     (u128 a, u128 b);
+bool u128_lt     (u128 a, u128 b);
+bool u128_gt     (u128 a, u128 b);
+bool u128_le     (u128 a, u128 b);
+bool u128_ge     (u128 a, u128 b);
+u128 u128_add    (u128 a, u128 b);
+u128 u128_not    (u128 a);
+u128 u128_neg    (u128 a);
+u128 u128_sub    (u128 a, u128 b);
+u128 u128_and    (u128 a, u128 b);
+u128 u128_or     (u128 a, u128 b);
+u128 u128_xor    (u128 a, u128 b);
+u128 u128_and_not(u128 a, u128 b);
+u128 u128_shl    (u128 a, u32 n);
+u128 u128_shr    (u128 a, u32 n);
+u128 u128_mul    (u128 a, u128 b);
+void u128_divide (u128 num, u128 den, u128 *quo, u128 *rem);
+u128 u128_quo    (u128 a, u128 b);
+u128 u128_mod    (u128 a, u128 b);
+
+i128 i128_abs    (i128 a);
+i32  i128_cmp    (i128 a, i128 b);
+bool i128_eq     (i128 a, i128 b);
+bool i128_ne     (i128 a, i128 b);
+bool i128_lt     (i128 a, i128 b);
+bool i128_gt     (i128 a, i128 b);
+bool i128_le     (i128 a, i128 b);
+bool i128_ge     (i128 a, i128 b);
+i128 i128_add    (i128 a, i128 b);
+i128 i128_not    (i128 a);
+i128 i128_neg    (i128 a);
+i128 i128_sub    (i128 a, i128 b);
+i128 i128_and    (i128 a, i128 b);
+i128 i128_or     (i128 a, i128 b);
+i128 i128_xor    (i128 a, i128 b);
+i128 i128_and_not(i128 a, i128 b);
+i128 i128_shl    (i128 a, u32 n);
+i128 i128_shr    (i128 a, u32 n);
+i128 i128_mul    (i128 a, i128 b);
+void i128_divide (i128 num, i128 den, i128 *quo, i128 *rem);
+i128 i128_quo    (i128 a, i128 b);
+i128 i128_mod    (i128 a, i128 b);
+
+bool operator==(u128 const &a, u128 const &b) { return u128_eq(a, b); }
+bool operator!=(u128 const &a, u128 const &b) { return u128_ne(a, b); }
+bool operator< (u128 const &a, u128 const &b) { return u128_lt(a, b); }
+bool operator> (u128 const &a, u128 const &b) { return u128_gt(a, b); }
+bool operator<=(u128 const &a, u128 const &b) { return u128_le(a, b); }
+bool operator>=(u128 const &a, u128 const &b) { return u128_ge(a, b); }
+
+u128 operator+ (u128 const &a, u128 const &b) { return u128_add(a, b); }
+u128 operator- (u128 const &a, u128 const &b) { return u128_sub(a, b); }
+u128 operator* (u128 const &a, u128 const &b) { return u128_mul(a, b); }
+u128 operator/ (u128 const &a, u128 const &b) { return u128_quo(a, b); }
+u128 operator% (u128 const &a, u128 const &b) { return u128_mod(a, b); }
+u128 operator& (u128 const &a, u128 const &b) { return u128_and(a, b); }
+u128 operator| (u128 const &a, u128 const &b) { return u128_or (a, b); }
+u128 operator^ (u128 const &a, u128 const &b) { return u128_xor(a, b); }
+u128 operator~ (u128 const &a)                { return u128_not(a); }
+u128 operator+ (u128 const &a)                { return a; }
+u128 operator- (u128 const &a)                { return u128_neg(a); }
+u128 operator<<(u128 const &a, u32 const &b)  { return u128_shl(a, b); }
+u128 operator>>(u128 const &a, u32 const &b)  { return u128_shr(a, b); }
+
+
+bool operator==(i128 const &a, i128 const &b) { return i128_eq(a, b); }
+bool operator!=(i128 const &a, i128 const &b) { return i128_ne(a, b); }
+bool operator< (i128 const &a, i128 const &b) { return i128_lt(a, b); }
+bool operator> (i128 const &a, i128 const &b) { return i128_gt(a, b); }
+bool operator<=(i128 const &a, i128 const &b) { return i128_le(a, b); }
+bool operator>=(i128 const &a, i128 const &b) { return i128_ge(a, b); }
+
+i128 operator+ (i128 const &a, i128 const &b) { return i128_add(a, b); }
+i128 operator- (i128 const &a, i128 const &b) { return i128_sub(a, b); }
+i128 operator* (i128 const &a, i128 const &b) { return i128_mul(a, b); }
+i128 operator/ (i128 const &a, i128 const &b) { return i128_quo(a, b); }
+i128 operator% (i128 const &a, i128 const &b) { return i128_mod(a, b); }
+i128 operator& (i128 const &a, i128 const &b) { return i128_and(a, b); }
+i128 operator| (i128 const &a, i128 const &b) { return i128_or (a, b); }
+i128 operator^ (i128 const &a, i128 const &b) { return i128_xor(a, b); }
+i128 operator~ (i128 const &a)                { return i128_not(a); }
+i128 operator+ (i128 const &a)                { return a; }
+i128 operator- (i128 const &a)                { return i128_neg(a); }
+i128 operator<<(i128 const &a, u32 b)         { return i128_shl(a, b); }
+i128 operator>>(i128 const &a, u32 b)         { return i128_shr(a, b); }
+
+////////////////////////////////////////////////////////////////
+
+
+u64 bit128__digit_value(Rune r) {
+	if ('0' <= r && r <= '9') {
+		return r - '0';
+	} else if ('a' <= r && r <= 'f') {
+		return r - 'a' + 10;
+	} else if ('A' <= r && r <= 'F') {
+		return r - 'A' + 10;
+	}
+	return 16; // NOTE(bill): Larger than highest possible
+}
+
+u128 u128_lo_hi(u64 lo, u64 hi) {
+	u128 r = {};
+	r.lo = lo;
+	r.hi = hi;
+	return r;
+}
+u128 u128_from_u32(u32 u)       { return u128_lo_hi(cast(u64)u, 0); }
+u128 u128_from_u64(u64 u)       { return u128_lo_hi(cast(u64)u, 0); }
+u128 u128_from_i64(i64 u)       { return u128_lo_hi(cast(u64)u, u < 0 ? -1 : 0); }
+u128 u128_from_f32(f32 f)       { return u128_lo_hi(cast(u64)f, 0); }
+u128 u128_from_f64(f64 f)       { return u128_lo_hi(cast(u64)f, 0); }
+u128 u128_from_string(String string) {
+	// TODO(bill): Allow for numbers with underscores in them
+	u64 base = 10;
+	bool has_prefix = false;
+	if (string.len > 2 && string[0] == '0') {
+		switch (string[1]) {
+		case 'b': base = 2;  has_prefix = true; break;
+		case 'o': base = 8;  has_prefix = true; break;
+		case 'd': base = 10; has_prefix = true; break;
+		case 'z': base = 12; has_prefix = true; break;
+		case 'x': base = 16; has_prefix = true; break;
+		}
+	}
+
+	u8 *text = string.text;
+	isize len = string.len;
+	if (has_prefix) {
+		text += 2;
+		len -= 2;
+	}
+
+	u128 base_ = u128_from_u64(base);
+
+	u128 result = {0};
+	for (isize i = 0; i < len; i++) {
+		Rune r = cast(Rune)text[i];
+		if (r == '_') {
+			continue;
+		}
+		u64 v = bit128__digit_value(r);
+		if (v >= base) {
+			break;
+		}
+		result = u128_mul(result, base_);
+		result = u128_add(result, u128_from_u64(v));
+	}
+	return result;
+}
+
+
+i128 i128_lo_hi(u64 lo, i64 hi) {
+	i128 i;
+	i.lo = lo;
+	i.hi = hi;
+	return i;
+}
+i128 i128_from_u32(u32 u)       { return i128_lo_hi(cast(u64)u, 0); }
+i128 i128_from_u64(u64 u)       { return i128_lo_hi(cast(u64)u, 0); }
+i128 i128_from_i64(i64 u)       { return i128_lo_hi(cast(u64)u, u < 0 ? -1 : 0); }
+i128 i128_from_f32(f32 f)       { return i128_lo_hi(cast(u64)f, 0); }
+i128 i128_from_f64(f64 f)       { return i128_lo_hi(cast(u64)f, 0); }
+i128 i128_from_string(String string) {
+	// TODO(bill): Allow for numbers with underscores in them
+	u64 base = 10;
+	bool has_prefix = false;
+	if (string.len > 2 && string[0] == '0') {
+		switch (string[1]) {
+		case 'b': base = 2;  has_prefix = true; break;
+		case 'o': base = 8;  has_prefix = true; break;
+		case 'd': base = 10; has_prefix = true; break;
+		case 'z': base = 12; has_prefix = true; break;
+		case 'x': base = 16; has_prefix = true; break;
+		}
+	}
+
+	u8 *text = string.text;
+	isize len = string.len;
+	if (has_prefix) {
+		text += 2;
+		len -= 2;
+	}
+
+	i128 base_ = i128_from_u64(base);
+
+	i128 result = {0};
+	for (isize i = 0; i < len; i++) {
+		Rune r = cast(Rune)text[i];
+		if (r == '_') {
+			continue;
+		}
+		u64 v = bit128__digit_value(r);
+		if (v >= base) {
+			break;
+		}
+		result = i128_mul(result, base_);
+		result = i128_add(result, i128_from_u64(v));
+	}
+
+	return result;
+}
+
+
+
+u64 u128_to_u64(u128 a) {
+	return (a.lo&BIT128_U64_BITS62) | (a.hi&BIT128_U64_HIGHBIT);
+}
+i64 u128_to_i64(u128 a) {
+	return a.lo;
+}
+f64 u128_to_f64(u128 a) {
+	if (a.hi >= 0) {
+		return (cast(f64)a.hi * 18446744073709551616.0) + cast(f64)a.lo;
+	}
+	i64 h = cast(i64)a.hi;
+	u64 l = a.lo;
+	h = ~h;
+	l = ~l;
+	l += 1;
+	if (l == 0) {
+		h += 1;
+	}
+
+	return -((cast(f64)h * 18446744073709551616.0) + cast(f64)l);
+}
+i128 u128_to_i128(u128 a) {
+	return *cast(i128 *)&a;
+}
+
+
+
+
+u64 i128_to_u64(i128 a) {
+	return (a.lo&BIT128_U64_BITS62) | (a.hi&BIT128_U64_HIGHBIT);
+}
+i64 i128_to_i64(i128 a) {
+	return cast(i64)a.lo;
+}
+f64 i128_to_f64(i128 a) {
+	if (a.hi >= 0) {
+		return (cast(f64)a.hi * 18446744073709551616.0) + cast(f64)a.lo;
+	}
+	i64 h = a.hi;
+	u64 l = a.lo;
+	h = ~h;
+	l = ~l;
+	l += 1;
+	if (l == 0) {
+		h += 1;
+	}
+
+	return -((cast(f64)h * 18446744073709551616.0) + cast(f64)l);
+}
+u128 i128_to_u128(i128 a) {
+	return *cast(u128 *)&a;
+}
+
+
+
+String u128_to_string(u128 v, char *out_buf, isize out_buf_len) {
+	char buf[200] = {0};
+	isize i = gb_size_of(buf);
+
+	u128 b = u128_from_u64(10);;
+	while (u128_ge(v, b)) {
+		buf[--i] = gb__num_to_char_table[u128_to_i64(u128_mod(v, b))];
+		v = u128_quo(v, b);
+	}
+	buf[--i] = gb__num_to_char_table[u128_to_i64(u128_mod(v, b))];
+
+	isize len = gb_min(gb_size_of(buf)-i, out_buf_len);
+	gb_memcopy(out_buf, &buf[i], len);
+	return make_string(cast(u8 *)out_buf, len);
+}
+String i128_to_string(i128 a, char *out_buf, isize out_buf_len) {
+	char buf[200] = {0};
+	isize i = gb_size_of(buf);
+	bool negative = false;
+	if (i128_lt(a, I128_ZERO)) {
+		negative = true;
+		a = i128_neg(a);
+	}
+
+	u128 v = *cast(u128 *)&a;
+	u128 b = u128_from_u64(10);;
+	while (u128_ge(v, b)) {
+		buf[--i] = gb__num_to_char_table[u128_to_i64(u128_mod(v, b))];
+		v = u128_quo(v, b);
+	}
+	buf[--i] = gb__num_to_char_table[u128_to_i64(u128_mod(v, b))];
+
+	if (negative) {
+		buf[--i] = '-';
+	}
+
+	isize len = gb_min(gb_size_of(buf)-i, out_buf_len);
+	gb_memcopy(out_buf, &buf[i], len);
+	return make_string(cast(u8 *)out_buf, len);
+}
+
+
+
+////////////////////////////////////////////////////////////////
+
+i32 u128_cmp(u128 a, u128 b) {
+	if (a.hi == b.hi && b.lo == b.lo) {
+		return 0;
+	}
+	if (a.hi == b.hi) {
+		return a.lo < b.lo ? -1 : +1;
+	}
+	return a.hi < b.hi ? -1 : +1;
+}
+
+bool u128_eq(u128 a, u128 b) { return a.hi == b.hi && a.lo == b.lo; }
+bool u128_ne(u128 a, u128 b) { return !u128_eq(a, b); }
+bool u128_lt(u128 a, u128 b) { return a.hi == b.hi ? a.lo < b.lo : a.hi < b.hi; }
+bool u128_gt(u128 a, u128 b) { return a.hi == b.hi ? a.lo > b.lo : a.hi > b.hi; }
+bool u128_le(u128 a, u128 b) { return !u128_gt(a, b); }
+bool u128_ge(u128 a, u128 b) { return !u128_lt(a, b); }
+
+u128 u128_add(u128 a, u128 b) {
+	u128 old_a = a;
+	a.lo += b.lo;
+	a.hi += b.hi;
+	if (a.lo < old_a.lo) {
+		a.hi += 1;
+	}
+	return a;
+}
+u128 u128_not(u128 a) { return u128_lo_hi(~a.lo, ~a.hi); }
+
+u128 u128_neg(u128 a) {
+	return u128_add(u128_not(a), u128_from_u64(1));
+}
+u128 u128_sub(u128 a, u128 b) {
+	return u128_add(a, u128_neg(b));
+}
+u128 u128_and(u128 a, u128 b) { return u128_lo_hi(a.lo&b.lo, a.hi&b.hi); }
+u128 u128_or (u128 a, u128 b) { return u128_lo_hi(a.lo|b.lo, a.hi|b.hi); }
+u128 u128_xor(u128 a, u128 b) { return u128_lo_hi(a.lo^b.lo, a.hi^b.hi); }
+u128 u128_and_not(u128 a, u128 b) { return u128_lo_hi(a.lo&(~b.lo), a.hi&(~b.hi)); }
+
+
+u128 u128_shl(u128 a, u32 n) {
+	if (n >= 128) {
+		return u128_lo_hi(0, 0);
+	}
+#if 0 && defined(MSVC_AMD64_INTRINSICS)
+	a.hi = __shiftleft128(a.lo, a.hi, n);
+	a.lo = a.lo << n;
+	return a;
+#else
+	if (n >= 64) {
+		n -= 64;
+		a.hi = a.lo;
+		a.lo = 0;
+	}
+
+	if (n != 0) {
+		u64 mask = ~(BIT128_U64_ALLBITS >> n);
+
+		a.hi <<= n;
+		a.hi |= (a.lo&mask) >> (64 - n);
+		a.lo <<= n;
+	}
+	return a;
+#endif
+}
+
+u128 u128_shr(u128 a, u32 n) {
+	if (n >= 128) {
+		return u128_lo_hi(0, 0);
+	}
+#if 0 && defined(MSVC_AMD64_INTRINSICS)
+	a.lo = __shiftright128(a.lo, a.hi, n);
+	a.hi = a.hi >> n;
+	return a;
+#else
+	if (n >= 64) {
+		n -= 64;
+		a.lo = a.hi;
+		a.hi = 0;
+	}
+
+	if (n != 0) {
+		u64 mask = ~(BIT128_U64_ALLBITS << n);
+		a.lo >>= n;
+		a.lo |= (a.hi&mask) << (64 - n);
+		a.hi >>= n;
+	}
+	return a;
+#endif
+}
+
+
+u128 u128_mul(u128 a, u128 b) {
+	if (a.lo == 0 && a.hi == 0) {
+		return u128_from_u64(0);
+	} else if (b.lo == 0 && b.hi == 0) {
+		return u128_from_u64(0);
+	}
+	if (u128_eq(a, U128_ONE)) {
+		return b;
+	}
+	if (u128_eq(b, U128_ONE)) {
+		return a;
+	}
+
+
+#if defined(MSVC_AMD64_INTRINSICS)
+	if (a.hi == 0 && b.hi == 0) {
+		a.lo = _umul128(a.lo, b.lo, &a.hi);
+		return a;
+	}
+#endif
+
+	u128 res = {0};
+	u128 t = b;
+	for (u32 i = 0; i < 128; i++) {
+		if ((t.lo&1) != 0) {
+			res = u128_add(res, u128_shl(a, i));
+		}
+
+		t = u128_shr(t, 1);
+	}
+
+	return res;
+}
+
+bool u128_hibit(u128 const &d) { return (d.hi & BIT128_U64_HIGHBIT) != 0; }
+bool i128_hibit(i128 const &d) { return d.hi < 0; }
+
+void u128_divide(u128 a, u128 b, u128 *quo, u128 *rem) {
+	if (u128_eq(b, U128_ZERO)) {
+		if (quo) *quo = u128_from_u64(a.lo/b.lo);
+		if (rem) *rem = U128_ZERO;
+		return;
+	}
+	if (a.hi == 0 && b.hi == 0) {
+		if (quo) *quo = u128_from_u64(a.lo/b.lo);
+		if (rem) *rem = u128_from_u64(a.lo%b.lo);
+		return;
+	}
+	u128 r = a;
+	u128 d = b;
+	u128 x = U128_ONE;
+	u128 q = U128_ZERO;
+
+	while (u128_ge(r, d) && !u128_hibit(d)) {
+		x = u128_shl(x, 1);
+		d = u128_shl(d, 1);
+	}
+
+	while (u128_ne(x, U128_ZERO)) {
+		if (u128_ge(r, d)) {
+			r = u128_sub(r, d);
+			q = u128_or(q, x);
+		}
+
+		x = u128_shr(x, 1);
+		d = u128_shr(d, 1);
+	}
+
+	if (quo) *quo = q;
+	if (rem) *rem = r;
+}
+
+u128 u128_quo(u128 a, u128 b) {
+	if (a.hi == 0 && b.hi == 0) {
+		return u128_from_u64(a.lo/b.lo);
+	}
+
+	u128 res = {0};
+	u128_divide(a, b, &res, nullptr);
+	return res;
+}
+u128 u128_mod(u128 a, u128 b) {
+	if (a.hi == 0 && b.hi == 0) {
+		return u128_from_u64(a.lo%b.lo);
+	}
+	u128 res = {0};
+	u128_divide(a, b, nullptr, &res);
+	return res;
+}
+
+////////////////////////////////////////////////////////////////
+
+i128 i128_abs(i128 a) {
+	if ((a.hi&BIT128_U64_HIGHBIT) != 0) {
+		return i128_neg(a);
+	}
+	return a;
+}
+
+i32 i128_cmp(i128 a, i128 b) {
+	if (a.hi == b.hi && b.lo == b.lo) {
+		return 0;
+	}
+	if (a.hi == b.hi) {
+		return a.lo < b.lo ? -1 : +1;
+	}
+	return a.hi < b.hi ? -1 : +1;
+}
+
+bool i128_eq(i128 a, i128 b) { return a.hi == b.hi && a.lo == b.lo; }
+bool i128_ne(i128 a, i128 b) { return !i128_eq(a, b); }
+bool i128_lt(i128 a, i128 b) { return a.hi == b.hi ? a.lo < b.lo : a.hi < b.hi; }
+bool i128_gt(i128 a, i128 b) { return a.hi == b.hi ? a.lo > b.lo : a.hi > b.hi; }
+bool i128_le(i128 a, i128 b) { return a.hi == b.hi ? a.lo <= b.lo : a.hi <= b.hi; }
+bool i128_ge(i128 a, i128 b) { return a.hi == b.hi ? a.lo >= b.lo : a.hi >= b.hi; }
+
+i128 i128_add(i128 a, i128 b) {
+	i128 old_a = a;
+	a.lo += b.lo;
+	a.hi += b.hi;
+	if (a.lo < old_a.lo) {
+		a.hi += 1;
+	}
+	return a;
+}
+i128 i128_not(i128 a) { return i128_lo_hi(~a.lo, ~a.hi); }
+
+i128 i128_neg(i128 a) {
+	return i128_add(i128_not(a), i128_from_u64(1));
+}
+i128 i128_sub(i128 a, i128 b) {
+	return i128_add(a, i128_neg(b));
+}
+i128 i128_and(i128 a, i128 b) { return i128_lo_hi(a.lo&b.lo, a.hi&b.hi); }
+i128 i128_or (i128 a, i128 b) { return i128_lo_hi(a.lo|b.lo, a.hi|b.hi); }
+i128 i128_xor(i128 a, i128 b) { return i128_lo_hi(a.lo^b.lo, a.hi^b.hi); }
+i128 i128_and_not(i128 a, i128 b) { return i128_lo_hi(a.lo&(~b.lo), a.hi&(~b.hi)); }
+
+
+i128 i128_shl(i128 a, u32 n) {
+	if (n >= 128) {
+		return i128_lo_hi(0, 0);
+	}
+
+#if 0 && defined(MSVC_AMD64_INTRINSICS)
+	a.hi = __shiftleft128(a.lo, a.hi, n);
+	a.lo = a.lo << n;
+	return a;
+#else
+	if (n >= 64) {
+		n -= 64;
+		a.hi = a.lo;
+		a.lo = 0;
+	}
+
+	if (n != 0) {
+		u64 mask = ~(BIT128_U64_ALLBITS >> n);
+
+		a.hi <<= n;
+		a.hi |= (a.lo&mask) >> (64 - n);
+		a.lo <<= n;
+	}
+	return a;
+#endif
+}
+
+i128 i128_shr(i128 a, u32 n) {
+	if (n >= 128) {
+		return i128_lo_hi(0, 0);
+	}
+
+#if 0 && defined(MSVC_AMD64_INTRINSICS)
+	a.lo = __shiftright128(a.lo, a.hi, n);
+	a.hi = a.hi >> n;
+	return a;
+#else
+	if (n >= 64) {
+		n -= 64;
+		a.lo = a.hi;
+		a.hi = 0;
+	}
+
+	if (n != 0) {
+		u64 mask = ~(BIT128_U64_ALLBITS << n);
+		a.lo >>= n;
+		a.lo |= (a.hi&mask) << (64 - n);
+		a.hi >>= n;
+	}
+	return a;
+#endif
+}
+
+
+i128 i128_mul(i128 a, i128 b) {
+	if (a.lo == 0 && a.hi == 0) {
+		return i128_from_u64(0);
+	} else if (b.lo == 0 && b.hi == 0) {
+		return i128_from_u64(0);
+	}
+	if (i128_eq(a, I128_ONE)) {
+		return b;
+	}
+	if (i128_eq(b, I128_ONE)) {
+		return a;
+	}
+
+#if defined(MSVC_AMD64_INTRINSICS)
+	if (a.hi == 0 && b.hi == 0) {
+		a.lo = _mul128(a.lo, b.lo, &a.hi);
+		return a;
+	}
+#endif
+
+	i128 res = {0};
+	i128 t = b;
+	for (u32 i = 0; i < 128; i++) {
+		if ((t.lo&1) != 0) {
+			res = i128_add(res, i128_shl(a, i));
+		}
+
+		t = i128_shr(t, 1);
+	}
+
+	return res;
+}
+
+void i128_divide(i128 a, i128 b, i128 *quo_, i128 *rem_) {
+	// IMPORTANT TODO(bill): Optimize this i128 division calculation
+	i128 iquo = {0};
+	i128 irem = {0};
+	if (a.hi == 0 && b.hi == 0) {
+		u64 q = a.lo / b.lo;
+		u64 r = a.lo % b.lo;
+		iquo = i128_from_u64(q);
+		irem = i128_from_u64(r);
+	} else if ((~a.hi) == 0 && (~b.hi) == 0) {
+		i64 x = i128_to_i64(a);
+		i64 y = i128_to_i64(b);
+		i64 q = x / y;
+		i64 r = x % y;
+		iquo = i128_from_i64(q);
+		irem = i128_from_i64(r);
+	} else if (a.hi > 0 || b.hi > 0) {
+		u128 q, r = {0};
+		u128_divide(*cast(u128 *)&a, *cast(u128 *)&b, &q, &r);
+		iquo = *cast(i128 *)&q;
+		irem = *cast(i128 *)&r;
+	} else if (i128_eq(b, I128_ZERO)) {
+		iquo = i128_from_u64(a.lo/b.lo);
+	} else {
+		i32 rem_sign = 1;
+		i32 quo_sign = 1;
+		if (i128_lt(a, I128_ZERO)) {
+			a = i128_neg(a);
+			rem_sign = -1;
+		}
+		if (i128_lt(b, I128_ZERO)) {
+			b = i128_neg(b);
+			quo_sign = -1;
+		}
+		quo_sign *= rem_sign;
+
+		iquo = a;
+
+		for (isize i = 0; i < 128; i++) {
+			irem = i128_shl(irem, 1);
+			if (i128_lt(iquo, I128_ZERO)) {
+				irem.lo |= 1;
+			}
+			iquo = i128_shl(iquo, 1);
+			if (i128_ge(irem, b)) {
+				irem = i128_sub(irem, b);
+				iquo = i128_add(iquo, I128_ONE);
+			}
+		}
+
+		if (quo_sign < 0) iquo = i128_neg(iquo);
+		if (rem_sign < 0) irem = i128_neg(irem);
+	}
+
+	if (quo_) *quo_ = iquo;
+	if (rem_) *rem_ = irem;
+}
+
+i128 i128_quo(i128 a, i128 b) {
+	i128 res = {0};
+	i128_divide(a, b, &res, nullptr);
+	return res;
+}
+i128 i128_mod(i128 a, i128 b) {
+	i128 res = {0};
+	i128_divide(a, b, nullptr, &res);
+	return res;
+}
@@ -1,6 +1,6 @@
 // Optimizations for the IR code

-void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
+void ir_opt_add_operands(Array<irValue *> *ops, irInstr *i) {
 	switch (i->kind) {
 	case irInstr_Comment:
 		break;
@@ -27,9 +27,6 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
 		array_add(ops, i->PtrOffset.address);
 		array_add(ops, i->PtrOffset.offset);
 		break;
-	case irInstr_ArrayExtractValue:
-		array_add(ops, i->ArrayExtractValue.address);
-		break;
 	case irInstr_StructExtractValue:
 		array_add(ops, i->StructExtractValue.address);
 		break;
@@ -42,7 +39,7 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
 		array_add(ops, i->If.cond);
 		break;
 	case irInstr_Return:
-		if (i->Return.value != NULL) {
+		if (i->Return.value != nullptr) {
 			array_add(ops, i->Return.value);
 		}
 		break;
@@ -51,7 +48,7 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
 		break;
 	case irInstr_Phi:
 		for_array(j, i->Phi.edges) {
-			array_add(ops, i->Phi.edges.e[j]);
+			array_add(ops, i->Phi.edges[j]);
 		}
 		break;
 	case irInstr_Unreachable:
@@ -69,20 +66,22 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
 			array_add(ops, i->Call.args[j]);
 		}
 		break;
-	case irInstr_VectorExtractElement:
-		array_add(ops, i->VectorExtractElement.vector);
-		array_add(ops, i->VectorExtractElement.index);
-		break;
-	case irInstr_VectorInsertElement:
-		array_add(ops, i->VectorInsertElement.vector);
-		array_add(ops, i->VectorInsertElement.elem);
-		array_add(ops, i->VectorInsertElement.index);
-		break;
-	case irInstr_VectorShuffle:
-		array_add(ops, i->VectorShuffle.vector);
-		break;
+	// case irInstr_VectorExtractElement:
+		// array_add(ops, i->VectorExtractElement.vector);
+		// array_add(ops, i->VectorExtractElement.index);
+		// break;
+	// case irInstr_VectorInsertElement:
+		// array_add(ops, i->VectorInsertElement.vector);
+		// array_add(ops, i->VectorInsertElement.elem);
+		// array_add(ops, i->VectorInsertElement.index);
+		// break;
+	// case irInstr_VectorShuffle:
+		// array_add(ops, i->VectorShuffle.vector);
+		// break;
 	case irInstr_StartupRuntime:
 		break;
+
+	#if 0
 	case irInstr_BoundsCheck:
 		array_add(ops, i->BoundsCheck.index);
 		array_add(ops, i->BoundsCheck.len);
@@ -91,6 +90,7 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {
 		array_add(ops, i->SliceBoundsCheck.low);
 		array_add(ops, i->SliceBoundsCheck.high);
 		break;
+	#endif
 	}
 }

@@ -100,24 +100,24 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) {

 void ir_opt_block_replace_pred(irBlock *b, irBlock *from, irBlock *to) {
 	for_array(i, b->preds) {
-		irBlock *pred = b->preds.e[i];
+		irBlock *pred = b->preds[i];
 		if (pred == from) {
-			b->preds.e[i] = to;
+			b->preds[i] = to;
 		}
 	}
 }

 void ir_opt_block_replace_succ(irBlock *b, irBlock *from, irBlock *to) {
 	for_array(i, b->succs) {
-		irBlock *succ = b->succs.e[i];
+		irBlock *succ = b->succs[i];
 		if (succ == from) {
-			b->succs.e[i] = to;
+			b->succs[i] = to;
 		}
 	}
 }

 bool ir_opt_block_has_phi(irBlock *b) {
-	return b->instrs.e[0]->Instr.kind == irInstr_Phi;
+	return b->instrs[0]->Instr.kind == irInstr_Phi;
 }


@@ -129,10 +129,10 @@ bool ir_opt_block_has_phi(irBlock *b) {



-irValueArray ir_get_block_phi_nodes(irBlock *b) {
-	irValueArray phis = {0};
+Array<irValue *> ir_get_block_phi_nodes(irBlock *b) {
+	Array<irValue *> phis = {0};
 	for_array(i, b->instrs) {
-		irInstr *instr = &b->instrs.e[i]->Instr;
+		irInstr *instr = &b->instrs[i]->Instr;
 		if (instr->kind != irInstr_Phi) {
 			phis = b->instrs;
 			phis.count = i;
@@ -143,22 +143,22 @@ irValueArray ir_get_block_phi_nodes(irBlock *b) {
 }

 void ir_remove_pred(irBlock *b, irBlock *p) {
-	irValueArray phis = ir_get_block_phi_nodes(b);
+	Array<irValue *> phis = ir_get_block_phi_nodes(b);
 	isize i = 0;
 	for_array(j, b->preds) {
-		irBlock *pred = b->preds.e[j];
+		irBlock *pred = b->preds[j];
 		if (pred != p) {
-			b->preds.e[i] = b->preds.e[j];
+			b->preds[i] = b->preds[j];
 			for_array(k, phis) {
-				irInstrPhi *phi = &phis.e[k]->Instr.Phi;
-				phi->edges.e[i] = phi->edges.e[j];
+				irInstrPhi *phi = &phis[k]->Instr.Phi;
+				phi->edges[i] = phi->edges[j];
 			}
 			i++;
 		}
 	}
 	b->preds.count = i;
 	for_array(k, phis) {
-		irInstrPhi *phi = &phis.e[k]->Instr.Phi;
+		irInstrPhi *phi = &phis[k]->Instr.Phi;
 		phi->edges.count = i;
 	}

@@ -167,13 +167,13 @@ void ir_remove_pred(irBlock *b, irBlock *p) {
 void ir_remove_dead_blocks(irProcedure *proc) {
 	isize j = 0;
 	for_array(i, proc->blocks) {
-		irBlock *b = proc->blocks.e[i];
-		if (b == NULL) {
+		irBlock *b = proc->blocks[i];
+		if (b == nullptr) {
 			continue;
 		}
 		// NOTE(bill): Swap order
-		b->index = j;
-		proc->blocks.e[j++] = b;
+		b->index = cast(i32)j;
+		proc->blocks[j++] = b;
 	}
 	proc->blocks.count = j;
 }
@@ -183,7 +183,7 @@ void ir_mark_reachable(irBlock *b) {
 	isize const BLACK = -1;
 	b->index = BLACK;
 	for_array(i, b->succs) {
-		irBlock *succ = b->succs.e[i];
+		irBlock *succ = b->succs[i];
 		if (succ->index == WHITE) {
 			ir_mark_reachable(succ);
 		}
@@ -194,23 +194,23 @@ void ir_remove_unreachable_blocks(irProcedure *proc) {
 	isize const WHITE =  0;
 	isize const BLACK = -1;
 	for_array(i, proc->blocks) {
-		proc->blocks.e[i]->index = WHITE;
+		proc->blocks[i]->index = WHITE;
 	}

-	ir_mark_reachable(proc->blocks.e[0]);
+	ir_mark_reachable(proc->blocks[0]);

 	for_array(i, proc->blocks) {
-		irBlock *b = proc->blocks.e[i];
+		irBlock *b = proc->blocks[i];
 		if (b->index == WHITE) {
 			for_array(j, b->succs) {
-				irBlock *c = b->succs.e[j];
+				irBlock *c = b->succs[j];
 				if (c->index == BLACK) {
 					ir_remove_pred(c, b);
 				}
 			}
 			// NOTE(bill): Mark as empty but don't actually free it
 			// As it's been allocated with an arena
-			proc->blocks.e[i] = NULL;
+			proc->blocks[i] = nullptr;
 		}
 	}
 	ir_remove_dead_blocks(proc);
@@ -220,7 +220,7 @@ bool ir_opt_block_fusion(irProcedure *proc, irBlock *a) {
 	if (a->succs.count != 1) {
 		return false;
 	}
-	irBlock *b = a->succs.e[0];
+	irBlock *b = a->succs[0];
 	if (b->preds.count != 1) {
 		return false;
 	}
@@ -231,21 +231,21 @@ bool ir_opt_block_fusion(irProcedure *proc, irBlock *a) {

 	array_pop(&a->instrs); // Remove branch at end
 	for_array(i, b->instrs) {
-		array_add(&a->instrs, b->instrs.e[i]);
-		ir_set_instr_parent(b->instrs.e[i], a);
+		array_add(&a->instrs, b->instrs[i]);
+		ir_set_instr_block(b->instrs[i], a);
 	}

 	array_clear(&a->succs);
 	for_array(i, b->succs) {
-		array_add(&a->succs, b->succs.e[i]);
+		array_add(&a->succs, b->succs[i]);
 	}

 	// Fix preds links
 	for_array(i, b->succs) {
-		ir_opt_block_replace_pred(b->succs.e[i], b, a);
+		ir_opt_block_replace_pred(b->succs[i], b, a);
 	}

-	proc->blocks.e[b->index] = NULL;
+	proc->blocks[b->index] = nullptr;
 	return true;
 }

@@ -257,11 +257,11 @@ void ir_opt_blocks(irProcedure *proc) {
 	while (changed) {
 		changed = false;
 		for_array(i, proc->blocks) {
-			irBlock *b = proc->blocks.e[i];
-			if (b == NULL) {
+			irBlock *b = proc->blocks[i];
+			if (b == nullptr) {
 				continue;
 			}
-			GB_ASSERT(b->index == i);
+			GB_ASSERT_MSG(b->index == i, "%d, %td", b->index, i);

 			if (ir_opt_block_fusion(proc, b)) {
 				changed = true;
@@ -276,21 +276,21 @@ void ir_opt_blocks(irProcedure *proc) {
 void ir_opt_build_referrers(irProcedure *proc) {
 	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena);

-	irValueArray ops = {0}; // NOTE(bill): Act as a buffer
-	array_init_reserve(&ops, proc->module->tmp_allocator, 64); // HACK(bill): This _could_ overflow the temp arena
+	Array<irValue *> ops = {0}; // NOTE(bill): Act as a buffer
+	array_init(&ops, proc->module->tmp_allocator, 64); // HACK(bill): This _could_ overflow the temp arena
 	for_array(i, proc->blocks) {
-		irBlock *b = proc->blocks.e[i];
+		irBlock *b = proc->blocks[i];
 		for_array(j, b->instrs) {
-			irValue *instr = b->instrs.e[j];
+			irValue *instr = b->instrs[j];
 			array_clear(&ops);
 			ir_opt_add_operands(&ops, &instr->Instr);
 			for_array(k, ops) {
-				irValue *op = ops.e[k];
-				if (op == NULL) {
+				irValue *op = ops[k];
+				if (op == nullptr) {
 					continue;
 				}
-				irValueArray *refs = ir_value_referrers(op);
-				if (refs != NULL) {
+				Array<irValue *> *refs = ir_value_referrers(op);
+				if (refs != nullptr) {
 					array_add(refs, instr);
 				}
 			}
@@ -325,10 +325,10 @@ i32 ir_lt_depth_first_search(irLTState *lt, irBlock *p, i32 i, irBlock **preorde
 	preorder[i] = p;
 	p->dom.pre = i++;
 	lt->sdom[p->index] = p;
-	ir_lt_link(lt, NULL, p);
+	ir_lt_link(lt, nullptr, p);
 	for_array(index, p->succs) {
-		irBlock *q = p->succs.e[index];
-		if (lt->sdom[q->index] == NULL) {
+		irBlock *q = p->succs[index];
+		if (lt->sdom[q->index] == nullptr) {
 			lt->parent[q->index] = p;
 			i = ir_lt_depth_first_search(lt, q, i, preorder);
 		}
@@ -339,7 +339,7 @@ i32 ir_lt_depth_first_search(irLTState *lt, irBlock *p, i32 i, irBlock **preorde
 irBlock *ir_lt_eval(irLTState *lt, irBlock *v) {
 	irBlock *u = v;
 	for (;
-	     lt->ancestor[v->index] != NULL;
+	     lt->ancestor[v->index] != nullptr;
 	     v = lt->ancestor[v->index]) {
 		if (lt->sdom[v->index]->dom.pre < lt->sdom[u->index]->dom.pre) {
 			u = v;
@@ -357,7 +357,7 @@ irDomPrePost ir_opt_number_dom_tree(irBlock *v, i32 pre, i32 post) {

 	v->dom.pre = pre++;
 	for_array(i, v->dom.children) {
-		result = ir_opt_number_dom_tree(v->dom.children.e[i], result.pre, result.post);
+		result = ir_opt_number_dom_tree(v->dom.children[i], result.pre, result.post);
 	}
 	v->dom.post = post++;

@@ -373,7 +373,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {

 	gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena);

-	isize n = proc->blocks.count;
+	i32 n = cast(i32)proc->blocks.count;
 	irBlock **buf = gb_alloc_array(proc->module->tmp_allocator, irBlock *, 5*n);

 	irLTState lt = {0};
@@ -384,7 +384,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {

 	irBlock **preorder = &buf[3*n];
 	irBlock **buckets  = &buf[4*n];
-	irBlock *root = proc->blocks.e[0];
+	irBlock *root = proc->blocks[0];

 	// Step 1 - number vertices
 	i32 pre_num = ir_lt_depth_first_search(&lt, root, 0, preorder);
@@ -406,7 +406,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
 		// Step 2 - Compute all sdoms
 		lt.sdom[w->index] = lt.parent[w->index];
 		for_array(pred_index, w->preds) {
-			irBlock *v = w->preds.e[pred_index];
+			irBlock *v = w->preds[pred_index];
 			irBlock *u = ir_lt_eval(&lt, v);
 			if (lt.sdom[u->index]->dom.pre < lt.sdom[w->index]->dom.pre) {
 				lt.sdom[w->index] = lt.sdom[u->index];
@@ -432,7 +432,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
 	for (isize i = 1; i < n; i++) {
 		irBlock *w = preorder[i];
 		if (w == root) {
-			w->dom.idom = NULL;
+			w->dom.idom = nullptr;
 		} else {
 			// Weird tree relationships here!

@@ -441,7 +441,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
 			}

 			// Calculate children relation as inverse of idom
-			if (w->dom.idom->dom.children.e == NULL) {
+			if (w->dom.idom->dom.children.data == nullptr) {
 				// TODO(bill): Is this good enough for memory allocations?
 				array_init(&w->dom.idom->dom.children, heap_allocator());
 			}
@@ -464,13 +464,13 @@ void ir_opt_tree(irGen *s) {
 	s->opt_called = true;

 	for_array(member_index, s->module.procs) {
-		irProcedure *proc = s->module.procs.e[member_index];
+		irProcedure *proc = s->module.procs[member_index];
 		if (proc->blocks.count == 0) { // Prototype/external procedure
 			continue;
 		}

 		ir_opt_blocks(proc);
-	#if 1
+	#if 0
 		ir_opt_build_referrers(proc);
 		ir_opt_build_dom_tree(proc);

--- a/Show More
+++ b/Show More