diff --git a/compiler/builtins/docs/Int.roc b/compiler/builtins/docs/Int.roc
index e6e235db2b..2e0d54b87d 100644
--- a/compiler/builtins/docs/Int.roc
+++ b/compiler/builtins/docs/Int.roc
@@ -215,7 +215,7 @@ asc : Int a, Int a -> [ Eq, Lt, Gt ]
 ##
 desc : Int a, Int a -> [ Eq, Lt, Gt ]
 
-## TODO should we offer hash32 etc even if it has to do a hash64 and truncate?
+## TODO should we offer hash32 etc even if someday it has to do a hash64 and truncate?
 ##
 ## CAUTION: This function may give different answers in future releases of Roc,
 ## so be aware that if you rely on the exact answer this gives today, your
@@ -224,16 +224,16 @@ hash64 : a -> U64
 
 ## Limits
 
-## The highest number that can be stored in an #Int without overflowing its
+## The highest number that can be stored in an #I32 without overflowing its
 ## available memory and crashing.
 ##
-## Note that this is smaller than the positive version of #Int.lowest,
-## which means if you call #Num.abs on #Int.lowest, it will overflow and crash!
-highest : Int *
+## Note that this is smaller than the positive version of #Int.lowestI32
+## which means if you call #Num.abs on #Int.lowestI32, it will overflow and crash!
+highestI32 : I32
 
-## The lowest number that can be stored in an #Int without overflowing its
+## The lowest number that can be stored in an #I32 without overflowing its
 ## available memory and crashing.
 ##
 ## Note that the positive version of this number is this is larger than
-## #Int.highest, which means if you call #Num.abs on #Int.lowest, it will overflow and crash!
-lowest : Int *
+## #Int.highestI32, which means if you call #Num.abs on #Int.lowestI32, it will overflow and crash!
+lowest : I32
diff --git a/compiler/builtins/docs/Str.roc b/compiler/builtins/docs/Str.roc
index 450189640c..52460d485a 100644
--- a/compiler/builtins/docs/Str.roc
+++ b/compiler/builtins/docs/Str.roc
@@ -2,12 +2,58 @@ api Str provides Str, isEmpty, join
 
 ## Types
 
-## A sequence of [UTF-8](https://en.wikipedia.org/wiki/UTF-8) text characters.
+## A [Unicode](https://unicode.org) text value.
 ##
-## One #Str can be up to 2 gigabytes in size. If you need to store larger
-## strings than that, you can split them into smaller chunks and operate
-## on those instead of on one large #Str. This often runs faster in practice,
-## even for strings much smaller than 2 gigabytes.
+## Dealing with text is deep topic, so by design, Roc's `Str` module sticks
+## to the basics. For more advanced use cases like working with raw [code points](https://unicode.org/glossary/#code_point),
+## see the [roc/unicode](roc/unicode) package, and for locale-specific text
+## functions (including capitalization, as capitalization rules vary by locale)
+## see the [roc/locale](roc/locale) package.
+##
+## ### Unicode
+##
+## Unicode can represent text values which span multiple languages, symbols, and emoji.
+## Here are some valid Roc strings:
+##
+## * "Roc"
+## * "鹏"
+## * "🐦"
+##
+## Every Unicode string is a sequence of [grapheme clusters](https://unicode.org/glossary/#grapheme_cluster).
+## A grapheme cluster corresponds to what a person reading a string might call
+## a "character", but because the term "character" is used to mean many different
+## concepts across different programming languages, we intentionally avoid it in Roc.
+## Instead, we use the term "clusters" as a shorthand for "grapheme clusters."
+##
+## You can get the number of grapheme clusters in a string by calling `Str.countClusters` on it:
+##
+## >>> Str.countClusters "Roc"
+##
+## >>> Str.countClusters "音乐"
+##
+## >>> Str.countClusters "👍"
+##
+## > The `countClusters` function traverses the entire string to calculate its answer,
+## > so it's much better for performance to use `Str.isEmpty` instead of
+## > calling `Str.countClusters` and checking whether the count was `0`.
+##
+## ### Escape characters
+##
+## ### String interpolation
+##
+## ### Encoding
+##
+## Roc strings are not coupled to any particular
+## [encoding](https://en.wikipedia.org/wiki/Character_encoding). As it happens,
+## they are currently encoded in UTF-8, but this module is intentionally designed
+## not to rely on that implementation detail so that a future release of Roc can
+## potentially change it without breaking existing Roc applications.
+##
+## This module has functions to can convert a #Str to a #List of raw [code unit](https://unicode.org/glossary/#code_unit)
+## integers (not to be confused with the [code points](https://unicode.org/glossary/#code_point)
+## mentioned earlier) in a particular encoding. If you need encoding-specific functions,
+## you should take a look at the [roc/unicode](roc/unicode) package.
+## It has many more tools than this module does!
 Str : [ @Str ]
 
 ## Convert
@@ -21,10 +67,22 @@ Str : [ @Str ]
 ## but it's recommended to pass much smaller numbers instead.
 ##
 ## Passing a negative number for decimal places is equivalent to passing 0.
-decimal : Int, Float -> Str
+decimal : Float *, ULen -> Str
 
 ## Convert an #Int to a string.
-int : Float -> Str
+int : Int * -> Str
+
+## Split a string around a separator.
+##
+## >>> Str.splitClusters "1,2,3" ","
+##
+## Passing `""` for the separator is not useful; it returns the original string
+## wrapped in a list.
+##
+## >>> Str.splitClusters "1,2,3" ""
+##
+## To split a string into its grapheme clusters, use #Str.clusters
+split : Str, Str -> List Str
 
 ## Check
 
@@ -58,4 +116,196 @@ padStart : Str, Int, Str -> Str
 
 padEnd : Str, Int, Str -> Str
 
+## Grapheme Clusters
+
+## Split a string into its grapheme clusters.
+##
+## >>> Str.clusters "1,2,3"
+##
+## >>> Str.clusters  "👍👍👍"
+##
+clusters : Str -> List Str
+
+reverseClusters : Str -> Str
+
+foldClusters : Str, { start: state, step: (state, Str -> state) } -> state
+
+## Returns #True if the string begins with a capital letter, and #False otherwise.
+##
+## >>> Str.isCapitalized "hi"
+##
+## >>> Str.isCapitalized "Hi"
+##
+## >>> Str.isCapitalized " Hi"
+##
+## >>> Str.isCapitalized "Česká"
+##
+## >>> Str.isCapitalized "Э"
+##
+## >>> Str.isCapitalized "東京"
+##
+## >>> Str.isCapitalized "🐦"
+##
+## >>> Str.isCapitalized ""
+##
+## Since the rules for how to capitalize an uncapitalized string vary by locale,
+## see the [roc/locale](roc/locale) package for functions which do that.
+isCapitalized : Str -> Bool
+
+## ## Code Units
+##
+## Besides grapheme clusters, another way to break down strings is into
+## raw code unit integers.
+##
+## Code units are no substitute for grapheme clusters!
+## These functions exist to support advanced use cases like those found in
+## [roc/unicode](roc/unicode), and using code units when grapheme clusters would
+## be more appropriate can very easily lead to bugs.
+##
+## For example, `Str.countGraphemes "👩‍👩‍👦‍👦"` returns `1`,
+## whereas `Str.toUtf8 "👩‍👩‍👦‍👦"` returns a list with a length of 25,
+## `Str.toUtf16 "👩‍👩‍👦‍👦"` returns a list with a length of 11.
+## and `Str.toUtf32 "👩‍👩‍👦‍👦"` returns a list with a length of 7.
+
+## Return a #List of the string's #U8 UTF-8 [code units](https://unicode.org/glossary/#code_unit).
+## (To split the string into a #List of smaller #Str values instead of #U8 values,
+## see #Str.split and #Str.clusters.)
+##
+## >>> Str.toUtf8 "👩‍👩‍👦‍👦"
+##
+## >>> Str.toUtf8 "Roc"
+##
+## >>> Str.toUtf8 "鹏"
+##
+## >>> Str.toUtf8 "🐦"
+##
+## For a more flexible function that walks through each of these #U8 code units
+## without creating a #List, see #Str.foldUtf8 and #Str.foldRevUtf8.
+toUtf8 : Str -> List U8
+
+## Return a #List of the string's #U16 UTF-16 [code units](https://unicode.org/glossary/#code_unit).
+## (To split the string into a #List of smaller #Str values instead of #U16 values,
+## see #Str.split and #Str.clusters.)
+##
+## >>> Str.toUtf16 "👩‍👩‍👦‍👦"
+##
+## >>> Str.toUtf16 "Roc"
+##
+## >>> Str.toUtf16 "鹏"
+##
+## >>> Str.toUtf16 "🐦"
+##
+## For a more flexible function that walks through each of these #U16 code units
+## without creating a #List, see #Str.foldUtf16 and #Str.foldRevUtf16.
+toUtf16 : Str -> List U16
+
+## Return a #List of the string's #U32 UTF-32 [code units](https://unicode.org/glossary/#code_unit).
+## (To split the string into a #List of smaller #Str values instead of #U32 values,
+## see #Str.split and #Str.clusters.)
+##
+## >>> Str.toUtf32 "👩‍👩‍👦‍👦"
+##
+## >>> Str.toUtf32 "Roc"
+##
+## >>> Str.toUtf32 "鹏"
+##
+## >>> Str.toUtf32 "🐦"
+##
+## For a more flexible function that walks through each of these #U32 code units
+## without creating a #List, see #Str.foldUtf32 and #Str.foldRevUtf32.
+toUtf32 : Str -> List U32
+
+
+## Walk through the string's #U8 UTF-8 [code units](https://unicode.org/glossary/#code_unit)
+## to build up a state.
+## (If you want a `step` function which receives a #Str instead of an #U8, see #Str.foldClusters.)
+##
+## Here are the #U8 values that will be passed to `step` when this function is
+## called on various strings:
+##
+## * `"👩‍👩‍👦‍👦"` passes 240, 159, 145, 169, 226, 128, 141, 240, 159, 145, 169, 226, 128, 141, 240, 159, 145, 166, 226, 128, 141, 240, 159, 145, 166
+## * `"Roc"` passes 82, 111, 99
+## * `"鹏"` passes 233, 185, 143
+## * `"🐦"` passes 240, 159, 144, 166
+##
+## To convert a #Str into a plain `List U8` of UTF-8 code units, see #Str.toUtf8.
+foldUtf8 : Str, { start: state, step: (state, U8 -> state) } -> state
+
+## Walk through the string's #U16 UTF-16 [code units](https://unicode.org/glossary/#code_unit)
+## to build up a state.
+## (If you want a `step` function which receives a #Str instead of an #U16, see #Str.foldClusters.)
+##
+## Here are the #U16 values that will be passed to `step` when this function is
+## called on various strings:
+##
+## * `"👩‍👩‍👦‍👦"` passes 55357, 56425, 8205, 55357, 56425, 8205, 55357, 56422, 8205, 55357, 56422
+## * `"Roc"` passes 82, 111, 99
+## * `"鹏"` passes 40527
+## * `"🐦"` passes 55357, 56358
+##
+## To convert a #Str into a plain `List U16` of UTF-16 code units, see #Str.toUtf16.
+foldUtf16 : Str, { start: state, step: (state, U16 -> state) } -> state
+
+## Walk through the string's #U32 UTF-32 [code units](https://unicode.org/glossary/#code_unit)
+## to build up a state.
+## (If you want a `step` function which receives a #Str instead of an #U32, see #Str.foldClusters.)
+##
+## Here are the #U32 values that will be passed to `step` when this function is
+## called on various strings:
+##
+## * `"👩‍👩‍👦‍👦"` passes 128105, 8205, 128105, 8205, 128102, 8205, 128102
+## * `"Roc"` passes 82, 111, 99
+## * `"鹏"` passes 40527
+## * `"🐦"` passes 128038
+##
+## To convert a #Str into a plain `List U32` of UTF-32 code units, see #Str.toUtf32.
+foldUtf32 : Str, { start: state, step: (state, U32 -> state) } -> state
+
+
+## Walk backwards through the string's #U8 UTF-8 [code units](https://unicode.org/glossary/#code_unit)
+## to build up a state.
+## (If you want a `step` function which receives a #Str instead of an #U8, see #Str.foldClusters.)
+##
+## Here are the #U8 values that will be passed to `step` when this function is
+## called on various strings:
+##
+## * `"👩‍👩‍👦‍👦"` passes 166, 145, 159, 240, 141, 128, 226, 166, 145, 159, 240, 141, 128, 226, 169, 145, 159, 240, 141, 128, 226, 169, 145, 159, 240
+## * `"Roc"` passes 99, 111, 82
+## * `"鹏"` passes 143, 185, 233
+## * `"🐦"` passes 166, 144, 159, 240
+##
+## To convert a #Str into a plain `List U8` of UTF-8 code units, see #Str.toUtf8.
+foldRevUtf8 : Str, { start: state, step: (state, U8 -> state) } -> state
+
+## Walk backwards through the string's #U16 UTF-16 [code units](https://unicode.org/glossary/#code_unit)
+## to build up a state.
+## (If you want a `step` function which receives a #Str instead of an #U16, see #Str.foldClusters.)
+##
+## Here are the #U16 values that will be passed to `step` when this function is
+## called on various strings:
+##
+## * `"👩‍👩‍👦‍👦"` passes 56422, 55357, 8205, 56422, 55357, 8205, 56425, 55357, 8205, 56425, 55357
+## * `"Roc"` passes 99, 111, 82
+## * `"鹏"` passes 40527
+## * `"🐦"` passes 56358, 55357
+##
+## To convert a #Str into a plain `List U16` of UTF-16 code units, see #Str.toUtf16.
+foldRevUtf16 : Str, { start: state, step: (state, U16 -> state) } -> state
+
+## Walk backwards through the string's #U32 UTF-32 [code units](https://unicode.org/glossary/#code_unit)
+## to build up a state.
+## (If you want a `step` function which receives a #Str instead of an #U32, see #Str.foldClusters.)
+##
+## Here are the #U32 values that will be passed to `step` when this function is
+## called on various strings:
+##
+## * `"👩‍👩‍👦‍👦"` passes 128102, 8205, 128102, 8205, 128105, 8205, 128105
+## * `"Roc"` passes 99, 111, 82
+## * `"鹏"` passes 40527
+## * `"🐦"` passes 128038
+##
+## To convert a #Str into a plain `List U32` of UTF-32 code units, see #Str.toUtf32.
+foldRevUtf32 : Str, { start: state, step: (state, U32 -> state) } -> state
+
+
 
diff --git a/compiler/gen/src/crane/build.rs b/compiler/gen/src/crane/build.rs
index 1a81e886fb..a15f9fb88d 100644
--- a/compiler/gen/src/crane/build.rs
+++ b/compiler/gen/src/crane/build.rs
@@ -55,6 +55,8 @@ pub fn build_expr<'a, B: Backend>(
 ) -> Value {
     use roc_mono::expr::Expr::*;
 
+    let ptr_bytes = env.cfg.pointer_bytes() as u32;
+
     match expr {
         Int(num) => builder.ins().iconst(types::I64, *num),
         Float(num) => builder.ins().f64const(*num),
@@ -173,7 +175,6 @@ pub fn build_expr<'a, B: Backend>(
         },
         Struct(sorted_fields) => {
             let cfg = env.cfg;
-            let ptr_bytes = cfg.pointer_bytes() as u32;
 
             // The slot size will be the sum of all the fields' sizes
             let mut slot_size = 0;
@@ -189,6 +190,7 @@ pub fn build_expr<'a, B: Backend>(
             ));
 
             // Create instructions for storing each field's expression
+            // NOTE assumes that all fields have the same width!
             for (index, (field_expr, field_layout)) in sorted_fields.iter().enumerate() {
                 let val = build_expr(env, &scope, module, builder, field_expr, procs);
 
@@ -203,6 +205,50 @@ pub fn build_expr<'a, B: Backend>(
                 .ins()
                 .stack_addr(cfg.pointer_type(), slot, Offset32::new(0))
         }
+        Tag { tag_layout, arguments , tag_id, union_size, .. } => {
+            let cfg = env.cfg;
+            let ptr_bytes = cfg.pointer_bytes() as u32;
+
+            // NOTE: all variants of a tag union must have the same size, so (among other things)
+            // it's easy to quickly index them in arrays. Therefore the size of this tag doens't
+            // depend on the tag arguments, but solely on the layout of the whole tag union
+            let slot_size = tag_layout.stack_size(ptr_bytes);
+
+            // Create a slot
+            let slot = builder.create_stack_slot(StackSlotData::new(
+                StackSlotKind::ExplicitSlot,
+                slot_size
+            ));
+
+            // Create instructions for storing each field's expression
+            let mut offset = 0;
+
+            // still need to insert the tag discriminator for non-single unions
+            // when there are no arguments, e.g. `Nothing : Maybe a`
+            if *union_size > 1 {
+                let val = builder.ins().iconst(types::I64, *tag_id as i64);
+                builder.ins().stack_store(val, slot, Offset32::new(0));
+                offset += ptr_bytes;
+            }
+
+            for (field_expr, field_layout) in arguments.iter() {
+                let val = build_expr(env, &scope, module, builder, field_expr, procs);
+
+                let field_size = field_layout.stack_size(ptr_bytes);
+                let field_offset = i32::try_from(offset)
+                    .expect("TODO handle field size conversion to i32");
+
+                builder.ins().stack_store(val, slot, Offset32::new(field_offset));
+
+                offset += field_size;
+            }
+
+
+            builder
+                .ins()
+                .stack_addr(cfg.pointer_type(), slot, Offset32::new(0))
+        }
+
         Access {
             label,
             field_layout,
@@ -252,15 +298,49 @@ pub fn build_expr<'a, B: Backend>(
                 .ins()
                 .load(cfg.pointer_type(), mem_flags, record, Offset32::new(offset))
         }
+        AccessAtIndex {
+            index,
+            field_layouts,
+            expr,
+            ..
+        } => {
+            let cfg = env.cfg;
+            let mut offset = 0;
+
+
+
+            for (field_index, field_layout) in field_layouts.iter().enumerate() {
+                if *index == field_index as u64 {
+                    let offset = i32::try_from(offset)
+                        .expect("TODO gracefully handle usize -> i32 conversion in struct access");
+
+                    let mem_flags = MemFlags::new();
+                    let expr = build_expr(env, scope, module, builder, expr, procs);
+
+                    let ret_type = layout_to_type(&field_layout, cfg.pointer_type());
+
+                    return builder
+                        .ins()
+                        .load(ret_type, mem_flags, expr, Offset32::new(offset));
+                }
+
+                offset += field_layout.stack_size(ptr_bytes);
+            }
+
+            panic!("field access out of bounds: index {:?} in layouts {:?}", index, field_layouts)
+
+        }
+
         Str(str_literal) => {
             if str_literal.is_empty() {
                 panic!("TODO build an empty string in Crane");
             } else {
                 let bytes_len = str_literal.len() + 1/* TODO drop the +1 when we have structs and this is no longer a NUL-terminated CString.*/;
-                let ptr = call_malloc(env, module, builder, bytes_len);
+                let size = builder.ins().iconst(types::I64, bytes_len as i64);
+                let ptr = call_malloc(env, module, builder, size);
                 let mem_flags = MemFlags::new();
 
-                // Copy the bytes from the string literal into the array
+                // Store the bytes from the string literal in the array
                 for (index, byte) in str_literal.bytes().enumerate() {
                     let val = builder.ins().iconst(types::I8, byte as i64);
                     let offset = Offset32::new(index as i32);
@@ -294,7 +374,8 @@ pub fn build_expr<'a, B: Backend>(
             } else {
                 let elem_bytes = elem_layout.stack_size(ptr_bytes as u32);
                 let bytes_len = elem_bytes as usize * elems.len();
-                let elems_ptr = call_malloc(env, module, builder, bytes_len);
+                let size = builder.ins().iconst(types::I64, bytes_len as i64);
+                let elems_ptr = call_malloc(env, module, builder, size);
                 let mem_flags = MemFlags::new();
 
                 // Copy the elements from the literal into the array
@@ -308,18 +389,19 @@ pub fn build_expr<'a, B: Backend>(
                 elems_ptr
             };
 
-            // Store the pointer in slot 0
-            builder
-                .ins()
-                .stack_store(elems_ptr, slot, Offset32::new(0));
+            // Store the pointer
+            {
+                let offset = Offset32::new((Builtin::WRAPPER_PTR * ptr_bytes) as i32);
 
-            // Store the length in slot 1
+                builder.ins().stack_store(elems_ptr, slot, offset);
+            }
+
+            // Store the length
             {
                 let length = builder.ins().iconst(env.ptr_sized_int(), elems.len() as i64);
+                let offset = Offset32::new((Builtin::WRAPPER_LEN * ptr_bytes) as i32);
 
-                builder
-                    .ins()
-                    .stack_store(length, slot, Offset32::new(ptr_bytes as i32));
+                builder.ins().stack_store(length, slot, offset);
             }
 
             // Return the pointer to the wrapper
@@ -331,6 +413,21 @@ pub fn build_expr<'a, B: Backend>(
     }
 }
 
+fn layout_to_type<'a>(layout: &Layout<'a>, _pointer_type: Type) -> Type {
+    use roc_mono::layout::Builtin::*;
+
+    match layout {
+        Layout::Builtin(builtin) => match builtin {
+            Int64 => cranelift::prelude::types::I64,
+            Byte => cranelift::prelude::types::I8,
+            Bool => cranelift::prelude::types::B1,
+            Float64 => cranelift::prelude::types::F64,
+            other => panic!("I don't yet know how to make a type from {:?}", other),
+        },
+        other => panic!("I don't yet know how to make a type from {:?}", other),
+    }
+}
+
 struct Branch2<'a> {
     cond: &'a Expr<'a>,
     cond_layout: &'a Layout<'a>,
@@ -363,7 +460,7 @@ fn build_branch2<'a, B: Backend>(
     let fail_block = builder.create_block();
 
     match branch.cond_layout {
-        Layout::Builtin(Builtin::Bool(_, _)) => {
+        Layout::Builtin(Builtin::Bool) => {
             builder.ins().brnz(cond, pass_block, &[]);
         }
         other => panic!("I don't know how to build a conditional for {:?}", other),
@@ -645,14 +742,13 @@ fn call_by_name<'a, B: Backend>(
             debug_assert!(args.len() == 1);
 
             let list_ptr = build_arg(&args[0], env, scope, module, builder, procs);
+            let ptr_bytes = env.cfg.pointer_bytes() as u32;
+            let offset = Offset32::new((Builtin::WRAPPER_LEN * ptr_bytes) as i32);
 
-            // Get the usize int length
-            builder.ins().load(
-                env.ptr_sized_int(),
-                MemFlags::new(),
-                list_ptr,
-                Offset32::new(env.cfg.pointer_bytes() as i32),
-            )
+            // Get the usize list length
+            builder
+                .ins()
+                .load(env.ptr_sized_int(), MemFlags::new(), list_ptr, offset)
         }
         Symbol::INT_EQ_I64 | Symbol::INT_EQ_I8 | Symbol::INT_EQ_I1 => {
             debug_assert!(args.len() == 2);
@@ -674,68 +770,68 @@ fn call_by_name<'a, B: Backend>(
             let wrapper_ptr = build_arg(&args[0], env, scope, module, builder, procs);
             let elem_index = build_arg(&args[1], env, scope, module, builder, procs);
 
-            let elem_type = Type::int(64).unwrap(); // TODO Look this up instead of hardcoding it!
-            let elem_bytes = 8; // TODO Look this up instead of hardcoding it!
-            let elem_size = builder.ins().iconst(types::I64, elem_bytes);
-
-            // Load the pointer we got to the wrapper struct
-            let elems_ptr = builder.ins().load(
-                env.cfg.pointer_type(),
-                MemFlags::new(),
-                wrapper_ptr,
-                Offset32::new(0),
-            );
-
-            // Multiply the requested index by the size of each element.
-            let offset = builder.ins().imul(elem_index, elem_size);
-
-            // Follow the pointer in the wrapper struct to the actual elements
-            builder.ins().load_complex(
-                elem_type,
-                MemFlags::new(),
-                &[elems_ptr, offset],
-                Offset32::new(0),
-            )
-        }
-        Symbol::LIST_SET => {
             let (_list_expr, list_layout) = &args[0];
 
+            // Get the usize list length
+            let ptr_bytes = env.cfg.pointer_bytes() as u32;
+            let offset = Offset32::new((Builtin::WRAPPER_LEN * ptr_bytes) as i32);
+            let _list_len =
+                builder
+                    .ins()
+                    .load(env.ptr_sized_int(), MemFlags::new(), wrapper_ptr, offset);
+
+            // TODO compare elem_index to _list_len to do array bounds checking.
+
             match list_layout {
                 Layout::Builtin(Builtin::List(elem_layout)) => {
-                    // TODO try memcpy for shallow clones; it's probably faster
-                    // let list_val = build_expr(env, scope, module, builder, list_expr, procs);
+                    let cfg = env.cfg;
+                    let elem_type = type_from_layout(cfg, elem_layout);
+                    let elem_bytes = elem_layout.stack_size(cfg.pointer_bytes() as u32);
+                    let elem_size = builder.ins().iconst(types::I64, elem_bytes as i64);
 
-                    let num_elems = 10; // TODO FIXME read from List.len
-                    let elem_bytes =
-                        elem_layout.stack_size(env.cfg.pointer_bytes() as u32) as usize;
-                    let bytes_len = (elem_bytes * num_elems) + 1/* TODO drop the +1 when we have structs and this is no longer NUL-terminated. */;
-                    let wrapper_ptr = call_malloc(env, module, builder, bytes_len);
-                    // let mem_flags = MemFlags::new();
-
-                    // Copy the elements from the literal into the array
-                    // for (index, elem) in elems.iter().enumerate() {
-                    //     let offset = Offset32::new(elem_bytes as i32 * index as i32);
-                    //     let val = build_expr(env, scope, module, builder, elem, procs);
-
-                    //     builder.ins().store(mem_flags, val, ptr, offset);
-                    // }
-
-                    // Add a NUL terminator at the end.
-                    // TODO: Instead of NUL-terminating, return a struct
-                    // with the pointer and also the length and capacity.
-                    // let nul_terminator = builder.ins().iconst(types::I8, 0);
-                    // let index = bytes_len as i32 - 1;
-                    // let offset = Offset32::new(index);
-
-                    // builder.ins().store(mem_flags, nul_terminator, ptr, offset);
                     // Load the pointer we got to the wrapper struct
-                    let _elems_ptr = builder.ins().load(
+                    let elems_ptr = builder.ins().load(
                         env.cfg.pointer_type(),
                         MemFlags::new(),
                         wrapper_ptr,
                         Offset32::new(0),
                     );
 
+                    // Multiply the requested index by the size of each element.
+                    let offset = builder.ins().imul(elem_index, elem_size);
+
+                    // Follow the pointer in the wrapper struct to the actual elements
+                    builder.ins().load_complex(
+                        elem_type,
+                        MemFlags::new(),
+                        &[elems_ptr, offset],
+                        Offset32::new(0),
+                    )
+                }
+                _ => {
+                    unreachable!("Invalid List layout for List.get: {:?}", list_layout);
+                }
+            }
+        }
+        Symbol::LIST_SET => {
+            // set : List elem, Int, elem -> List elem
+            let wrapper_ptr = build_arg(&args[0], env, scope, module, builder, procs);
+            let (_list_expr, list_layout) = &args[0];
+
+            // Get the usize list length
+            let ptr_bytes = env.cfg.pointer_bytes() as u32;
+            let offset = Offset32::new((Builtin::WRAPPER_LEN * ptr_bytes) as i32);
+            let _list_len =
+                builder
+                    .ins()
+                    .load(env.ptr_sized_int(), MemFlags::new(), wrapper_ptr, offset);
+
+            // TODO do array bounds checking, and early return the original List if out of bounds
+
+            match list_layout {
+                Layout::Builtin(Builtin::List(elem_layout)) => {
+                    let wrapper_ptr = clone_list(env, builder, module, wrapper_ptr, elem_layout);
+
                     list_set_in_place(
                         env,
                         wrapper_ptr,
@@ -756,6 +852,17 @@ fn call_by_name<'a, B: Backend>(
             // set : List elem, Int, elem -> List elem
             debug_assert!(args.len() == 3);
 
+            // Get the usize list length
+            let wrapper_ptr = build_arg(&args[0], env, scope, module, builder, procs);
+            let ptr_bytes = env.cfg.pointer_bytes() as u32;
+            let offset = Offset32::new((Builtin::WRAPPER_LEN * ptr_bytes) as i32);
+            let _list_len =
+                builder
+                    .ins()
+                    .load(env.ptr_sized_int(), MemFlags::new(), wrapper_ptr, offset);
+
+            // TODO do array bounds checking, and early return the original List if out of bounds
+
             let (list_expr, list_layout) = &args[0];
             let list_val = build_expr(env, scope, module, builder, list_expr, procs);
 
@@ -802,17 +909,13 @@ fn call_malloc<B: Backend>(
     env: &Env<'_>,
     module: &mut Module<B>,
     builder: &mut FunctionBuilder,
-    size: usize,
+    size: Value,
 ) -> Value {
     // Declare malloc inside this function
     let local_func = module.declare_func_in_func(env.malloc, &mut builder.func);
 
-    // Convert the size argument to a Value
-    let ptr_size_type = module.target_config().pointer_type();
-    let size_arg = builder.ins().iconst(ptr_size_type, size as i64);
-
     // Call malloc and return the resulting pointer
-    let call = builder.ins().call(local_func, &[size_arg]);
+    let call = builder.ins().call(local_func, &[size]);
     let results = builder.inst_results(call);
 
     debug_assert!(results.len() == 1);
@@ -850,3 +953,77 @@ fn list_set_in_place<'a>(
 
     wrapper_ptr
 }
+
+fn clone_list<B: Backend>(
+    env: &Env<'_>,
+    builder: &mut FunctionBuilder,
+    module: &mut Module<B>,
+    src_wrapper_ptr: Value,
+    elem_layout: &Layout<'_>,
+) -> Value {
+    let cfg = env.cfg;
+    let ptr_bytes = env.cfg.pointer_bytes() as u32;
+
+    // Load the pointer we got to the wrapper struct
+    let elems_ptr = {
+        let offset = Offset32::new((Builtin::WRAPPER_PTR * ptr_bytes) as i32);
+
+        builder
+            .ins()
+            .load(cfg.pointer_type(), MemFlags::new(), src_wrapper_ptr, offset)
+    };
+
+    // Get the usize list length
+    let list_len = {
+        let offset = Offset32::new((Builtin::WRAPPER_LEN * ptr_bytes) as i32);
+
+        builder.ins().load(
+            env.ptr_sized_int(),
+            MemFlags::new(),
+            src_wrapper_ptr,
+            offset,
+        )
+    };
+
+    // Calculate the number of bytes we'll need to allocate.
+    let elem_bytes = builder.ins().iconst(
+        env.ptr_sized_int(),
+        elem_layout.stack_size(cfg.pointer_bytes() as u32) as i64,
+    );
+    let size = builder.ins().imul(elem_bytes, list_len);
+
+    // Allocate space for the new array that we'll copy into.
+    let new_elems_ptr = call_malloc(env, module, builder, size);
+
+    // Either memcpy or deep clone the array elements
+    if elem_layout.safe_to_memcpy() {
+        // Copy the bytes from the original array into the new
+        // one we just malloc'd.
+        //
+        // TODO how do we decide when to do the small memcpy vs the normal one?
+        builder.call_memcpy(env.cfg, new_elems_ptr, elems_ptr, size);
+    } else {
+        panic!("TODO Cranelift currently only knows how to clone list elements that are Copy.");
+    }
+
+    // Create a fresh wrapper struct for the newly populated array
+    let ptr_bytes = cfg.pointer_bytes() as u32;
+    let slot = builder.create_stack_slot(StackSlotData::new(
+        StackSlotKind::ExplicitSlot,
+        ptr_bytes * Builtin::LIST_WORDS,
+    ));
+
+    // Store the new pointer in slot 0 of the wrapper
+    builder
+        .ins()
+        .stack_store(new_elems_ptr, slot, Offset32::new(0));
+
+    // Store the length in slot 1 of the wrapper
+    builder
+        .ins()
+        .stack_store(list_len, slot, Offset32::new(ptr_bytes as i32));
+
+    builder
+        .ins()
+        .stack_addr(cfg.pointer_type(), slot, Offset32::new(0))
+}
diff --git a/compiler/gen/src/crane/convert.rs b/compiler/gen/src/crane/convert.rs
index 857cbdf8f9..36c94b80d8 100644
--- a/compiler/gen/src/crane/convert.rs
+++ b/compiler/gen/src/crane/convert.rs
@@ -10,12 +10,12 @@ pub fn type_from_layout(cfg: TargetFrontendConfig, layout: &Layout<'_>) -> Type
     use roc_mono::layout::Layout::*;
 
     match layout {
-        Pointer(_) | FunctionPointer(_, _) | Struct(_) | Tag(_) => cfg.pointer_type(),
+        FunctionPointer(_, _) | Struct(_) | Union(_) => cfg.pointer_type(),
         Builtin(builtin) => match builtin {
             Int64 => types::I64,
             Float64 => types::F64,
-            Bool(_, _) => types::B1,
-            Byte(_) => types::I8,
+            Bool => types::B1,
+            Byte => types::I8,
             Str | EmptyStr | Map(_, _) | EmptyMap | Set(_) | EmptySet | List(_) | EmptyList => {
                 cfg.pointer_type()
             }
diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs
index ecc8563073..921a19c74f 100644
--- a/compiler/gen/src/llvm/build.rs
+++ b/compiler/gen/src/llvm/build.rs
@@ -3,13 +3,13 @@ use bumpalo::Bump;
 use inkwell::builder::Builder;
 use inkwell::context::Context;
 use inkwell::module::{Linkage, Module};
-use inkwell::types::BasicTypeEnum;
+use inkwell::types::{BasicTypeEnum, IntType};
 use inkwell::values::BasicValueEnum::{self, *};
 use inkwell::values::{FunctionValue, IntValue, PointerValue};
 use inkwell::{AddressSpace, FloatPredicate, IntPredicate};
 
 use crate::llvm::convert::{
-    basic_type_from_layout, collection_wrapper, get_array_type, get_fn_type,
+    basic_type_from_layout, collection_wrapper, get_array_type, get_fn_type, ptr_int,
 };
 use roc_collections::all::ImMap;
 use roc_module::symbol::{Interns, Symbol};
@@ -32,7 +32,13 @@ pub struct Env<'a, 'ctx, 'env> {
     pub builder: &'env Builder<'ctx>,
     pub module: &'ctx Module<'ctx>,
     pub interns: Interns,
-    pub pointer_bytes: u32,
+    pub ptr_bytes: u32,
+}
+
+impl<'a, 'ctx, 'env> Env<'a, 'ctx, 'env> {
+    pub fn ptr_int(&self) -> IntType<'ctx> {
+        ptr_int(self.context, self.ptr_bytes)
+    }
 }
 
 pub fn build_expr<'a, 'ctx, 'env>(
@@ -75,7 +81,8 @@ pub fn build_expr<'a, 'ctx, 'env>(
             ret_layout,
             cond_layout,
         } => {
-            let ret_type = basic_type_from_layout(env.arena, env.context, &ret_layout);
+            let ret_type =
+                basic_type_from_layout(env.arena, env.context, &ret_layout, env.ptr_bytes);
             let switch_args = SwitchArgs {
                 cond_layout: cond_layout.clone(),
                 cond_expr: cond,
@@ -92,7 +99,7 @@ pub fn build_expr<'a, 'ctx, 'env>(
 
             for (symbol, layout, expr) in stores.iter() {
                 let val = build_expr(env, &scope, parent, &expr, procs);
-                let expr_bt = basic_type_from_layout(env.arena, context, &layout);
+                let expr_bt = basic_type_from_layout(env.arena, context, &layout, env.ptr_bytes);
                 let alloca = create_entry_block_alloca(
                     env,
                     parent,
@@ -122,14 +129,14 @@ pub fn build_expr<'a, 'ctx, 'env>(
                 panic!("TODO create a phi node for &&");
             }
             _ => {
-                let mut arg_vals: Vec<BasicValueEnum> =
+                let mut arg_tuples: Vec<(BasicValueEnum, &'a Layout<'a>)> =
                     Vec::with_capacity_in(args.len(), env.arena);
 
-                for (arg, _layout) in args.iter() {
-                    arg_vals.push(build_expr(env, scope, parent, arg, procs));
+                for (arg, layout) in args.iter() {
+                    arg_tuples.push((build_expr(env, scope, parent, arg, procs), layout));
                 }
 
-                call_with_args(*symbol, arg_vals.into_bump_slice(), env)
+                call_with_args(*symbol, arg_tuples.into_bump_slice(), env)
             }
         },
         FunctionPointer(symbol) => {
@@ -165,7 +172,6 @@ pub fn build_expr<'a, 'ctx, 'env>(
                 .left()
                 .unwrap_or_else(|| panic!("LLVM error: Invalid call by pointer."))
         }
-
         Load(symbol) => match scope.get(symbol) {
             Some((_, ptr)) => env
                 .builder
@@ -209,13 +215,13 @@ pub fn build_expr<'a, 'ctx, 'env>(
         }
         Array { elem_layout, elems } => {
             let ctx = env.context;
-            let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout);
+            let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
             let builder = env.builder;
 
             if elems.is_empty() {
                 let array_type = get_array_type(&elem_type, 0);
                 let ptr_type = array_type.ptr_type(AddressSpace::Generic);
-                let struct_type = collection_wrapper(ctx, ptr_type);
+                let struct_type = collection_wrapper(ctx, ptr_type, env.ptr_bytes);
 
                 // The first field in the struct should be the pointer.
                 let struct_val = builder
@@ -230,11 +236,12 @@ pub fn build_expr<'a, 'ctx, 'env>(
                 BasicValueEnum::StructValue(struct_val.into_struct_value())
             } else {
                 let len_u64 = elems.len() as u64;
-                let elem_bytes = elem_layout.stack_size(env.pointer_bytes) as u64;
+                let elem_bytes = elem_layout.stack_size(env.ptr_bytes) as u64;
 
                 let ptr = {
                     let bytes_len = elem_bytes * len_u64;
-                    let len = ctx.i32_type().const_int(bytes_len, false);
+                    let len_type = env.ptr_int();
+                    let len = len_type.const_int(bytes_len, false);
 
                     env.builder
                         .build_array_malloc(elem_type, len, "create_list_ptr")
@@ -252,8 +259,8 @@ pub fn build_expr<'a, 'ctx, 'env>(
                 }
 
                 let ptr_val = BasicValueEnum::PointerValue(ptr);
-                let struct_type = collection_wrapper(ctx, ptr.get_type());
-                let len = BasicValueEnum::IntValue(ctx.i32_type().const_int(len_u64, false));
+                let struct_type = collection_wrapper(ctx, ptr.get_type(), env.ptr_bytes);
+                let len = BasicValueEnum::IntValue(env.ptr_int().const_int(len_u64, false));
                 let mut struct_val;
 
                 // Field 0: pointer
@@ -271,16 +278,6 @@ pub fn build_expr<'a, 'ctx, 'env>(
                     .build_insert_value(struct_val, len, Builtin::WRAPPER_LEN, "insert_len")
                     .unwrap();
 
-                // Field 2: capacity (initially set to length)
-                struct_val = builder
-                    .build_insert_value(
-                        struct_val,
-                        len,
-                        Builtin::WRAPPER_CAPACITY,
-                        "insert_capacity",
-                    )
-                    .unwrap();
-
                 BasicValueEnum::StructValue(struct_val.into_struct_value())
             }
         }
@@ -296,7 +293,8 @@ pub fn build_expr<'a, 'ctx, 'env>(
 
             for (field_expr, field_layout) in sorted_fields.iter() {
                 let val = build_expr(env, &scope, parent, field_expr, procs);
-                let field_type = basic_type_from_layout(env.arena, env.context, &field_layout);
+                let field_type =
+                    basic_type_from_layout(env.arena, env.context, &field_layout, env.ptr_bytes);
 
                 field_types.push(field_type);
                 field_vals.push(val);
@@ -315,6 +313,157 @@ pub fn build_expr<'a, 'ctx, 'env>(
 
             BasicValueEnum::StructValue(struct_val.into_struct_value())
         }
+        Tag {
+            union_size,
+            arguments,
+            ..
+        } if *union_size == 1 => {
+            let it = arguments.iter();
+
+            let ctx = env.context;
+            let builder = env.builder;
+
+            // Determine types
+            let num_fields = arguments.len() + 1;
+            let mut field_types = Vec::with_capacity_in(num_fields, env.arena);
+            let mut field_vals = Vec::with_capacity_in(num_fields, env.arena);
+
+            for (field_expr, field_layout) in it {
+                let val = build_expr(env, &scope, parent, field_expr, procs);
+                let field_type =
+                    basic_type_from_layout(env.arena, env.context, &field_layout, env.ptr_bytes);
+
+                field_types.push(field_type);
+                field_vals.push(val);
+            }
+
+            // Create the struct_type
+            let struct_type = ctx.struct_type(field_types.into_bump_slice(), false);
+            let mut struct_val = struct_type.const_zero().into();
+
+            // Insert field exprs into struct_val
+            for (index, field_val) in field_vals.into_iter().enumerate() {
+                struct_val = builder
+                    .build_insert_value(struct_val, field_val, index as u32, "insert_field")
+                    .unwrap();
+            }
+
+            BasicValueEnum::StructValue(struct_val.into_struct_value())
+        }
+        Tag {
+            arguments,
+            tag_layout,
+            union_size,
+            tag_id,
+            ..
+        } => {
+            let ptr_size = env.ptr_bytes;
+
+            let whole_size = tag_layout.stack_size(ptr_size);
+            let mut filler = tag_layout.stack_size(ptr_size);
+
+            let ctx = env.context;
+            let builder = env.builder;
+
+            // Determine types
+            let num_fields = arguments.len() + 1;
+            let mut field_types = Vec::with_capacity_in(num_fields, env.arena);
+            let mut field_vals = Vec::with_capacity_in(num_fields, env.arena);
+
+            // insert the discriminant value
+            if *union_size > 1 {
+                let val = env
+                    .context
+                    .i64_type()
+                    .const_int(*tag_id as u64, true)
+                    .into();
+
+                let field_type = env.context.i64_type().into();
+
+                field_types.push(field_type);
+                field_vals.push(val);
+
+                let field_size = ptr_size;
+                filler -= field_size;
+            }
+
+            for (field_expr, field_layout) in arguments.iter() {
+                let val = build_expr(env, &scope, parent, field_expr, procs);
+                let field_type =
+                    basic_type_from_layout(env.arena, env.context, &field_layout, ptr_size);
+
+                field_types.push(field_type);
+                field_vals.push(val);
+
+                let field_size = field_layout.stack_size(ptr_size);
+                filler -= field_size;
+            }
+
+            // TODO verify that this is required (better safe than sorry)
+            if filler > 0 {
+                field_types.push(env.context.i8_type().array_type(filler).into());
+            }
+
+            // Create the struct_type
+            let struct_type = ctx.struct_type(field_types.into_bump_slice(), false);
+            let mut struct_val = struct_type.const_zero().into();
+
+            // Insert field exprs into struct_val
+            for (index, field_val) in field_vals.into_iter().enumerate() {
+                struct_val = builder
+                    .build_insert_value(struct_val, field_val, index as u32, "insert_field")
+                    .unwrap();
+            }
+
+            // How we create tag values
+            //
+            // The memory layout of tags can be different. e.g. in
+            //
+            // [ Ok Int, Err Str ]
+            //
+            // the `Ok` tag stores a 64-bit integer, the `Err` tag stores a struct.
+            // All tags of a union must have the same length, for easy addressing (e.g. array lookups).
+            // So we need to ask for the maximum of all tag's sizes, even if most tags won't use
+            // all that memory, and certainly won't use it in the same way (the tags have fields of
+            // different types/sizes)
+            //
+            // In llvm, we must be explicit about the type of value we're creating: we can't just
+            // make a unspecified block of memory. So what we do is create a byte array of the
+            // desired size. Then when we know which tag we have (which is here, in this function),
+            // we need to cast that down to the array of bytes that llvm expects
+            //
+            // There is the bitcast instruction, but it doesn't work for arrays. So we need to jump
+            // through some hoops using store and load to get this to work: the array is put into a
+            // one-element struct, which can be cast to the desired type.
+            //
+            // This tricks comes from
+            // https://github.com/raviqqe/ssf/blob/bc32aae68940d5bddf5984128e85af75ca4f4686/ssf-llvm/src/expression_compiler.rs#L116
+
+            let array_type = ctx.i8_type().array_type(whole_size);
+            let struct_pointer = builder.build_alloca(array_type, "struct_poitner");
+
+            builder.build_store(
+                builder
+                    .build_bitcast(
+                        struct_pointer,
+                        struct_type.ptr_type(inkwell::AddressSpace::Generic),
+                        "",
+                    )
+                    .into_pointer_value(),
+                struct_val,
+            );
+
+            let result = builder.build_load(struct_pointer, "");
+
+            // For unclear reasons, we can't cast an array to a struct on the other side.
+            // the solution is to wrap the array in a struct (yea...)
+            let wrapper_type = ctx.struct_type(&[array_type.into()], false);
+            let mut wrapper_val = wrapper_type.const_zero().into();
+            wrapper_val = builder
+                .build_insert_value(wrapper_val, result, 0, "insert_field")
+                .unwrap();
+            wrapper_val.into_struct_value().into()
+        }
         Access {
             label,
             field_layout,
@@ -348,6 +497,73 @@ pub fn build_expr<'a, 'ctx, 'env>(
                 .build_extract_value(struct_val, index, "field_access")
                 .unwrap()
         }
+        AccessAtIndex {
+            index,
+            expr,
+            is_unwrapped,
+            ..
+        } if *is_unwrapped => {
+            let builder = env.builder;
+
+            // Get Struct val
+            // Since this is a one-element tag union, we get the correct struct immediately
+            let argument = build_expr(env, &scope, parent, expr, procs).into_struct_value();
+
+            builder
+                .build_extract_value(
+                    argument,
+                    *index as u32,
+                    env.arena.alloc(format!("tag_field_access_{}_", index)),
+                )
+                .unwrap()
+        }
+
+        AccessAtIndex {
+            index,
+            expr,
+            field_layouts,
+            ..
+        } => {
+            let builder = env.builder;
+
+            // Determine types, assumes the descriminant is in the field layouts
+            let num_fields = field_layouts.len();
+            let mut field_types = Vec::with_capacity_in(num_fields, env.arena);
+            let ptr_bytes = env.ptr_bytes;
+
+            for field_layout in field_layouts.iter() {
+                let field_type =
+                    basic_type_from_layout(env.arena, env.context, &field_layout, ptr_bytes);
+                field_types.push(field_type);
+            }
+
+            // Create the struct_type
+            let struct_type = env
+                .context
+                .struct_type(field_types.into_bump_slice(), false);
+
+            // cast the argument bytes into the desired shape for this tag
+            let argument = build_expr(env, &scope, parent, expr, procs).into_struct_value();
+            let argument_pointer = builder.build_alloca(argument.get_type(), "");
+            builder.build_store(argument_pointer, argument);
+
+            let argument = builder
+                .build_load(
+                    builder
+                        .build_bitcast(
+                            argument_pointer,
+                            struct_type.ptr_type(inkwell::AddressSpace::Generic),
+                            "",
+                        )
+                        .into_pointer_value(),
+                    "",
+                )
+                .into_struct_value();
+
+            builder
+                .build_extract_value(argument, *index as u32, "")
+                .expect("desired field did not decode")
+        }
         _ => {
             panic!("I don't yet know how to LLVM build {:?}", expr);
         }
@@ -369,7 +585,7 @@ fn build_branch2<'a, 'ctx, 'env>(
     procs: &Procs<'a>,
 ) -> BasicValueEnum<'ctx> {
     let ret_layout = cond.ret_layout;
-    let ret_type = basic_type_from_layout(env.arena, env.context, &ret_layout);
+    let ret_type = basic_type_from_layout(env.arena, env.context, &ret_layout, env.ptr_bytes);
 
     let cond_expr = build_expr(env, scope, parent, cond.cond, procs);
 
@@ -433,10 +649,8 @@ fn build_switch<'a, 'ctx, 'env>(
         // they either need to all be i8, or i64
         let int_val = match cond_layout {
             Layout::Builtin(Builtin::Int64) => context.i64_type().const_int(*int as u64, false),
-            Layout::Builtin(Builtin::Bool(_, _)) => {
-                context.bool_type().const_int(*int as u64, false)
-            }
-            Layout::Builtin(Builtin::Byte(_)) => context.i8_type().const_int(*int as u64, false),
+            Layout::Builtin(Builtin::Bool) => context.bool_type().const_int(*int as u64, false),
+            Layout::Builtin(Builtin::Byte) => context.i8_type().const_int(*int as u64, false),
             _ => panic!("Can't cast to cond_layout = {:?}", cond_layout),
         };
         let block = context.append_basic_block(parent, format!("branch{}", int).as_str());
@@ -566,12 +780,12 @@ pub fn build_proc_header<'a, 'ctx, 'env>(
     let args = proc.args;
     let arena = env.arena;
     let context = &env.context;
-    let ret_type = basic_type_from_layout(arena, context, &proc.ret_layout);
+    let ret_type = basic_type_from_layout(arena, context, &proc.ret_layout, env.ptr_bytes);
     let mut arg_basic_types = Vec::with_capacity_in(args.len(), arena);
     let mut arg_symbols = Vec::new_in(arena);
 
     for (layout, arg_symbol) in args.iter() {
-        let arg_type = basic_type_from_layout(arena, env.context, &layout);
+        let arg_type = basic_type_from_layout(arena, env.context, &layout, env.ptr_bytes);
 
         arg_basic_types.push(arg_type);
         arg_symbols.push(arg_symbol);
@@ -639,7 +853,7 @@ pub fn verify_fn(fn_val: FunctionValue<'_>) {
 #[allow(clippy::cognitive_complexity)]
 fn call_with_args<'a, 'ctx, 'env>(
     symbol: Symbol,
-    args: &[BasicValueEnum<'ctx>],
+    args: &[(BasicValueEnum<'ctx>, &'a Layout<'a>)],
     env: &Env<'a, 'ctx, 'env>,
 ) -> BasicValueEnum<'ctx> {
     match symbol {
@@ -647,8 +861,8 @@ fn call_with_args<'a, 'ctx, 'env>(
             debug_assert!(args.len() == 2);
 
             let int_val = env.builder.build_int_add(
-                args[0].into_int_value(),
-                args[1].into_int_value(),
+                args[0].0.into_int_value(),
+                args[1].0.into_int_value(),
                 "add_i64",
             );
 
@@ -658,8 +872,8 @@ fn call_with_args<'a, 'ctx, 'env>(
             debug_assert!(args.len() == 2);
 
             let float_val = env.builder.build_float_add(
-                args[0].into_float_value(),
-                args[1].into_float_value(),
+                args[0].0.into_float_value(),
+                args[1].0.into_float_value(),
                 "add_f64",
             );
 
@@ -669,8 +883,8 @@ fn call_with_args<'a, 'ctx, 'env>(
             debug_assert!(args.len() == 2);
 
             let int_val = env.builder.build_int_sub(
-                args[0].into_int_value(),
-                args[1].into_int_value(),
+                args[0].0.into_int_value(),
+                args[1].0.into_int_value(),
                 "sub_I64",
             );
 
@@ -680,8 +894,8 @@ fn call_with_args<'a, 'ctx, 'env>(
             debug_assert!(args.len() == 2);
 
             let float_val = env.builder.build_float_sub(
-                args[0].into_float_value(),
-                args[1].into_float_value(),
+                args[0].0.into_float_value(),
+                args[1].0.into_float_value(),
                 "sub_f64",
             );
 
@@ -691,8 +905,8 @@ fn call_with_args<'a, 'ctx, 'env>(
             debug_assert!(args.len() == 2);
 
             let int_val = env.builder.build_int_mul(
-                args[0].into_int_value(),
-                args[1].into_int_value(),
+                args[0].0.into_int_value(),
+                args[1].0.into_int_value(),
                 "mul_i64",
             );
 
@@ -703,29 +917,26 @@ fn call_with_args<'a, 'ctx, 'env>(
 
             let int_val = env
                 .builder
-                .build_int_neg(args[0].into_int_value(), "negate_i64");
+                .build_int_neg(args[0].0.into_int_value(), "negate_i64");
 
             BasicValueEnum::IntValue(int_val)
         }
         Symbol::LIST_LEN => {
             debug_assert!(args.len() == 1);
 
-            let wrapper_struct = args[0].into_struct_value();
+            let wrapper_struct = args[0].0.into_struct_value();
             let builder = env.builder;
 
-            // Get the 32-bit int length
-            let i32_val = builder.build_extract_value(wrapper_struct, Builtin::WRAPPER_LEN, "unwrapped_list_len").unwrap().into_int_value();
-
-            // cast the 32-bit length to a 64-bit int
-            BasicValueEnum::IntValue(builder.build_int_cast(i32_val, env.context.i64_type(), "i32_to_i64"))
+            // Get the usize int length
+            builder.build_extract_value(wrapper_struct, Builtin::WRAPPER_LEN, "unwrapped_list_len").unwrap().into_int_value().into()
         }
         Symbol::LIST_IS_EMPTY => {
             debug_assert!(args.len() == 1);
 
-            let list_struct = args[0].into_struct_value();
+            let list_struct = args[0].0.into_struct_value();
             let builder = env.builder;
             let list_len = builder.build_extract_value(list_struct, 1, "unwrapped_list_len").unwrap().into_int_value();
-            let zero = env.context.i32_type().const_zero();
+            let zero = env.ptr_int().const_zero();
             let answer = builder.build_int_compare(IntPredicate::EQ, list_len, zero, "is_zero");
 
             BasicValueEnum::IntValue(answer)
@@ -735,8 +946,8 @@ fn call_with_args<'a, 'ctx, 'env>(
 
             let int_val = env.builder.build_int_compare(
                 IntPredicate::EQ,
-                args[0].into_int_value(),
-                args[1].into_int_value(),
+                args[0].0.into_int_value(),
+                args[1].0.into_int_value(),
                 "cmp_i64",
             );
 
@@ -747,8 +958,8 @@ fn call_with_args<'a, 'ctx, 'env>(
 
             let int_val = env.builder.build_int_compare(
                 IntPredicate::EQ,
-                args[0].into_int_value(),
-                args[1].into_int_value(),
+                args[0].0.into_int_value(),
+                args[1].0.into_int_value(),
                 "cmp_i1",
             );
 
@@ -759,8 +970,8 @@ fn call_with_args<'a, 'ctx, 'env>(
 
             let int_val = env.builder.build_int_compare(
                 IntPredicate::EQ,
-                args[0].into_int_value(),
-                args[1].into_int_value(),
+                args[0].0.into_int_value(),
+                args[1].0.into_int_value(),
                 "cmp_i8",
             );
 
@@ -771,8 +982,8 @@ fn call_with_args<'a, 'ctx, 'env>(
 
             let int_val = env.builder.build_float_compare(
                 FloatPredicate::OEQ,
-                args[0].into_float_value(),
-                args[1].into_float_value(),
+                args[0].0.into_float_value(),
+                args[1].0.into_float_value(),
                 "cmp_f64",
             );
 
@@ -784,36 +995,45 @@ fn call_with_args<'a, 'ctx, 'env>(
             // List.get : List elem, Int -> Result elem [ OutOfBounds ]*
             debug_assert!(args.len() == 2);
 
-            let wrapper_struct = args[0].into_struct_value();
-            let elem_index = args[1].into_int_value();
+            let (_list_expr, list_layout) = &args[0];
 
-            // Slot 1 in the wrapper struct is the length
+            let wrapper_struct = args[0].0.into_struct_value();
+            let elem_index = args[1].0.into_int_value();
+
+            // Get the length from the wrapper struct
             let _list_len = builder.build_extract_value(wrapper_struct, Builtin::WRAPPER_LEN, "unwrapped_list_len").unwrap().into_int_value();
 
             // TODO here, check to see if the requested index exceeds the length of the array.
 
-            // Slot 0 in the wrapper struct is the pointer to the array data
-            let array_data_ptr = builder.build_extract_value(wrapper_struct, Builtin::WRAPPER_PTR, "unwrapped_list_ptr").unwrap().into_pointer_value();
+            match list_layout {
+                Layout::Builtin(Builtin::List(elem_layout)) => {
+                    // Get the pointer to the array data
+                    let array_data_ptr = builder.build_extract_value(wrapper_struct, Builtin::WRAPPER_PTR, "unwrapped_list_ptr").unwrap().into_pointer_value();
 
-            let elem_bytes = 8; // TODO Look this size up instead of hardcoding it!
-            let elem_size = env.context.i64_type().const_int(elem_bytes, false);
+                    let elem_bytes = elem_layout.stack_size(env.ptr_bytes) as u64;
+                    let elem_size = env.context.i64_type().const_int(elem_bytes, false);
 
-            // Calculate the offset at runtime by multiplying the index by the size of an element.
-            let offset_bytes = builder.build_int_mul(elem_index, elem_size, "mul_offset");
+                    // Calculate the offset at runtime by multiplying the index by the size of an element.
+                    let offset_bytes = builder.build_int_mul(elem_index, elem_size, "mul_offset");
 
-            // We already checked the bounds earlier.
-            let elem_ptr = unsafe { builder.build_in_bounds_gep(array_data_ptr, &[offset_bytes], "elem") };
+                    // We already checked the bounds earlier.
+                    let elem_ptr = unsafe { builder.build_in_bounds_gep(array_data_ptr, &[offset_bytes], "elem") };
 
-            builder.build_load(elem_ptr, "List.get")
+                    builder.build_load(elem_ptr, "List.get")
+                }
+                _ => {
+                    unreachable!("Invalid List layout for List.get: {:?}", list_layout);
+                }
+            }
         }
         Symbol::LIST_SET /* TODO clone first for LIST_SET! */ | Symbol::LIST_SET_IN_PLACE => {
             let builder = env.builder;
 
             debug_assert!(args.len() == 3);
 
-            let wrapper_struct = args[0].into_struct_value();
-            let elem_index = args[1].into_int_value();
-            let elem = args[2];
+            let wrapper_struct = args[0].0.into_struct_value();
+            let elem_index = args[1].0.into_int_value();
+            let (elem, elem_layout) = args[2];
 
             // Slot 1 in the wrapper struct is the length
             let _list_len = builder.build_extract_value(wrapper_struct, Builtin::WRAPPER_LEN, "unwrapped_list_len").unwrap().into_int_value();
@@ -824,7 +1044,7 @@ fn call_with_args<'a, 'ctx, 'env>(
             // Slot 0 in the wrapper struct is the pointer to the array data
             let array_data_ptr = builder.build_extract_value(wrapper_struct, Builtin::WRAPPER_PTR, "unwrapped_list_ptr").unwrap().into_pointer_value();
 
-            let elem_bytes = 8; // TODO Look this size up instead of hardcoding it!
+            let elem_bytes = elem_layout.stack_size(env.ptr_bytes) as u64;
             let elem_size = env.context.i64_type().const_int(elem_bytes, false);
 
             // Calculate the offset at runtime by multiplying the index by the size of an element.
@@ -845,7 +1065,13 @@ fn call_with_args<'a, 'ctx, 'env>(
                 .get_function(symbol.ident_string(&env.interns))
                 .unwrap_or_else(|| panic!("Unrecognized function: {:?}", symbol));
 
-            let call = env.builder.build_call(fn_val, args, "tmp");
+            let mut arg_vals: Vec<BasicValueEnum> = Vec::with_capacity_in(args.len(), env.arena);
+
+            for (arg, _layout) in args.iter() {
+                arg_vals.push(*arg);
+            }
+
+            let call = env.builder.build_call(fn_val, arg_vals.into_bump_slice(), "call");
 
             call.try_as_basic_value()
                 .left()
diff --git a/compiler/gen/src/llvm/convert.rs b/compiler/gen/src/llvm/convert.rs
index 2c8c16dd6e..0d6b558b14 100644
--- a/compiler/gen/src/llvm/convert.rs
+++ b/compiler/gen/src/llvm/convert.rs
@@ -2,7 +2,7 @@ use bumpalo::collections::Vec;
 use bumpalo::Bump;
 use inkwell::context::Context;
 use inkwell::types::BasicTypeEnum::{self, *};
-use inkwell::types::{ArrayType, BasicType, FunctionType, PointerType, StructType};
+use inkwell::types::{ArrayType, BasicType, FunctionType, IntType, PointerType, StructType};
 use inkwell::AddressSpace;
 
 use roc_mono::layout::Layout;
@@ -38,17 +38,20 @@ pub fn basic_type_from_layout<'ctx>(
     arena: &Bump,
     context: &'ctx Context,
     layout: &Layout<'_>,
+    ptr_bytes: u32,
 ) -> BasicTypeEnum<'ctx> {
     use roc_mono::layout::Builtin::*;
     use roc_mono::layout::Layout::*;
 
     match layout {
         FunctionPointer(args, ret_layout) => {
-            let ret_type = basic_type_from_layout(arena, context, &ret_layout);
+            let ret_type = basic_type_from_layout(arena, context, &ret_layout, ptr_bytes);
             let mut arg_basic_types = Vec::with_capacity_in(args.len(), arena);
 
             for arg_layout in args.iter() {
-                arg_basic_types.push(basic_type_from_layout(arena, context, arg_layout));
+                arg_basic_types.push(basic_type_from_layout(
+                    arena, context, arg_layout, ptr_bytes,
+                ));
             }
 
             let fn_type = get_fn_type(&ret_type, arg_basic_types.into_bump_slice());
@@ -61,24 +64,50 @@ pub fn basic_type_from_layout<'ctx>(
             let mut field_types = Vec::with_capacity_in(sorted_fields.len(), arena);
 
             for (_, field_layout) in sorted_fields.iter() {
-                field_types.push(basic_type_from_layout(arena, context, field_layout));
+                field_types.push(basic_type_from_layout(
+                    arena,
+                    context,
+                    field_layout,
+                    ptr_bytes,
+                ));
             }
 
             context
                 .struct_type(field_types.into_bump_slice(), false)
                 .as_basic_type_enum()
         }
-        Tag(_fields) => {
-            panic!("TODO layout_to_basic_type for Tag");
+        Union(tags) if tags.len() == 1 => {
+            let layouts = tags.iter().next().unwrap();
+
+            // Determine types
+            let mut field_types = Vec::with_capacity_in(layouts.len(), arena);
+
+            for layout in layouts.iter() {
+                field_types.push(basic_type_from_layout(arena, context, layout, ptr_bytes));
+            }
+
+            context
+                .struct_type(field_types.into_bump_slice(), false)
+                .as_basic_type_enum()
         }
-        Pointer(_layout) => {
-            panic!("TODO layout_to_basic_type for Pointer");
+        Union(_) => {
+            // TODO make this dynamic
+            let ptr_size = std::mem::size_of::<i64>();
+            let union_size = layout.stack_size(ptr_size as u32);
+
+            let array_type = context
+                .i8_type()
+                .array_type(union_size)
+                .as_basic_type_enum();
+
+            context.struct_type(&[array_type], false).into()
         }
+
         Builtin(builtin) => match builtin {
             Int64 => context.i64_type().as_basic_type_enum(),
             Float64 => context.f64_type().as_basic_type_enum(),
-            Bool(_, _) => context.bool_type().as_basic_type_enum(),
-            Byte(_) => context.i8_type().as_basic_type_enum(),
+            Bool => context.bool_type().as_basic_type_enum(),
+            Byte => context.i8_type().as_basic_type_enum(),
             Str | EmptyStr => context
                 .i8_type()
                 .ptr_type(AddressSpace::Generic)
@@ -86,17 +115,17 @@ pub fn basic_type_from_layout<'ctx>(
             Map(_, _) | EmptyMap => panic!("TODO layout_to_basic_type for Builtin::Map"),
             Set(_) | EmptySet => panic!("TODO layout_to_basic_type for Builtin::Set"),
             List(elem_layout) => {
-                let ptr_type = basic_type_from_layout(arena, context, elem_layout)
+                let ptr_type = basic_type_from_layout(arena, context, elem_layout, ptr_bytes)
                     .ptr_type(AddressSpace::Generic);
 
-                collection_wrapper(context, ptr_type).into()
+                collection_wrapper(context, ptr_type, ptr_bytes).into()
             }
             EmptyList => {
                 let array_type =
                     get_array_type(&context.opaque_struct_type("empty_list_elem").into(), 0);
                 let ptr_type = array_type.ptr_type(AddressSpace::Generic);
 
-                collection_wrapper(context, ptr_type).into()
+                collection_wrapper(context, ptr_type, ptr_bytes).into()
             }
         },
     }
@@ -106,9 +135,24 @@ pub fn basic_type_from_layout<'ctx>(
 pub fn collection_wrapper<'ctx>(
     ctx: &'ctx Context,
     ptr_type: PointerType<'ctx>,
+    ptr_bytes: u32,
 ) -> StructType<'ctx> {
     let ptr_type_enum = BasicTypeEnum::PointerType(ptr_type);
-    let u32_type = BasicTypeEnum::IntType(ctx.i32_type());
+    let len_type = BasicTypeEnum::IntType(ptr_int(ctx, ptr_bytes));
 
-    ctx.struct_type(&[ptr_type_enum, u32_type, u32_type], false)
+    ctx.struct_type(&[ptr_type_enum, len_type], false)
+}
+
+pub fn ptr_int(ctx: &Context, ptr_bytes: u32) -> IntType<'_> {
+    match ptr_bytes {
+        1 => ctx.i8_type(),
+        2 => ctx.i16_type(),
+        4 => ctx.i32_type(),
+        8 => ctx.i64_type(),
+        16 => ctx.i128_type(),
+        _ => panic!(
+            "Invalid target: Roc does't support compiling to {}-bit systems.",
+            ptr_bytes * 8
+        ),
+    }
 }
diff --git a/compiler/gen/tests/test_gen.rs b/compiler/gen/tests/test_gen.rs
index 944a780945..6636d4d572 100644
--- a/compiler/gen/tests/test_gen.rs
+++ b/compiler/gen/tests/test_gen.rs
@@ -77,6 +77,7 @@ mod test_gen {
             // Populate Procs and Subs, and get the low-level Expr from the canonical Expr
             let mono_expr = Expr::new(&arena, &mut subs, loc_expr.value, &mut procs, home, &mut ident_ids, POINTER_SIZE);
 
+
             // Put this module's ident_ids back in the interns
             env.interns.all_ident_ids.insert(home, ident_ids);
 
@@ -147,7 +148,7 @@ mod test_gen {
                 builder.finalize();
             }
 
-            module.define_function(main_fn, &mut ctx).expect("declare main");
+            module.define_function(main_fn, &mut ctx).expect("crane declare main");
             module.clear_context(&mut ctx);
 
             // Perform linking
@@ -200,16 +201,16 @@ mod test_gen {
             // Compute main_fn_type before moving subs to Env
             let layout = Layout::from_content(&arena, content, &subs, POINTER_SIZE)
         .unwrap_or_else(|err| panic!("Code gen error in test: could not convert to layout. Err was {:?} and Subs were {:?}", err, subs));
-            let main_fn_type = basic_type_from_layout(&arena, &context, &layout)
-                .fn_type(&[], false);
-            let main_fn_name = "$Test.main";
-
             let execution_engine =
                 module
                 .create_jit_execution_engine(OptimizationLevel::None)
                 .expect("Error creating JIT execution engine for test");
 
-            let pointer_bytes = execution_engine.get_target_data().get_pointer_byte_size(None);
+            let ptr_bytes = execution_engine.get_target_data().get_pointer_byte_size(None);
+
+            let main_fn_type = basic_type_from_layout(&arena, &context, &layout, ptr_bytes)
+                .fn_type(&[], false);
+            let main_fn_name = "$Test.main";
 
             // Compile and add all the Procs before adding main
             let mut env = roc_gen::llvm::build::Env {
@@ -218,7 +219,7 @@ mod test_gen {
                 context: &context,
                 interns,
                 module: arena.alloc(module),
-                pointer_bytes
+                ptr_bytes
             };
             let mut procs = Procs::default();
             let mut ident_ids = env.interns.all_ident_ids.remove(&home).unwrap();
@@ -226,6 +227,8 @@ mod test_gen {
             // Populate Procs and get the low-level Expr from the canonical Expr
             let main_body = Expr::new(&arena, &mut subs, loc_expr.value, &mut procs, home, &mut ident_ids, POINTER_SIZE);
 
+            dbg!(&main_body);
+
             // Put this module's ident_ids back in the interns, so we can use them in Env.
             env.interns.all_ident_ids.insert(home, ident_ids);
 
@@ -335,16 +338,16 @@ mod test_gen {
             // Compute main_fn_type before moving subs to Env
             let layout = Layout::from_content(&arena, content, &subs, POINTER_SIZE)
         .unwrap_or_else(|err| panic!("Code gen error in test: could not convert to layout. Err was {:?} and Subs were {:?}", err, subs));
-            let main_fn_type = basic_type_from_layout(&arena, &context, &layout)
-                .fn_type(&[], false);
-            let main_fn_name = "$Test.main";
 
             let execution_engine =
                 module
                 .create_jit_execution_engine(OptimizationLevel::None)
                 .expect("Error creating JIT execution engine for test");
 
-            let pointer_bytes = execution_engine.get_target_data().get_pointer_byte_size(None);
+            let ptr_bytes = execution_engine.get_target_data().get_pointer_byte_size(None);
+            let main_fn_type = basic_type_from_layout(&arena, &context, &layout, ptr_bytes)
+                .fn_type(&[], false);
+            let main_fn_name = "$Test.main";
 
             // Compile and add all the Procs before adding main
             let mut env = roc_gen::llvm::build::Env {
@@ -353,7 +356,7 @@ mod test_gen {
                 context: &context,
                 interns,
                 module: arena.alloc(module),
-                pointer_bytes
+                ptr_bytes
             };
             let mut procs = Procs::default();
             let mut ident_ids = env.interns.all_ident_ids.remove(&home).unwrap();
@@ -550,7 +553,26 @@ mod test_gen {
     }
 
     #[test]
-    fn get_shared_int_list() {
+    fn set_shared_int_list() {
+        assert_crane_evals_to!(
+            indoc!(
+                r#"
+                    shared = [ 2, 4 ]
+
+                    # This should not mutate the original
+                    x = List.set shared 1 77
+
+                    List.getUnsafe shared 1
+                "#
+            ),
+            4,
+            i64,
+            |x| x
+        );
+    }
+
+    #[test]
+    fn get_unique_int_list() {
         assert_evals_to!(
             indoc!(
                 r#"
@@ -594,6 +616,23 @@ mod test_gen {
         );
     }
 
+    // doesn't work yet. The condition must be cast to an integer to use a jump table
+    //    #[test]
+    //    fn branch_third_float() {
+    //        assert_evals_to!(
+    //            indoc!(
+    //                r#"
+    //                when 10.0 is
+    //                    1.0 -> 63
+    //                    2 -> 48
+    //                    _ -> 112
+    //                "#
+    //            ),
+    //            112.0,
+    //            f64
+    //        );
+    //    }
+
     #[test]
     fn branch_first_int() {
         assert_evals_to!(
@@ -624,6 +663,85 @@ mod test_gen {
         );
     }
 
+    #[test]
+    fn branch_third_int() {
+        assert_evals_to!(
+            indoc!(
+                r#"
+                when 10 is
+                    1 -> 63
+                    2 -> 48
+                    _ -> 112
+                "#
+            ),
+            112,
+            i64
+        );
+    }
+
+    #[test]
+    fn branch_store_variable() {
+        assert_evals_to!(
+            indoc!(
+                r#"
+                        when 0 is
+                            1 -> 12
+                            a -> a
+                    "#
+            ),
+            0,
+            i64
+        );
+    }
+
+    #[test]
+    fn one_element_tag() {
+        assert_evals_to!(
+            indoc!(
+                r#"
+                x : [ Pair Int ]
+                x = Pair 2
+
+                0x3
+                "#
+            ),
+            3,
+            i64
+        );
+    }
+
+    #[test]
+    fn when_one_element_tag() {
+        assert_evals_to!(
+            indoc!(
+                r#"
+                x : [ Pair Int Int ]
+                x = Pair 0x2 0x3
+
+                when x is
+                    Pair l r -> l + r
+                "#
+            ),
+            5,
+            i64
+        );
+    }
+
+    #[test]
+    fn twice_record_access() {
+        assert_evals_to!(
+            indoc!(
+                r#"
+                x =  {a: 0x2, b: 0x3 }
+
+                x.a + x.b
+                "#
+            ),
+            5,
+            i64
+        );
+    }
+
     #[test]
     fn gen_when_one_branch() {
         assert_evals_to!(
@@ -1065,6 +1183,136 @@ mod test_gen {
         );
     }
 
+    #[test]
+    fn applied_tag_nothing() {
+        assert_evals_to!(
+            indoc!(
+                r#"
+                Maybe a : [ Just a, Nothing ]
+
+                x : Maybe Int
+                x = Nothing
+
+                0x1
+                "#
+            ),
+            1,
+            i64
+        );
+    }
+    #[test]
+    fn applied_tag_just() {
+        assert_evals_to!(
+            indoc!(
+                r#"
+                Maybe a : [ Just a, Nothing ]
+
+                y : Maybe Int
+                y = Just 0x4
+
+                0x1
+                "#
+            ),
+            1,
+            i64
+        );
+    }
+
+    //
+    //    #[test]
+    //    fn applied_tag_just_unit() {
+    //        assert_evals_to!(
+    //            indoc!(
+    //                r#"
+    //                Fruit : [ Orange, Apple, Banana ]
+    //                Maybe a : [ Just a, Nothing ]
+    //
+    //                orange : Fruit
+    //                orange = Orange
+    //
+    //                y : Maybe Fruit
+    //                y = Just orange
+    //
+    //                0x1
+    //                "#
+    //            ),
+    //            1,
+    //            i64
+    //        );
+    //    }
+
+    #[test]
+    fn when_on_nothing() {
+        assert_evals_to!(
+            indoc!(
+                r#"
+                x : [ Nothing, Just Int ]
+                x = Nothing
+
+                when x is
+                    Nothing -> 0x2
+                    Just _ -> 0x1
+                "#
+            ),
+            2,
+            i64
+        );
+    }
+
+    //    #[test]
+    //    fn when_on_just() {
+    //        assert_evals_to!(
+    //            indoc!(
+    //                r#"
+    //                x : [ Nothing, Just Int ]
+    //                x = Just 41
+    //
+    //                case x of
+    //                    Just v -> v + 0x1
+    //                    Nothing -> 0x1
+    //                "#
+    //            ),
+    //            42,
+    //            i64
+    //        );
+    //    }
+
+    #[test]
+    fn when_on_result() {
+        assert_evals_to!(
+            indoc!(
+                r#"
+                x : Result Int Int
+                x = Err 41
+
+                when x is
+                    Err v ->  v + 1
+                    Ok _ -> 1
+                "#
+            ),
+            42,
+            i64
+        );
+    }
+
+    #[test]
+    fn when_on_these() {
+        assert_evals_to!(
+            indoc!(
+                r#"
+                x : [ This Int, These Int Int ]
+                x = These 0x3 0x2
+
+                when x is
+                    These a b -> a + b
+                    This v -> v
+                "#
+            ),
+            5,
+            i64
+        );
+    }
+
     #[test]
     fn basic_record() {
         assert_evals_to!(
@@ -1174,5 +1422,17 @@ mod test_gen {
             19,
             i64
         );
+
+        assert_evals_to!(
+            indoc!(
+                r#"
+                    rec = { x: 15, y: 17, z: 19 }
+
+                    rec.z + rec.x
+                "#
+            ),
+            34,
+            i64
+        );
     }
 }
diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs
new file mode 100644
index 0000000000..f85df484e4
--- /dev/null
+++ b/compiler/mono/src/decision_tree.rs
@@ -0,0 +1,1137 @@
+use crate::expr::Env;
+use crate::expr::Expr;
+use crate::expr::Pattern;
+use roc_collections::all::{MutMap, MutSet};
+use roc_module::ident::TagName;
+use roc_module::symbol::Symbol;
+
+use crate::layout::Builtin;
+use crate::layout::Layout;
+
+/// COMPILE CASES
+
+type Label = u64;
+
+/// Users of this module will mainly interact with this function. It takes
+/// some normal branches and gives out a decision tree that has "labels" at all
+/// the leafs and a dictionary that maps these "labels" to the code that should
+/// run.
+pub fn compile(raw_branches: Vec<(Pattern<'_>, u64)>) -> DecisionTree {
+    let formatted = raw_branches
+        .into_iter()
+        .map(|(pattern, index)| Branch {
+            goal: index,
+            patterns: vec![(Path::Empty, pattern)],
+        })
+        .collect();
+
+    to_decision_tree(formatted)
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum DecisionTree<'a> {
+    Match(Label),
+    Decision {
+        path: Path,
+        edges: Vec<(Test<'a>, DecisionTree<'a>)>,
+        default: Option<Box<DecisionTree<'a>>>,
+    },
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Test<'a> {
+    IsCtor {
+        tag_id: u8,
+        tag_name: TagName,
+        union: crate::pattern::Union,
+        arguments: Vec<(Pattern<'a>, Layout<'a>)>,
+    },
+    IsInt(i64),
+    // float patterns are stored as u64 so they are comparable/hashable
+    IsFloat(u64),
+    IsStr(Box<str>),
+    IsBit(bool),
+    IsByte {
+        tag_id: u8,
+        num_alts: usize,
+    },
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Path {
+    Index { index: u64, path: Box<Path> },
+    Unbox(Box<Path>),
+    Empty,
+}
+
+// ACTUALLY BUILD DECISION TREES
+
+#[derive(Clone, Debug, PartialEq)]
+struct Branch<'a> {
+    goal: Label,
+    patterns: Vec<(Path, Pattern<'a>)>,
+}
+
+fn to_decision_tree(raw_branches: Vec<Branch>) -> DecisionTree {
+    let branches: Vec<_> = raw_branches.into_iter().map(flatten_patterns).collect();
+
+    match check_for_match(&branches) {
+        Some(goal) => DecisionTree::Match(goal),
+        None => {
+            // TODO remove clone
+            let path = pick_path(branches.clone());
+
+            let (edges, fallback) = gather_edges(branches, &path);
+
+            let mut decision_edges: Vec<_> = edges
+                .into_iter()
+                .map(|(a, b)| (a, to_decision_tree(b)))
+                .collect();
+
+            match (decision_edges.split_last_mut(), fallback.split_last()) {
+                (Some(((_tag, decision_tree), rest)), None) if rest.is_empty() => {
+                    // TODO remove clone
+                    decision_tree.clone()
+                }
+                (_, None) => DecisionTree::Decision {
+                    path,
+                    edges: decision_edges,
+                    default: None,
+                },
+                (None, Some(_)) => to_decision_tree(fallback),
+                _ => DecisionTree::Decision {
+                    path,
+                    edges: decision_edges,
+                    default: Some(Box::new(to_decision_tree(fallback))),
+                },
+            }
+        }
+    }
+}
+
+fn is_complete(tests: &[Test]) -> bool {
+    let length = tests.len();
+    debug_assert!(length > 0);
+    match tests.get(length - 1) {
+        None => unreachable!("should never happen"),
+        Some(v) => match v {
+            Test::IsCtor { union, .. } => length == union.alternatives.len(),
+            Test::IsByte { num_alts, .. } => length == *num_alts,
+            Test::IsBit(_) => length == 2,
+            Test::IsInt(_) => false,
+            Test::IsFloat(_) => false,
+            Test::IsStr(_) => false,
+        },
+    }
+}
+
+fn flatten_patterns(branch: Branch) -> Branch {
+    let mut result = Vec::with_capacity(branch.patterns.len());
+
+    for path_pattern in branch.patterns {
+        flatten(path_pattern, &mut result);
+    }
+    Branch {
+        goal: branch.goal,
+        patterns: result,
+    }
+}
+
+fn flatten<'a>(path_pattern: (Path, Pattern<'a>), path_patterns: &mut Vec<(Path, Pattern<'a>)>) {
+    match &path_pattern.1 {
+        Pattern::AppliedTag { union, .. } => {
+            if union.alternatives.len() == 1 {
+                //        case map dearg ctorArgs of
+                //          [arg] ->
+                //            flatten (Unbox path, arg) otherPathPatterns
+                //
+                //          args ->
+                //            foldr flatten otherPathPatterns (subPositions path args)
+                // subPositions :: Path -> [Can.Pattern] -> [(Path, Can.Pattern)]
+                // subPositions path patterns =
+                //   Index.indexedMap (\index pattern -> (Index index path, pattern)) patterns
+                //
+                //
+                // dearg :: Can.PatternCtorArg -> Can.Pattern
+                // dearg (Can.PatternCtorArg _ _ pattern) =
+                //   pattern
+
+                todo!()
+            } else {
+                path_patterns.push(path_pattern);
+            }
+        }
+
+        _ => {
+            path_patterns.push(path_pattern);
+        }
+    }
+}
+
+/// SUCCESSFULLY MATCH
+
+/// If the first branch has no more "decision points" we can finally take that
+/// path. If that is the case we give the resulting label and a mapping from free
+/// variables to "how to get their value". So a pattern like (Just (x,_)) will give
+/// us something like ("x" => value.0.0)
+fn check_for_match(branches: &Vec<Branch>) -> Option<Label> {
+    match branches.get(0) {
+        Some(Branch { goal, patterns }) if patterns.iter().all(|(_, p)| !needs_tests(p)) => {
+            Some(*goal)
+        }
+        _ => None,
+    }
+}
+
+/// GATHER OUTGOING EDGES
+
+fn gather_edges<'a>(
+    branches: Vec<Branch<'a>>,
+    path: &Path,
+) -> (Vec<(Test<'a>, Vec<Branch<'a>>)>, Vec<Branch<'a>>) {
+    // TODO remove clone
+    let relevant_tests = tests_at_path(path, branches.clone());
+
+    let check = is_complete(&relevant_tests);
+
+    // TODO remove clone
+    let all_edges = relevant_tests
+        .into_iter()
+        .map(|t| edges_for(path, branches.clone(), t))
+        .collect();
+
+    let fallbacks = if check {
+        vec![]
+    } else {
+        branches
+            .into_iter()
+            .filter(|b| is_irrelevant_to(path, b))
+            .collect()
+    };
+
+    (all_edges, fallbacks)
+}
+
+/// FIND RELEVANT TESTS
+
+fn tests_at_path<'a>(selected_path: &Path, branches: Vec<Branch<'a>>) -> Vec<Test<'a>> {
+    // NOTE the ordering of the result is important!
+
+    let mut visited = MutSet::default();
+    let mut unique = Vec::new();
+
+    let all_tests = branches
+        .into_iter()
+        .filter_map(|b| test_at_path(selected_path, b));
+
+    for test in all_tests {
+        if !visited.contains(&test) {
+            visited.insert(test.clone());
+            unique.push(test);
+        }
+    }
+
+    unique
+}
+
+fn test_at_path<'a>(selected_path: &Path, branch: Branch<'a>) -> Option<Test<'a>> {
+    use Pattern::*;
+    use Test::*;
+
+    match branch
+        .patterns
+        .iter()
+        .find(|(path, _)| path == selected_path)
+    {
+        None => None,
+        Some((_, pattern)) => match pattern {
+            Identifier(_)
+            | RecordDestructure(_, _)
+            | Underscore
+            | Shadowed(_, _)
+            | UnsupportedPattern(_) => None,
+
+            AppliedTag {
+                tag_name,
+                tag_id,
+                arguments,
+                union,
+                ..
+            } => Some(IsCtor {
+                tag_id: *tag_id,
+                tag_name: tag_name.clone(),
+                union: union.clone(),
+                arguments: arguments.to_vec(),
+            }),
+            BitLiteral(v) => Some(IsBit(*v)),
+            EnumLiteral { tag_id, enum_size } => Some(IsByte {
+                tag_id: *tag_id,
+                num_alts: *enum_size as usize,
+            }),
+            IntLiteral(v) => Some(IsInt(*v)),
+            FloatLiteral(v) => Some(IsFloat(*v)),
+            StrLiteral(v) => Some(IsStr(v.clone())),
+        },
+    }
+}
+
+/// BUILD EDGES
+
+fn edges_for<'a>(
+    path: &Path,
+    branches: Vec<Branch<'a>>,
+    test: Test<'a>,
+) -> (Test<'a>, Vec<Branch<'a>>) {
+    let new_branches = branches
+        .into_iter()
+        .filter_map(|b| to_relevant_branch(&test, path, b))
+        .collect();
+
+    (test, new_branches)
+}
+
+fn to_relevant_branch<'a>(test: &Test<'a>, path: &Path, branch: Branch<'a>) -> Option<Branch<'a>> {
+    use Pattern::*;
+    use Test::*;
+
+    // TODO remove clone
+    match extract(path, branch.patterns.clone()) {
+        Extract::NotFound => Some(branch),
+        Extract::Found {
+            mut start,
+            found_pattern: pattern,
+            end,
+        } => match pattern {
+            RecordDestructure(_, _)
+            | Identifier(_)
+            | Underscore
+            | Shadowed(_, _)
+            | UnsupportedPattern(_) => Some(branch),
+            AppliedTag {
+                union,
+                tag_name,
+                arguments,
+                ..
+            } => {
+                let mut arguments: Vec<_> = arguments.into_iter().map(|v| v.0).collect();
+                match test {
+                    IsCtor {
+                        tag_name: test_name,
+                        ..
+                    } if &tag_name == test_name => {
+                        // TODO can't we unbox whenever there is just one alternative, even if
+                        // there are multiple arguments?
+                        if arguments.len() == 1 && union.alternatives.len() == 1 {
+                            let arg = arguments.remove(0);
+                            {
+                                start.push((Path::Unbox(Box::new(path.clone())), arg));
+                                start.extend(end);
+                            }
+                        } else {
+                            let sub_positions =
+                                arguments.into_iter().enumerate().map(|(index, pattern)| {
+                                    (
+                                        Path::Index {
+                                            index: index as u64,
+                                            path: Box::new(path.clone()),
+                                        },
+                                        pattern,
+                                    )
+                                });
+                            start.extend(sub_positions);
+                            start.extend(end);
+                        }
+
+                        Some(Branch {
+                            goal: branch.goal,
+                            patterns: start,
+                        })
+                    }
+                    _ => None,
+                }
+                /*
+                 *
+                Can.PCtor _ _ (Can.Union _ _ numAlts _) name _ ctorArgs ->
+                    case test of
+                      IsCtor _ testName _ _ _ | name == testName ->
+                        Just $ Branch goal $
+                          case map dearg ctorArgs of
+                            [arg] | numAlts == 1 ->
+                              start ++ [(Unbox path, arg)] ++ end
+
+                            args ->
+                              start ++ subPositions path args ++ end
+
+                      _ ->
+                        Nothing
+                      */
+            }
+            StrLiteral(string) => match test {
+                IsStr(test_str) if string == *test_str => {
+                    start.extend(end);
+                    Some(Branch {
+                        goal: branch.goal,
+                        patterns: start,
+                    })
+                }
+                _ => None,
+            },
+
+            IntLiteral(int) => match test {
+                IsInt(is_int) if int == *is_int => {
+                    start.extend(end);
+                    Some(Branch {
+                        goal: branch.goal,
+                        patterns: start,
+                    })
+                }
+                _ => None,
+            },
+
+            FloatLiteral(float) => match test {
+                IsFloat(test_float) if float == *test_float => {
+                    start.extend(end);
+                    Some(Branch {
+                        goal: branch.goal,
+                        patterns: start,
+                    })
+                }
+                _ => None,
+            },
+
+            BitLiteral(bit) => match test {
+                IsBit(test_bit) if bit == *test_bit => {
+                    start.extend(end);
+                    Some(Branch {
+                        goal: branch.goal,
+                        patterns: start,
+                    })
+                }
+                _ => None,
+            },
+
+            EnumLiteral { tag_id, .. } => match test {
+                IsByte {
+                    tag_id: test_id, ..
+                } if tag_id == *test_id => {
+                    start.extend(end);
+                    Some(Branch {
+                        goal: branch.goal,
+                        patterns: start,
+                    })
+                }
+
+                _ => None,
+            },
+        },
+    }
+}
+
+enum Extract<'a> {
+    NotFound,
+    Found {
+        start: Vec<(Path, Pattern<'a>)>,
+        found_pattern: Pattern<'a>,
+        end: Vec<(Path, Pattern<'a>)>,
+    },
+}
+
+fn extract<'a>(selected_path: &Path, path_patterns: Vec<(Path, Pattern<'a>)>) -> Extract<'a> {
+    let mut start = Vec::new();
+
+    // TODO remove this clone
+    let mut copy = path_patterns.clone();
+
+    // TODO potential ordering problem
+    for (index, current) in path_patterns.into_iter().enumerate() {
+        if &current.0 == selected_path {
+            return Extract::Found {
+                start,
+                found_pattern: current.1,
+                end: {
+                    copy.drain(0..=index);
+                    copy
+                },
+            };
+        } else {
+            start.push(current);
+        }
+    }
+
+    Extract::NotFound
+}
+
+/// FIND IRRELEVANT BRANCHES
+
+fn is_irrelevant_to<'a>(selected_path: &Path, branch: &Branch<'a>) -> bool {
+    match branch
+        .patterns
+        .iter()
+        .find(|(path, _)| path == selected_path)
+    {
+        None => true,
+        Some((_, pattern)) => !needs_tests(pattern),
+    }
+}
+
+fn needs_tests<'a>(pattern: &Pattern<'a>) -> bool {
+    use Pattern::*;
+
+    match pattern {
+        Identifier(_) | Underscore | Shadowed(_, _) | UnsupportedPattern(_) => false,
+
+        RecordDestructure(_, _)
+        | AppliedTag { .. }
+        | BitLiteral(_)
+        | EnumLiteral { .. }
+        | IntLiteral(_)
+        | FloatLiteral(_)
+        | StrLiteral(_) => true,
+    }
+}
+
+/// PICK A PATH
+
+fn pick_path(branches: Vec<Branch>) -> Path {
+    // TODO remove this clone
+    let all_paths = branches
+        .clone()
+        .into_iter()
+        .map(|v| v.patterns)
+        .flatten()
+        .filter_map(is_choice_path);
+
+    let mut by_small_defaults = bests_by_small_defaults(&branches, all_paths);
+
+    if by_small_defaults.len() == 1 {
+        by_small_defaults.remove(0)
+    } else {
+        debug_assert!(!by_small_defaults.is_empty());
+        let mut result = bests_by_small_branching_factor(&branches, by_small_defaults.into_iter());
+
+        match result.pop() {
+            None => unreachable!("bests_by will always return at least one value in the vec"),
+            Some(path) => path,
+        }
+    }
+}
+
+fn is_choice_path(path_and_pattern: (Path, Pattern<'_>)) -> Option<Path> {
+    let (path, pattern) = path_and_pattern;
+
+    if needs_tests(&pattern) {
+        Some(path)
+    } else {
+        None
+    }
+}
+
+fn bests_by_small_branching_factor<I>(branches: &Vec<Branch>, mut all_paths: I) -> Vec<Path>
+where
+    I: Iterator<Item = Path>,
+{
+    match all_paths.next() {
+        None => panic!("Cannot choose the best of zero paths. This should never happen."),
+        Some(first_path) => {
+            let mut min_weight = small_branching_factor(branches, &first_path);
+            let mut min_paths = vec![first_path];
+
+            for path in all_paths {
+                let weight = small_branching_factor(branches, &path);
+
+                use std::cmp::Ordering;
+                match weight.cmp(&min_weight) {
+                    Ordering::Equal => {
+                        min_paths.push(path.clone());
+                    }
+                    Ordering::Less => {
+                        min_weight = weight;
+                        min_paths.clear();
+                        min_paths.push(path);
+                    }
+                    Ordering::Greater => {}
+                }
+            }
+
+            min_paths
+        }
+    }
+}
+
+fn bests_by_small_defaults<I>(branches: &Vec<Branch>, mut all_paths: I) -> Vec<Path>
+where
+    I: Iterator<Item = Path>,
+{
+    match all_paths.next() {
+        None => panic!("Cannot choose the best of zero paths. This should never happen."),
+        Some(first_path) => {
+            let mut min_weight = small_defaults(branches, &first_path);
+            let mut min_paths = vec![first_path];
+
+            for path in all_paths {
+                let weight = small_defaults(branches, &path);
+
+                use std::cmp::Ordering;
+                match weight.cmp(&min_weight) {
+                    Ordering::Equal => {
+                        min_paths.push(path.clone());
+                    }
+                    Ordering::Less => {
+                        min_weight = weight;
+                        min_paths.clear();
+                        min_paths.push(path);
+                    }
+                    Ordering::Greater => {}
+                }
+            }
+
+            min_paths
+        }
+    }
+}
+
+/// PATH PICKING HEURISTICS
+
+fn small_defaults(branches: &Vec<Branch>, path: &Path) -> usize {
+    branches
+        .iter()
+        .filter(|b| is_irrelevant_to(path, b))
+        .map(|_| 1)
+        .sum()
+}
+
+fn small_branching_factor(branches: &Vec<Branch>, path: &Path) -> usize {
+    // TODO remove clone
+    let (edges, fallback) = gather_edges(branches.to_vec(), path);
+
+    edges.len() + (if fallback.is_empty() { 0 } else { 1 })
+}
+
+#[derive(Clone, Debug, PartialEq)]
+enum Decider<'a, T> {
+    Leaf(T),
+    Chain {
+        test_chain: Vec<(Path, Test<'a>)>,
+        success: Box<Decider<'a, T>>,
+        failure: Box<Decider<'a, T>>,
+    },
+    FanOut {
+        path: Path,
+        tests: Vec<(Test<'a>, Decider<'a, T>)>,
+        fallback: Box<Decider<'a, T>>,
+    },
+}
+
+#[derive(Clone, Debug, PartialEq)]
+enum Choice<'a> {
+    Inline(Expr<'a>),
+    Jump(Label),
+}
+
+pub fn optimize_when<'a>(
+    env: &mut Env<'a, '_>,
+    cond_symbol: Symbol,
+    cond_layout: Layout<'a>,
+    ret_layout: Layout<'a>,
+    opt_branches: Vec<(Pattern<'a>, Expr<'a>)>,
+) -> Expr<'a> {
+    let (patterns, _indexed_branches) = opt_branches
+        .into_iter()
+        .enumerate()
+        .map(|(index, (pattern, branch))| ((pattern, index as u64), (index as u64, branch)))
+        .unzip();
+
+    let indexed_branches: Vec<(u64, Expr<'a>)> = _indexed_branches;
+
+    let decision_tree = compile(patterns);
+    let decider = tree_to_decider(decision_tree);
+    let target_counts = count_targets(&decider);
+
+    let mut choices = MutMap::default();
+    let mut jumps = Vec::new();
+
+    for (index, branch) in indexed_branches.into_iter() {
+        let ((branch_index, choice), opt_jump) = create_choices(&target_counts, index, branch);
+
+        if let Some(jump) = opt_jump {
+            jumps.push(jump);
+        }
+
+        choices.insert(branch_index, choice);
+    }
+
+    let choice_decider = insert_choices(&choices, decider);
+
+    let result = decide_to_branching(
+        env,
+        cond_symbol,
+        cond_layout,
+        ret_layout,
+        choice_decider,
+        &jumps,
+    );
+
+    // increase the jump counter by the number of jumps in this branching structure
+    *env.jump_counter += jumps.len() as u64;
+
+    result
+}
+
+fn path_to_expr<'a>(
+    env: &mut Env<'a, '_>,
+    symbol: Symbol,
+    path: &Path,
+    is_unwrapped: bool,
+    field_layouts: Layout<'a>,
+) -> Expr<'a> {
+    match path {
+        Path::Unbox(ref path) => path_to_expr(env, symbol, path, true, field_layouts),
+
+        // TODO make this work with AccessAtIndex.
+        // that already works for structs, but not for basic types for some reason
+        //            Expr::AccessAtIndex {
+        //                index: 0,
+        //                field_layouts: env.arena.alloc([field_layouts]),
+        //                expr: env.arena.alloc(Expr::Load(symbol)),
+        //            },
+        Path::Empty => Expr::Load(symbol),
+
+        // TODO path contains a nested path. Traverse all the way
+        Path::Index { index, .. } => Expr::AccessAtIndex {
+            index: *index,
+            field_layouts: env.arena.alloc([Layout::Builtin(Builtin::Byte)]),
+            expr: env.arena.alloc(Expr::Load(symbol)),
+            is_unwrapped,
+        },
+    }
+}
+
+fn decide_to_branching<'a>(
+    env: &mut Env<'a, '_>,
+    cond_symbol: Symbol,
+    cond_layout: Layout<'a>,
+    ret_layout: Layout<'a>,
+    decider: Decider<'a, Choice<'a>>,
+    jumps: &Vec<(u64, Expr<'a>)>,
+) -> Expr<'a> {
+    use Choice::*;
+    use Decider::*;
+
+    let jump_count = *env.jump_counter;
+
+    match decider {
+        Leaf(Jump(label)) => Expr::Jump(label + jump_count),
+        Leaf(Inline(expr)) => expr,
+        Chain {
+            test_chain,
+            success,
+            failure,
+        } => {
+            // generate a switch based on the test chain
+
+            let mut tests = Vec::with_capacity(test_chain.len());
+
+            for (path, test) in test_chain {
+                match test {
+                    Test::IsCtor {
+                        tag_id,
+                        union,
+                        arguments,
+                        ..
+                    } => {
+                        let lhs = Expr::Int(tag_id as i64);
+
+                        let mut field_layouts =
+                            bumpalo::collections::Vec::with_capacity_in(arguments.len(), env.arena);
+
+                        if union.alternatives.len() > 1 {
+                            // the tag discriminant
+                            field_layouts.push(Layout::Builtin(Builtin::Int64));
+                        }
+
+                        for (_, layout) in arguments {
+                            field_layouts.push(layout);
+                        }
+
+                        let rhs = Expr::AccessAtIndex {
+                            index: 0,
+                            field_layouts: field_layouts.into_bump_slice(),
+                            expr: env.arena.alloc(Expr::Load(cond_symbol)),
+                            is_unwrapped: union.alternatives.len() == 1,
+                        };
+
+                        let cond = env.arena.alloc(Expr::CallByName(
+                            Symbol::INT_EQ_I64,
+                            env.arena.alloc([
+                                (lhs, Layout::Builtin(Builtin::Int64)),
+                                (rhs, Layout::Builtin(Builtin::Int64)),
+                            ]),
+                        ));
+
+                        tests.push(cond);
+                    }
+                    Test::IsInt(test_int) => {
+                        let lhs = Expr::Int(test_int);
+                        let rhs = path_to_expr(
+                            env,
+                            cond_symbol,
+                            &path,
+                            false,
+                            Layout::Builtin(Builtin::Int64),
+                        );
+
+                        let cond = env.arena.alloc(Expr::CallByName(
+                            Symbol::INT_EQ_I64,
+                            env.arena.alloc([
+                                (lhs, Layout::Builtin(Builtin::Int64)),
+                                (rhs, Layout::Builtin(Builtin::Int64)),
+                            ]),
+                        ));
+
+                        tests.push(cond);
+                    }
+
+                    Test::IsFloat(test_int) => {
+                        // TODO maybe we can actually use i64 comparison here?
+                        let test_float = f64::from_bits(test_int as u64);
+                        let lhs = Expr::Float(test_float);
+                        let rhs = path_to_expr(
+                            env,
+                            cond_symbol,
+                            &path,
+                            false,
+                            Layout::Builtin(Builtin::Float64),
+                        );
+
+                        let cond = env.arena.alloc(Expr::CallByName(
+                            Symbol::FLOAT_EQ,
+                            env.arena.alloc([
+                                (lhs, Layout::Builtin(Builtin::Float64)),
+                                (rhs, Layout::Builtin(Builtin::Float64)),
+                            ]),
+                        ));
+
+                        tests.push(cond);
+                    }
+
+                    Test::IsByte {
+                        tag_id: test_byte,
+                        // num_alts: _,
+                        ..
+                    } => {
+                        let lhs = Expr::Byte(test_byte);
+                        let rhs = path_to_expr(
+                            env,
+                            cond_symbol,
+                            &path,
+                            false,
+                            Layout::Builtin(Builtin::Byte),
+                        );
+
+                        let cond = env.arena.alloc(Expr::CallByName(
+                            Symbol::INT_EQ_I8,
+                            env.arena.alloc([
+                                (lhs, Layout::Builtin(Builtin::Byte)),
+                                (rhs, Layout::Builtin(Builtin::Byte)),
+                            ]),
+                        ));
+
+                        tests.push(cond);
+                    }
+                    _ => todo!(),
+                }
+            }
+
+            let cond = tests.remove(0);
+
+            let pass = env.arena.alloc(decide_to_branching(
+                env,
+                cond_symbol,
+                cond_layout.clone(),
+                ret_layout.clone(),
+                *success,
+                jumps,
+            ));
+
+            let fail = env.arena.alloc(decide_to_branching(
+                env,
+                cond_symbol,
+                cond_layout.clone(),
+                ret_layout.clone(),
+                *failure,
+                jumps,
+            ));
+
+            let cond_layout = Layout::Builtin(Builtin::Bool);
+
+            Expr::Cond {
+                cond,
+                cond_layout,
+                pass,
+                fail,
+                ret_layout,
+            }
+        }
+        FanOut {
+            path,
+            tests,
+            fallback,
+        } => {
+            let cond = env.arena.alloc(path_to_expr(
+                env,
+                cond_symbol,
+                &path,
+                false,
+                cond_layout.clone(),
+            ));
+
+            let default_branch = env.arena.alloc(decide_to_branching(
+                env,
+                cond_symbol,
+                cond_layout.clone(),
+                ret_layout.clone(),
+                *fallback,
+                jumps,
+            ));
+
+            let mut branches = bumpalo::collections::Vec::with_capacity_in(tests.len(), env.arena);
+
+            for (test, decider) in tests {
+                let branch = decide_to_branching(
+                    env,
+                    cond_symbol,
+                    cond_layout.clone(),
+                    ret_layout.clone(),
+                    decider,
+                    jumps,
+                );
+
+                let tag = match test {
+                    Test::IsInt(v) => v as u64,
+                    Test::IsFloat(v) => v as u64,
+                    Test::IsBit(v) => v as u64,
+                    Test::IsByte { tag_id, .. } => tag_id as u64,
+                    _ => todo!(),
+                };
+
+                branches.push((tag, branch));
+            }
+
+            // make a jump table based on the tests
+            Expr::Switch {
+                cond,
+                cond_layout,
+                // branches: &'a [(u64, Expr<'a>)],
+                branches: branches.into_bump_slice(),
+                // default_branch: &'a Expr<'a>,
+                default_branch,
+                ret_layout,
+            }
+        }
+    }
+}
+
+/// TREE TO DECIDER
+///
+/// Decision trees may have some redundancies, so we convert them to a Decider
+/// which has special constructs to avoid code duplication when possible.
+
+fn tree_to_decider(tree: DecisionTree) -> Decider<u64> {
+    use Decider::*;
+    use DecisionTree::*;
+
+    match tree {
+        Match(target) => Leaf(target),
+
+        Decision {
+            path,
+            mut edges,
+            default,
+        } => match default {
+            None => match edges.len() {
+                0 => panic!("compiler bug, somehow created an empty decision tree"),
+                1 => {
+                    let (_, sub_tree) = edges.remove(0);
+
+                    tree_to_decider(sub_tree)
+                }
+                2 => {
+                    let (_, failure_tree) = edges.remove(1);
+                    let (test, success_tree) = edges.remove(0);
+
+                    to_chain(path, test, success_tree, failure_tree)
+                }
+
+                _ => {
+                    let fallback = edges.remove(edges.len() - 1).1;
+
+                    let necessary_tests = edges
+                        .into_iter()
+                        .map(|(test, decider)| (test, tree_to_decider(decider)))
+                        .collect();
+
+                    FanOut {
+                        path,
+                        tests: necessary_tests,
+                        fallback: Box::new(tree_to_decider(fallback)),
+                    }
+                }
+            },
+
+            Some(last) => match edges.len() {
+                0 => tree_to_decider(*last),
+                1 => {
+                    let failure_tree = *last;
+                    let (test, success_tree) = edges.remove(0);
+
+                    to_chain(path, test, success_tree, failure_tree)
+                }
+
+                _ => {
+                    let fallback = *last;
+
+                    let necessary_tests = edges
+                        .into_iter()
+                        .map(|(test, decider)| (test, tree_to_decider(decider)))
+                        .collect();
+
+                    FanOut {
+                        path,
+                        tests: necessary_tests,
+                        fallback: Box::new(tree_to_decider(fallback)),
+                    }
+                }
+            },
+        },
+    }
+}
+
+fn to_chain<'a>(
+    path: Path,
+    test: Test<'a>,
+    success_tree: DecisionTree<'a>,
+    failure_tree: DecisionTree<'a>,
+) -> Decider<'a, u64> {
+    use Decider::*;
+
+    let failure = tree_to_decider(failure_tree);
+
+    match tree_to_decider(success_tree) {
+        Chain {
+            mut test_chain,
+            success,
+            failure: sub_failure,
+        } if failure == *sub_failure => {
+            test_chain.push((path, test));
+
+            Chain {
+                test_chain,
+                success,
+                failure: Box::new(failure),
+            }
+        }
+
+        success => Chain {
+            test_chain: vec![(path, test)],
+            success: Box::new(success),
+            failure: Box::new(failure),
+        },
+    }
+}
+
+/// INSERT CHOICES
+///
+/// If a target appears exactly once in a Decider, the corresponding expression
+/// can be inlined. Whether things are inlined or jumps is called a "choice".
+
+fn count_targets(decision_tree: &Decider<u64>) -> MutMap<u64, u64> {
+    let mut result = MutMap::default();
+    count_targets_help(decision_tree, &mut result);
+
+    result
+}
+
+fn count_targets_help(decision_tree: &Decider<u64>, targets: &mut MutMap<u64, u64>) {
+    use Decider::*;
+    match decision_tree {
+        Leaf(target) => match targets.get_mut(target) {
+            None => {
+                targets.insert(*target, 1);
+            }
+            Some(current) => {
+                *current += 1;
+            }
+        },
+
+        Chain {
+            success, failure, ..
+        } => {
+            count_targets_help(success, targets);
+            count_targets_help(failure, targets);
+        }
+
+        FanOut {
+            tests, fallback, ..
+        } => {
+            count_targets_help(fallback, targets);
+
+            for (_, decider) in tests {
+                count_targets_help(decider, targets);
+            }
+        }
+    }
+}
+
+fn create_choices<'a>(
+    target_counts: &MutMap<u64, u64>,
+    target: u64,
+    branch: Expr<'a>,
+) -> ((u64, Choice<'a>), Option<(u64, Expr<'a>)>) {
+    match target_counts.get(&target) {
+        None => unreachable!(
+            "this should never happen: {:?} not in {:?}",
+            target, target_counts
+        ),
+        Some(1) => ((target, Choice::Inline(branch)), None),
+        Some(_) => ((target, Choice::Jump(target)), Some((target, branch))),
+    }
+}
+
+fn insert_choices<'a>(
+    choice_dict: &MutMap<u64, Choice<'a>>,
+    decider: Decider<'a, u64>,
+) -> Decider<'a, Choice<'a>> {
+    use Decider::*;
+    match decider {
+        Leaf(target) => {
+            // TODO remove clone
+            // Only targes that appear once are Inline, so it's safe to remove them from the dict.
+            Leaf(choice_dict[&target].clone())
+        }
+
+        Chain {
+            test_chain,
+            success,
+            failure,
+        } => Chain {
+            test_chain,
+            success: Box::new(insert_choices(choice_dict, *success)),
+            failure: Box::new(insert_choices(choice_dict, *failure)),
+        },
+
+        FanOut {
+            path,
+            tests,
+            fallback,
+        } => FanOut {
+            path,
+            tests: tests
+                .into_iter()
+                .map(|(test, nested)| (test, insert_choices(choice_dict, nested)))
+                .collect(),
+            fallback: Box::new(insert_choices(choice_dict, *fallback)),
+        },
+    }
+}
+
+// Opt.FanOut path (map (second go) tests) (go fallback)
diff --git a/compiler/mono/src/expr.rs b/compiler/mono/src/expr.rs
index 814cb50846..67ec09e70a 100644
--- a/compiler/mono/src/expr.rs
+++ b/compiler/mono/src/expr.rs
@@ -1,4 +1,5 @@
 use crate::layout::{Builtin, Layout};
+use crate::pattern::Ctor;
 use bumpalo::collections::Vec;
 use bumpalo::Bump;
 use roc_can;
@@ -7,6 +8,7 @@ use roc_module::ident::{Ident, Lowercase, TagName};
 use roc_module::symbol::{IdentIds, ModuleId, Symbol};
 use roc_region::all::{Located, Region};
 use roc_types::subs::{Content, ContentHash, FlatType, Subs, Variable};
+use std::hash::Hash;
 
 #[derive(Clone, Debug, PartialEq, Default)]
 pub struct Procs<'a> {
@@ -97,13 +99,14 @@ pub struct Proc<'a> {
     pub ret_layout: Layout<'a>,
 }
 
-struct Env<'a, 'i> {
+pub struct Env<'a, 'i> {
     pub arena: &'a Bump,
     pub subs: &'a mut Subs,
     pub home: ModuleId,
     pub ident_ids: &'i mut IdentIds,
     pub pointer_size: u32,
     symbol_counter: usize,
+    pub jump_counter: &'a mut u64,
 }
 
 impl<'a, 'i> Env<'a, 'i> {
@@ -181,8 +184,10 @@ pub enum Expr<'a> {
     },
     Tag {
         tag_layout: Layout<'a>,
-        name: TagName,
-        arguments: &'a [Expr<'a>],
+        tag_name: TagName,
+        tag_id: u8,
+        union_size: u8,
+        arguments: &'a [(Expr<'a>, Layout<'a>)],
     },
     Struct(&'a [(Expr<'a>, Layout<'a>)]),
     Access {
@@ -191,12 +196,21 @@ pub enum Expr<'a> {
         struct_layout: Layout<'a>,
         record: &'a Expr<'a>,
     },
+    AccessAtIndex {
+        index: u64,
+        field_layouts: &'a [Layout<'a>],
+        expr: &'a Expr<'a>,
+        is_unwrapped: bool,
+    },
 
     Array {
         elem_layout: Layout<'a>,
         elems: &'a [Expr<'a>],
     },
 
+    Label(u64, &'a Expr<'a>),
+    Jump(u64),
+
     RuntimeError(&'a str),
 }
 
@@ -217,6 +231,7 @@ impl<'a> Expr<'a> {
             ident_ids,
             pointer_size,
             symbol_counter: 0,
+            jump_counter: arena.alloc(0),
         };
 
         from_can(&mut env, can_expr, procs, None)
@@ -359,6 +374,7 @@ fn pattern_to_when<'a>(
     }
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn from_can<'a>(
     env: &mut Env<'a, '_>,
     can_expr: roc_can::expr::Expr,
@@ -412,7 +428,7 @@ fn from_can<'a>(
             store_pattern(
                 env,
                 mono_pattern,
-                loc_expr.value,
+                &loc_expr.value,
                 def.expr_var,
                 procs,
                 &mut stored,
@@ -503,8 +519,8 @@ fn from_can<'a>(
                             Ok(Layout::Builtin(builtin)) => match builtin {
                                 Builtin::Int64 => Symbol::INT_EQ_I64,
                                 Builtin::Float64 => Symbol::FLOAT_EQ,
-                                Builtin::Bool(_, _) => Symbol::INT_EQ_I1,
-                                Builtin::Byte(_) => Symbol::INT_EQ_I8,
+                                Builtin::Bool => Symbol::INT_EQ_I1,
+                                Builtin::Byte => Symbol::INT_EQ_I8,
                                 _ => panic!("Equality not implemented for {:?}", builtin),
                             },
                             Ok(complex) => panic!(
@@ -572,6 +588,10 @@ fn from_can<'a>(
                     // It might even be the anonymous result of a conditional:
                     //
                     // ((if x > 0 then \a -> a else \_ -> 0) 5)
+                    //
+                    // It could be named too:
+                    //
+                    // ((if x > 0 then foo else bar) 5)
                     let mut args = Vec::with_capacity_in(loc_args.len(), env.arena);
 
                     for (_, loc_arg) in loc_args {
@@ -654,28 +674,68 @@ fn from_can<'a>(
 
         Tag {
             variant_var,
-            name,
+            name: tag_name,
             arguments: args,
             ..
         } => {
             let arena = env.arena;
 
+            let mut fields = std::vec::Vec::new();
+
+            match roc_types::pretty_print::chase_ext_tag_union(env.subs, variant_var, &mut fields) {
+                Ok(()) | Err((_, Content::FlexVar(_))) => {}
+                Err(content) => panic!("invalid content in ext_var: {:?}", content),
+            }
+
+            fields.sort();
+            let tag_id = fields
+                .iter()
+                .position(|(key, _)| key == &tag_name)
+                .expect("tag must be in its own type");
+
             match Layout::from_var(arena, variant_var, &env.subs, env.pointer_size) {
-                Ok(Layout::Builtin(Builtin::Bool(_smaller, larger))) => Expr::Bool(name == larger),
-                Ok(Layout::Builtin(Builtin::Byte(tags))) => match tags.get(&name) {
-                    Some(v) => Expr::Byte(*v),
-                    None => panic!("Tag name is not part of the type"),
-                },
+                Ok(Layout::Builtin(Builtin::Bool)) => Expr::Bool(tag_id != 0),
+                Ok(Layout::Builtin(Builtin::Byte)) => Expr::Byte(tag_id as u8),
                 Ok(layout) => {
                     let mut arguments = Vec::with_capacity_in(args.len(), arena);
 
-                    for (_, arg) in args {
-                        arguments.push(from_can(env, arg.value, procs, None));
+                    for (arg_var, arg) in args {
+                        let arg_layout =
+                            Layout::from_var(env.arena, arg_var, env.subs, env.pointer_size)
+                                .expect("invalid ret_layout");
+
+                        arguments.push((from_can(env, arg.value, procs, None), arg_layout));
                     }
 
+                    let mut tags = std::vec::Vec::new();
+                    match roc_types::pretty_print::chase_ext_tag_union(
+                        env.subs,
+                        variant_var,
+                        &mut tags,
+                    ) {
+                        Ok(()) => {
+                            tags.sort();
+                        }
+                        other => panic!("invalid value in ext_var {:?}", other),
+                    }
+
+                    let mut opt_tag_id = None;
+                    for (index, (name, _)) in tags.iter().enumerate() {
+                        if name == &tag_name {
+                            opt_tag_id = Some(index as u8);
+                            break;
+                        }
+                    }
+
+                    let union_size = tags.len() as u8;
+
+                    let tag_id = opt_tag_id.expect("Tag must be in its own type");
+
                     Expr::Tag {
                         tag_layout: layout,
-                        name,
+                        tag_name,
+                        tag_id,
+                        union_size,
                         arguments: arguments.into_bump_slice(),
                     }
                 }
@@ -760,7 +820,7 @@ fn from_can<'a>(
 fn store_pattern<'a>(
     env: &mut Env<'a, '_>,
     can_pat: Pattern,
-    can_expr: roc_can::expr::Expr,
+    can_expr: &roc_can::expr::Expr,
     var: Variable,
     procs: &mut Procs<'a>,
     stored: &mut Vec<'a, (Symbol, Layout<'a>, Expr<'a>)>,
@@ -788,13 +848,15 @@ fn store_pattern<'a>(
     //     identity 5
     //
     match can_pat {
-        Identifier(symbol) => stored.push((symbol, layout, from_can(env, can_expr, procs, None))),
+        Identifier(symbol) => {
+            stored.push((symbol, layout, from_can(env, can_expr.clone(), procs, None)))
+        }
         Underscore => {
             // Since _ is never read, it's safe to reassign it.
             stored.push((
                 Symbol::UNDERSCORE,
                 layout,
-                from_can(env, can_expr, procs, None),
+                from_can(env, can_expr.clone(), procs, None),
             ))
         }
         _ => {
@@ -803,6 +865,96 @@ fn store_pattern<'a>(
     }
 }
 
+fn store_pattern2<'a>(
+    env: &mut Env<'a, '_>,
+    can_pat: &Pattern<'a>,
+    outer_symbol: Symbol,
+    _index: usize,
+    layout: Layout<'a>,
+    stored: &mut Vec<'a, (Symbol, Layout<'a>, Expr<'a>)>,
+) -> Result<(), String> {
+    use Pattern::*;
+
+    match can_pat {
+        Identifier(symbol) => {
+            if true {
+                // stored.push((*symbol, layout, Expr::Load(outer_symbol)))
+                //                let load = Expr::AccessAtIndex {
+                //                    index: index as u64,
+                //                    field_layouts: env.arena.alloc([
+                //                        Layout::Builtin(Builtin::Int64),
+                //                        Layout::Builtin(Builtin::Int64),
+                //                    ]),
+                //                    expr: env.arena.alloc(Expr::Load(outer_symbol)),
+                //                };
+
+                let load = Expr::Load(outer_symbol);
+                stored.push((*symbol, layout, load))
+            } else {
+                todo!()
+            }
+        }
+        Underscore => {
+            // Since _ is never read, it's safe to reassign it.
+            stored.push((Symbol::UNDERSCORE, layout, Expr::Load(outer_symbol)))
+        }
+        IntLiteral(_) | FloatLiteral(_) | EnumLiteral { .. } | BitLiteral(_) => {}
+        AppliedTag {
+            union, arguments, ..
+        } => {
+            let is_unwrapped = union.alternatives.len() == 1;
+
+            let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena);
+
+            if !is_unwrapped {
+                // add an element for the tag discriminant
+                arg_layouts.push(Layout::Builtin(Builtin::Int64));
+            }
+
+            for (_, layout) in arguments {
+                arg_layouts.push(layout.clone());
+            }
+
+            for (index, (argument, arg_layout)) in arguments.iter().enumerate() {
+                let load = Expr::AccessAtIndex {
+                    is_unwrapped,
+                    index: (!is_unwrapped as usize + index) as u64,
+                    field_layouts: arg_layouts.clone().into_bump_slice(),
+                    expr: env.arena.alloc(Expr::Load(outer_symbol)),
+                };
+                match argument {
+                    Identifier(symbol) => {
+                        // store immediately in the given symbol
+                        stored.push((*symbol, arg_layout.clone(), load));
+                    }
+                    Underscore => {
+                        // ignore
+                    }
+                    _ => {
+                        // store the field in a symbol, and continue matching on it
+                        let symbol = env.fresh_symbol();
+                        stored.push((symbol, layout.clone(), load));
+
+                        store_pattern2(env, argument, symbol, 0, arg_layout.clone(), stored)?;
+                    }
+                }
+            }
+        }
+
+        Shadowed(region, ident) => {
+            return Err(format!(
+                "The pattern at {:?} shadows variable {:?}",
+                region, ident
+            ));
+        }
+        _ => {
+            panic!("TODO store_pattern for {:?}", can_pat);
+        }
+    }
+
+    Ok(())
+}
+
 fn from_can_when<'a>(
     env: &mut Env<'a, '_>,
     cond_var: Variable,
@@ -814,8 +966,6 @@ fn from_can_when<'a>(
     )>,
     procs: &mut Procs<'a>,
 ) -> Expr<'a> {
-    use Pattern::*;
-
     match branches.len() {
         0 => {
             // A when-expression with no branches is a runtime error.
@@ -830,241 +980,83 @@ fn from_can_when<'a>(
             let (loc_when_pattern, loc_branch) = branches.into_iter().next().unwrap();
 
             let mono_pattern = from_can_pattern(env, &loc_when_pattern.value);
-            store_pattern(
-                env,
-                mono_pattern,
-                loc_cond.value,
-                cond_var,
-                procs,
-                &mut stored,
-            );
 
-            let ret = from_can(env, loc_branch.value, procs, None);
+            let cond_layout = Layout::from_var(env.arena, cond_var, env.subs, env.pointer_size)
+                .unwrap_or_else(|err| panic!("TODO turn this into a RuntimeError {:?}", err));
+            let cond_symbol = env.fresh_symbol();
+            let cond = from_can(env, loc_cond.value, procs, None);
+            stored.push((cond_symbol, cond_layout.clone(), cond));
+
+            // NOTE this will still store shadowed names. I think that is fine because the branch
+            // will throw an error anyway.
+            let ret = match store_pattern2(
+                env,
+                &mono_pattern,
+                cond_symbol,
+                0,
+                cond_layout,
+                &mut stored,
+            ) {
+                Ok(_) => from_can(env, loc_branch.value, procs, None),
+                Err(message) => Expr::RuntimeError(env.arena.alloc(message)),
+            };
 
             Expr::Store(stored.into_bump_slice(), arena.alloc(ret))
         }
-        2 => {
-            let loc_branches: std::vec::Vec<_> = branches
-                .iter()
-                .map(|(loc_branch, _)| {
-                    Located::at(loc_branch.region, from_can_pattern(env, &loc_branch.value))
-                })
-                .collect();
-
-            match crate::pattern::check(Region::zero(), &loc_branches) {
-                Ok(_) => {}
-                Err(errors) => panic!("Errors in patterns: {:?}", errors),
-            }
-
-            // A when-expression with exactly 2 branches compiles to a Cond.
-            let arena = env.arena;
-            let mut iter = branches.into_iter();
-            let (can_loc_when_pat1, loc_then) = iter.next().unwrap();
-            let (can_loc_when_pat2, loc_else) = iter.next().unwrap();
-
-            let when_pat1 = from_can_pattern(env, &can_loc_when_pat1.value);
-            let when_pat2 = from_can_pattern(env, &can_loc_when_pat2.value);
-
-            let cond_layout = Layout::Builtin(Builtin::Bool(
-                TagName::Global("False".into()),
-                TagName::Global("True".into()),
-            ));
-
-            match (&when_pat1, &when_pat2) {
-                (IntLiteral(int), Underscore) => {
-                    let cond_lhs = from_can(env, loc_cond.value, procs, None);
-                    let cond_rhs = Expr::Int(*int);
-
-                    let cond = arena.alloc(Expr::CallByName(
-                        Symbol::INT_EQ_I64,
-                        arena.alloc([
-                            (cond_lhs, Layout::Builtin(Builtin::Int64)),
-                            (cond_rhs, Layout::Builtin(Builtin::Int64)),
-                        ]),
-                    ));
-
-                    let pass = arena.alloc(from_can(env, loc_then.value, procs, None));
-                    let fail = arena.alloc(from_can(env, loc_else.value, procs, None));
-                    let ret_layout = Layout::from_var(arena, expr_var, env.subs, env.pointer_size)
-                        .unwrap_or_else(|err| {
-                            panic!("TODO turn this into a RuntimeError {:?}", err)
-                        });
-
-                    Expr::Cond {
-                        cond_layout,
-                        cond,
-                        pass,
-                        fail,
-                        ret_layout,
-                    }
-                }
-                (FloatLiteral(float), Underscore) => {
-                    let cond_lhs = from_can(env, loc_cond.value, procs, None);
-                    let cond_rhs = Expr::Float(*float);
-
-                    let cond = arena.alloc(Expr::CallByName(
-                        Symbol::FLOAT_EQ,
-                        arena.alloc([
-                            (cond_lhs, Layout::Builtin(Builtin::Float64)),
-                            (cond_rhs, Layout::Builtin(Builtin::Float64)),
-                        ]),
-                    ));
-
-                    let pass = arena.alloc(from_can(env, loc_then.value, procs, None));
-                    let fail = arena.alloc(from_can(env, loc_else.value, procs, None));
-                    let ret_layout = Layout::from_var(arena, expr_var, env.subs, env.pointer_size)
-                        .unwrap_or_else(|err| {
-                            panic!("TODO turn this into a RuntimeError {:?}", err)
-                        });
-
-                    Expr::Cond {
-                        cond_layout,
-                        cond,
-                        pass,
-                        fail,
-                        ret_layout,
-                    }
-                }
-                _ => {
-                    panic!("TODO handle more conds");
-                }
-            }
-        }
         _ => {
-            let loc_branches: std::vec::Vec<_> = branches
-                .iter()
-                .map(|(loc_branch, _)| {
-                    Located::at(loc_branch.region, from_can_pattern(env, &loc_branch.value))
-                })
-                .collect();
+            let cond_layout = Layout::from_var(env.arena, cond_var, env.subs, env.pointer_size)
+                .unwrap_or_else(|err| panic!("TODO turn this into a RuntimeError {:?}", err));
+
+            let cond = from_can(env, loc_cond.value, procs, None);
+            let cond_symbol = env.fresh_symbol();
+
+            let mut loc_branches = std::vec::Vec::new();
+            let mut opt_branches = std::vec::Vec::new();
+
+            for (loc_pattern, loc_expr) in branches {
+                let mono_pattern = from_can_pattern(env, &loc_pattern.value);
+
+                loc_branches.push(Located::at(loc_pattern.region, mono_pattern.clone()));
+
+                let mut stores = Vec::with_capacity_in(1, env.arena);
+
+                let mono_expr = match store_pattern2(
+                    env,
+                    &mono_pattern,
+                    cond_symbol,
+                    0,
+                    cond_layout.clone(),
+                    &mut stores,
+                ) {
+                    Ok(_) => Expr::Store(
+                        stores.into_bump_slice(),
+                        env.arena.alloc(from_can(env, loc_expr.value, procs, None)),
+                    ),
+                    Err(message) => Expr::RuntimeError(env.arena.alloc(message)),
+                };
+
+                opt_branches.push((mono_pattern, mono_expr));
+            }
 
             match crate::pattern::check(Region::zero(), &loc_branches) {
                 Ok(_) => {}
                 Err(errors) => panic!("Errors in patterns: {:?}", errors),
             }
 
-            // This is a when-expression with 3+ branches.
-            let arena = env.arena;
-            let cond = from_can(env, loc_cond.value, procs, None);
-            let subs = &env.subs;
-            let layout = Layout::from_var(arena, cond_var, subs, env.pointer_size)
-                .unwrap_or_else(|_| panic!("TODO generate a runtime error in from_can_when here!"));
+            let ret_layout = Layout::from_var(env.arena, expr_var, env.subs, env.pointer_size)
+                .unwrap_or_else(|err| panic!("TODO turn this into a RuntimeError {:?}", err));
 
-            // We can Switch on integers and tags, because they both have
-            // representations that work as integer values.
-            //
-            // TODO we can also Switch on record fields if we're pattern matching
-            // on a record field that's also Switchable.
-            //
-            // TODO we can also convert floats to integer representations.
-            let is_switchable = match layout {
-                Layout::Builtin(Builtin::Int64) => true,
-                Layout::Builtin(Builtin::Bool(_, _)) => true,
-                Layout::Builtin(Builtin::Byte(_)) => true,
-                _ => false,
-            };
+            let branching = crate::decision_tree::optimize_when(
+                env,
+                cond_symbol,
+                cond_layout.clone(),
+                ret_layout,
+                opt_branches,
+            );
 
-            // If the condition is an Int or Float, we can potentially use
-            // a Switch for more efficiency.
-            if is_switchable {
-                // These are integer literals or underscore patterns,
-                // so they're eligible for user in a jump table.
-                let mut jumpable_branches = Vec::with_capacity_in(branches.len(), arena);
-                let mut opt_default_branch = None;
+            let stores = env.arena.alloc([(cond_symbol, cond_layout, cond)]);
 
-                let mut is_last = true;
-                for (loc_when_pat, loc_expr) in branches.into_iter().rev() {
-                    let mono_expr = from_can(env, loc_expr.value, procs, None);
-                    let when_pat = from_can_pattern(env, &loc_when_pat.value);
-
-                    if is_last {
-                        opt_default_branch = match &when_pat {
-                            Identifier(symbol) => {
-                                // TODO does this evaluate `cond` twice?
-                                Some(arena.alloc(Expr::Store(
-                                    arena.alloc([(*symbol, layout.clone(), cond.clone())]),
-                                    arena.alloc(mono_expr.clone()),
-                                )))
-                            }
-                            Shadowed(_region, _ident) => {
-                                panic!("TODO make runtime exception out of the branch");
-                            }
-                            _ => Some(arena.alloc(mono_expr.clone())),
-                        };
-                        is_last = false;
-                    }
-
-                    match &when_pat {
-                        IntLiteral(int) => {
-                            // Switch only compares the condition to the
-                            // alternatives based on their bit patterns,
-                            // so casting from i64 to u64 makes no difference here.
-                            jumpable_branches.push((*int as u64, mono_expr));
-                        }
-                        BitLiteral(v) => jumpable_branches.push((*v as u64, mono_expr)),
-                        EnumLiteral { tag_id, .. } => {
-                            jumpable_branches.push((*tag_id as u64, mono_expr))
-                        }
-                        Identifier(_) => {
-                            // store is handled above
-                        }
-                        Underscore => {}
-                        Shadowed(_, _) => {
-                            panic!("TODO runtime error for shadowing in a pattern");
-                        }
-                        UnsupportedPattern(_region) => unreachable!("When accepts all patterns"),
-                        AppliedTag { .. }
-                        | StrLiteral(_)
-                        | RecordDestructure(_, _)
-                        | FloatLiteral(_) => {
-                            // The type checker should have converted these mismatches into RuntimeErrors already!
-                            if cfg!(debug_assertions) {
-                                panic!("A type mismatch in a pattern was not converted to a runtime error: {:?}", when_pat);
-                            } else {
-                                unreachable!();
-                            }
-                        }
-                    }
-                }
-
-                // If the default branch was never set, that means
-                // our canonical Expr didn't have one. An earlier
-                // step in the compilation process should have
-                // ruled this out!
-                debug_assert!(opt_default_branch.is_some());
-                let default_branch = opt_default_branch.unwrap();
-
-                let cond_layout = Layout::from_var(arena, cond_var, env.subs, env.pointer_size)
-                    .unwrap_or_else(|err| {
-                        panic!("TODO turn cond_layout into a RuntimeError {:?}", err)
-                    });
-
-                let ret_layout = Layout::from_var(arena, expr_var, env.subs, env.pointer_size)
-                    .unwrap_or_else(|err| {
-                        panic!("TODO turn ret_layout into a RuntimeError {:?}", err)
-                    });
-
-                Expr::Switch {
-                    cond: arena.alloc(cond),
-                    branches: jumpable_branches.into_bump_slice(),
-                    default_branch,
-                    ret_layout,
-                    cond_layout,
-                }
-            } else {
-                // /// More than two conditional branches, e.g. a 3-way when-expression
-                // Expr::Branches {
-                //     /// The left-hand side of the conditional. We compile this to LLVM once,
-                //     /// then reuse it to test against each different compiled cond_rhs value.
-                //     cond_lhs: &'a Expr<'a>,
-                //     /// ( cond_rhs, pass, fail )
-                //     branches: &'a [(Expr<'a>, Expr<'a>, Expr<'a>)],
-                //     ret_var: Variable,
-                // },
-                panic!(
-                    "TODO support when-expressions of 3+ branches whose conditions aren't integers."
-                );
-            }
+            Expr::Store(stores, env.arena.alloc(branching))
         }
     }
 }
@@ -1203,25 +1195,28 @@ fn specialize_proc_body<'a>(
 
 /// A pattern, including possible problems (e.g. shadowing) so that
 /// codegen can generate a runtime error if this pattern is reached.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Pattern<'a> {
     Identifier(Symbol),
-    AppliedTag {
-        tag_name: TagName,
-        arguments: Vec<'a, Pattern<'a>>,
-        layout: Layout<'a>,
-        union: crate::pattern::Union,
-    },
+    Underscore,
+
+    IntLiteral(i64),
+    FloatLiteral(u64),
     BitLiteral(bool),
     EnumLiteral {
         tag_id: u8,
         enum_size: u8,
     },
-    IntLiteral(i64),
-    FloatLiteral(f64),
     StrLiteral(Box<str>),
+
     RecordDestructure(Vec<'a, RecordDestruct<'a>>, Layout<'a>),
-    Underscore,
+    AppliedTag {
+        tag_name: TagName,
+        tag_id: u8,
+        arguments: Vec<'a, (Pattern<'a>, Layout<'a>)>,
+        layout: Layout<'a>,
+        union: crate::pattern::Union,
+    },
 
     // Runtime Exceptions
     Shadowed(Region, Located<Ident>),
@@ -1229,7 +1224,7 @@ pub enum Pattern<'a> {
     UnsupportedPattern(Region),
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct RecordDestruct<'a> {
     pub label: Lowercase,
     pub symbol: Symbol,
@@ -1245,14 +1240,14 @@ fn from_can_pattern<'a>(
         Underscore => Pattern::Underscore,
         Identifier(symbol) => Pattern::Identifier(*symbol),
         IntLiteral(v) => Pattern::IntLiteral(*v),
-        FloatLiteral(v) => Pattern::FloatLiteral(*v),
+        FloatLiteral(v) => Pattern::FloatLiteral(f64::to_bits(*v)),
         StrLiteral(v) => Pattern::StrLiteral(v.clone()),
         Shadowed(region, ident) => Pattern::Shadowed(*region, ident.clone()),
         UnsupportedPattern(region) => Pattern::UnsupportedPattern(*region),
 
         NumLiteral(var, num) => match to_int_or_float(env.subs, *var) {
             IntOrFloat::IntType => Pattern::IntLiteral(*num),
-            IntOrFloat::FloatType => Pattern::FloatLiteral(*num as f64),
+            IntOrFloat::FloatType => Pattern::FloatLiteral(*num as u64),
         },
 
         AppliedTag {
@@ -1260,54 +1255,70 @@ fn from_can_pattern<'a>(
             tag_name,
             arguments,
             ..
-        } => match Layout::from_var(env.arena, *whole_var, env.subs, env.pointer_size) {
-            Ok(Layout::Builtin(Builtin::Bool(_bottom, top))) => {
-                Pattern::BitLiteral(tag_name == &top)
+        } => {
+            let mut fields = std::vec::Vec::new();
+
+            match roc_types::pretty_print::chase_ext_tag_union(env.subs, *whole_var, &mut fields) {
+                Ok(()) | Err((_, Content::FlexVar(_))) => {}
+                Err(content) => panic!("invalid content in ext_var: {:?}", content),
             }
-            Ok(Layout::Builtin(Builtin::Byte(conversion))) => match conversion.get(&tag_name) {
-                Some(index) => Pattern::EnumLiteral {
-                    tag_id: *index,
-                    enum_size: conversion.len() as u8,
+
+            fields.sort();
+            let tag_id = fields
+                .iter()
+                .position(|(key, _)| key == tag_name)
+                .expect("tag must be in its own type");
+
+            let enum_size = fields.len();
+
+            let mut ctors = std::vec::Vec::with_capacity(fields.len());
+            for (tag_name, args) in &fields {
+                ctors.push(Ctor {
+                    name: tag_name.clone(),
+                    arity: args.len(),
+                })
+            }
+
+            let union = crate::pattern::Union {
+                alternatives: ctors,
+            };
+
+            let fields_map: MutMap<_, _> = fields.into_iter().collect();
+
+            match crate::layout::layout_from_tag_union(
+                env.arena,
+                &fields_map,
+                env.subs,
+                env.pointer_size,
+            ) {
+                Ok(Layout::Builtin(Builtin::Bool)) => Pattern::BitLiteral(tag_id != 0),
+                Ok(Layout::Builtin(Builtin::Byte)) => Pattern::EnumLiteral {
+                    tag_id: tag_id as u8,
+                    enum_size: enum_size as u8,
                 },
-                None => unreachable!("Tag must be in its own type"),
-            },
-            Ok(layout) => {
-                let mut mono_args = Vec::with_capacity_in(arguments.len(), env.arena);
-                for (_, loc_pat) in arguments {
-                    mono_args.push(from_can_pattern(env, &loc_pat.value));
-                }
+                Ok(layout) => {
+                    let mut mono_args = Vec::with_capacity_in(arguments.len(), env.arena);
+                    for (pat_var, loc_pat) in arguments {
+                        let layout =
+                            Layout::from_var(env.arena, *pat_var, env.subs, env.pointer_size)
+                                .unwrap_or_else(|err| {
+                                    panic!("TODO turn pat_var into a RuntimeError {:?}", err)
+                                });
 
-                let mut fields = std::vec::Vec::new();
-                let union = match roc_types::pretty_print::chase_ext_tag_union(
-                    env.subs,
-                    *whole_var,
-                    &mut fields,
-                ) {
-                    Ok(()) | Err((_, Content::FlexVar(_))) => {
-                        let mut ctors = std::vec::Vec::with_capacity(fields.len());
-                        for (tag_name, args) in fields {
-                            ctors.push(crate::pattern::Ctor {
-                                name: tag_name.clone(),
-                                arity: args.len(),
-                            })
-                        }
-
-                        crate::pattern::Union {
-                            alternatives: ctors,
-                        }
+                        mono_args.push((from_can_pattern(env, &loc_pat.value), layout));
                     }
-                    Err(content) => panic!("invalid content in ext_var: {:?}", content),
-                };
 
-                Pattern::AppliedTag {
-                    tag_name: tag_name.clone(),
-                    arguments: mono_args,
-                    union,
-                    layout,
+                    Pattern::AppliedTag {
+                        tag_name: tag_name.clone(),
+                        tag_id: tag_id as u8,
+                        arguments: mono_args,
+                        union,
+                        layout,
+                    }
                 }
+                Err(()) => panic!("Invalid layout"),
             }
-            Err(()) => panic!("Invalid layout"),
-        },
+        }
 
         RecordDestructure {
             whole_var,
diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs
index 2a7c716e32..57f9df9114 100644
--- a/compiler/mono/src/layout.rs
+++ b/compiler/mono/src/layout.rs
@@ -6,22 +6,21 @@ use roc_module::symbol::Symbol;
 use roc_types::subs::{Content, FlatType, Subs, Variable};
 
 /// Types for code gen must be monomorphic. No type variables allowed!
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Layout<'a> {
     Builtin(Builtin<'a>),
     Struct(&'a [(Lowercase, Layout<'a>)]),
-    Tag(&'a [Layout<'a>]),
-    Pointer(&'a Layout<'a>),
+    Union(&'a [&'a [Layout<'a>]]),
     /// A function. The types of its arguments, then the type of its return value.
     FunctionPointer(&'a [Layout<'a>], &'a Layout<'a>),
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Builtin<'a> {
     Int64,
     Float64,
-    Bool(TagName, TagName),
-    Byte(MutMap<TagName, u8>),
+    Bool,
+    Byte,
     Str,
     Map(&'a Layout<'a>, &'a Layout<'a>),
     Set(&'a Layout<'a>),
@@ -79,6 +78,24 @@ impl<'a> Layout<'a> {
         }
     }
 
+    pub fn safe_to_memcpy(&self) -> bool {
+        use Layout::*;
+
+        match self {
+            Builtin(builtin) => builtin.safe_to_memcpy(),
+            Struct(fields) => fields
+                .iter()
+                .all(|(_, field_layout)| field_layout.safe_to_memcpy()),
+            Union(tags) => tags
+                .iter()
+                .all(|tag_layout| tag_layout.iter().all(|field| field.safe_to_memcpy())),
+            FunctionPointer(_, _) => {
+                // Function pointers are immutable and can always be safely copied
+                true
+            }
+        }
+    }
+
     pub fn stack_size(&self, pointer_size: u32) -> u32 {
         use Layout::*;
 
@@ -93,17 +110,17 @@ impl<'a> Layout<'a> {
 
                 sum
             }
-            Tag(fields) => {
-                // the symbol is a 64-bit value, so 8 bytes
-                let mut sum = 8;
-
-                for field_layout in *fields {
-                    sum += field_layout.stack_size(pointer_size);
-                }
-
-                sum
-            }
-            Pointer(_) | FunctionPointer(_, _) => pointer_size,
+            Union(fields) => fields
+                .iter()
+                .map(|tag_layout| {
+                    tag_layout
+                        .iter()
+                        .map(|field| field.stack_size(pointer_size))
+                        .sum()
+                })
+                .max()
+                .unwrap_or_default(),
+            FunctionPointer(_, _) => pointer_size,
         }
     }
 }
@@ -131,17 +148,25 @@ impl<'a> Builtin<'a> {
         match self {
             Int64 => Builtin::I64_SIZE,
             Float64 => Builtin::F64_SIZE,
-            Bool(_, _) => Builtin::BOOL_SIZE,
-            Byte(_) => Builtin::BYTE_SIZE,
+            Bool => Builtin::BOOL_SIZE,
+            Byte => Builtin::BYTE_SIZE,
             Str | EmptyStr => Builtin::STR_WORDS * pointer_size,
             Map(_, _) | EmptyMap => Builtin::MAP_WORDS * pointer_size,
             Set(_) | EmptySet => Builtin::SET_WORDS * pointer_size,
             List(_) | EmptyList => Builtin::LIST_WORDS * pointer_size,
         }
     }
+
+    pub fn safe_to_memcpy(&self) -> bool {
+        use Builtin::*;
+
+        match self {
+            Int64 | Float64 | Bool | Byte | EmptyStr | EmptyMap | EmptyList | EmptySet => true,
+            Str | Map(_, _) | Set(_) | List(_) => false,
+        }
+    }
 }
 
-#[allow(clippy::cognitive_complexity)]
 fn layout_from_flat_type<'a>(
     arena: &'a Bump,
     flat_type: FlatType,
@@ -274,81 +299,7 @@ fn layout_from_flat_type<'a>(
         TagUnion(tags, ext_var) => {
             debug_assert!(ext_var_is_empty_tag_union(subs, ext_var));
 
-            match tags.len() {
-                0 => {
-                    panic!("TODO gracefully handle trying to instantiate Never");
-                }
-                // We can only unwrap a wrapper if it never becomes part of a bigger union
-                // therefore, the ext_var must be the literal empty tag union
-                1 => {
-                    // This is a wrapper. Unwrap it!
-                    let (tag, args) = tags.into_iter().next().unwrap();
-
-                    match tag {
-                        TagName::Private(Symbol::NUM_AT_NUM) => {
-                            debug_assert!(args.len() == 1);
-
-                            let var = args.into_iter().next().unwrap();
-
-                            unwrap_num_tag(subs, var)
-                        }
-                        TagName::Private(symbol) => {
-                            panic!("TODO emit wrapped private tag for {:?} {:?}", symbol, args);
-                        }
-                        TagName::Global(ident) => {
-                            panic!("TODO emit wrapped global tag for {:?} {:?}", ident, args);
-                        }
-                    }
-                }
-                _ => {
-                    // Check if we can turn this tag union into an enum
-                    // The arguments of all tags must have size 0.
-                    // That is trivially the case when there are no arguments
-                    //
-                    //  [ Orange, Apple, Banana ]
-                    //
-                    //  But when one-tag tag unions are optimized away, we can also use an enum for
-                    //
-                    //  [ Foo [ Unit ], Bar [ Unit ] ]
-
-                    let arguments_have_size_0 = || {
-                        tags.iter().all(|(_, args)| {
-                            args.iter().all(|var| {
-                                Layout::from_var(arena, *var, subs, pointer_size)
-                                    .map(|v| v.stack_size(pointer_size))
-                                    == Ok(0)
-                            })
-                        })
-                    };
-
-                    // up to 256 enum keys can be stored in a byte
-                    if tags.len() <= std::u8::MAX as usize + 1 && arguments_have_size_0() {
-                        if tags.len() <= 2 {
-                            // Up to 2 enum tags can be stored (in theory) in one bit
-                            let mut it = tags.keys();
-                            let a: TagName = it.next().unwrap().clone();
-                            let b: TagName = it.next().unwrap().clone();
-
-                            if a < b {
-                                Ok(Layout::Builtin(Builtin::Bool(a, b)))
-                            } else {
-                                Ok(Layout::Builtin(Builtin::Bool(b, a)))
-                            }
-                        } else {
-                            // up to 256 enum tags can be stored in a byte
-                            let mut tag_to_u8 = MutMap::default();
-
-                            for (counter, (name, _)) in tags.into_iter().enumerate() {
-                                tag_to_u8.insert(name, counter as u8);
-                            }
-                            Ok(Layout::Builtin(Builtin::Byte(tag_to_u8)))
-                        }
-                    } else {
-                        // panic!("TODO handle a tag union with mutliple tags: {:?}", tags);
-                        Ok(Layout::Tag(&[]))
-                    }
-                }
-            }
+            layout_from_tag_union(arena, &tags, subs, pointer_size)
         }
         RecursiveTagUnion(_, _, _) => {
             panic!("TODO make Layout for non-empty Tag Union");
@@ -364,6 +315,100 @@ fn layout_from_flat_type<'a>(
     }
 }
 
+pub fn layout_from_tag_union<'a>(
+    arena: &'a Bump,
+    tags: &MutMap<TagName, std::vec::Vec<Variable>>,
+    subs: &Subs,
+    pointer_size: u32,
+) -> Result<Layout<'a>, ()> {
+    match tags.len() {
+        0 => {
+            panic!("TODO gracefully handle trying to instantiate Never");
+        }
+        // We can only unwrap a wrapper if it never becomes part of a bigger union
+        // therefore, the ext_var must be the literal empty tag union
+        1 => {
+            // This is a wrapper. Unwrap it!
+            let (tag_name, arguments) = tags.iter().next().unwrap();
+
+            match &tag_name {
+                TagName::Private(Symbol::NUM_AT_NUM) => {
+                    debug_assert!(arguments.len() == 1);
+
+                    let var = arguments.iter().next().unwrap();
+
+                    unwrap_num_tag(subs, *var)
+                }
+                TagName::Private(_) | TagName::Global(_) => {
+                    let mut arg_layouts = Vec::with_capacity_in(arguments.len(), arena);
+
+                    for arg in arguments {
+                        arg_layouts.push(Layout::from_var(arena, *arg, subs, pointer_size)?);
+                    }
+
+                    let layouts = [arg_layouts.into_bump_slice()];
+
+                    Ok(Layout::Union(arena.alloc(layouts)))
+                }
+            }
+        }
+        _ => {
+            // Check if we can turn this tag union into an enum
+            // The arguments of all tags must have size 0.
+            // That is trivially the case when there are no arguments
+            //
+            //  [ Orange, Apple, Banana ]
+            //
+            //  But when one-tag tag unions are optimized away, we can also use an enum for
+            //
+            //  [ Foo [ Unit ], Bar [ Unit ] ]
+
+            let arguments_have_size_0 = || {
+                tags.iter().all(|(_, args)| {
+                    args.iter().all(|var| {
+                        Layout::from_var(arena, *var, subs, pointer_size)
+                            .map(|v| v.stack_size(pointer_size))
+                            == Ok(0)
+                    })
+                })
+            };
+
+            // up to 256 enum keys can be stored in a byte
+            if tags.len() <= std::u8::MAX as usize + 1 && arguments_have_size_0() {
+                if tags.len() <= 2 {
+                    Ok(Layout::Builtin(Builtin::Bool))
+                } else {
+                    // up to 256 enum tags can be stored in a byte
+                    Ok(Layout::Builtin(Builtin::Byte))
+                }
+            } else {
+                let add_discriminant = tags.len() != 1;
+                let mut layouts = Vec::with_capacity_in(tags.len(), arena);
+
+                for arguments in tags.values() {
+                    // add a field for the discriminant if there is more than one tag in the union
+                    let mut arg_layouts = if add_discriminant {
+                        let discriminant = Layout::Builtin(Builtin::Int64);
+                        let mut result = Vec::with_capacity_in(arguments.len() + 1, arena);
+                        result.push(discriminant);
+                        result
+                    } else {
+                        Vec::with_capacity_in(arguments.len(), arena)
+                    };
+
+                    for arg in arguments {
+                        arg_layouts.push(Layout::from_var(arena, *arg, subs, pointer_size)?);
+                    }
+
+                    layouts.push(arg_layouts.into_bump_slice());
+                }
+
+                Ok(Layout::Union(arena.alloc(layouts)))
+            }
+        }
+    }
+}
+
 fn ext_var_is_empty_tag_union(subs: &Subs, ext_var: Variable) -> bool {
     // the ext_var is empty
     let mut ext_fields = std::vec::Vec::new();
diff --git a/compiler/mono/src/lib.rs b/compiler/mono/src/lib.rs
index 37bd3c4957..5743c9c50f 100644
--- a/compiler/mono/src/lib.rs
+++ b/compiler/mono/src/lib.rs
@@ -16,4 +16,6 @@ pub mod layout;
 // Temporary, while we can build up test cases and optimize the exhaustiveness checking.
 // For now, following this warning's advice will lead to nasty type inference errors.
 #[allow(clippy::ptr_arg)]
+pub mod decision_tree;
+#[allow(clippy::ptr_arg)]
 pub mod pattern;
diff --git a/compiler/mono/src/pattern.rs b/compiler/mono/src/pattern.rs
index f8f4183fa2..cdcb4175d2 100644
--- a/compiler/mono/src/pattern.rs
+++ b/compiler/mono/src/pattern.rs
@@ -4,14 +4,15 @@ use roc_region::all::{Located, Region};
 
 use self::Pattern::*;
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Union {
     pub alternatives: Vec<Ctor>,
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Ctor {
     pub name: TagName,
+    // pub tag_id: u8,
     pub arity: usize,
 }
 
@@ -27,7 +28,7 @@ pub enum Literal {
     Int(i64),
     Bit(bool),
     Byte(u8),
-    Float(f64),
+    Float(u64),
     Str(Box<str>),
 }
 
@@ -94,7 +95,7 @@ fn simplify<'a>(pattern: &crate::expr::Pattern<'a>) -> Pattern {
             ..
         } => {
             let simplified_args: std::vec::Vec<_> =
-                arguments.iter().map(|v| simplify(&v)).collect();
+                arguments.iter().map(|v| simplify(&v.0)).collect();
             Ctor(union.clone(), tag_name.clone(), simplified_args)
         }
     }
@@ -254,7 +255,6 @@ fn recover_ctor(
     arity: usize,
     mut patterns: Vec<Pattern>,
 ) -> Vec<Pattern> {
-    // TODO ensure that this behaves the same as haskell's splitAt
     let mut rest = patterns.split_off(arity);
     let args = patterns;
 
diff --git a/compiler/mono/tests/test_mono.rs b/compiler/mono/tests/test_mono.rs
index 179cec98fc..125f5d7a44 100644
--- a/compiler/mono/tests/test_mono.rs
+++ b/compiler/mono/tests/test_mono.rs
@@ -13,8 +13,6 @@ mod helpers;
 mod test_mono {
     use crate::helpers::{can_expr, infer_expr, test_home, CanExprOut};
     use bumpalo::Bump;
-    use roc_collections::all::MutMap;
-    use roc_module::ident::TagName::*;
     use roc_module::symbol::{Interns, Symbol};
     use roc_mono::expr::Expr::{self, *};
     use roc_mono::expr::Procs;
@@ -164,7 +162,7 @@ mod test_mono {
 
                 Cond {
                     cond: &Expr::Bool(true),
-                    cond_layout: Builtin(Bool(Global("False".into()), Global("True".into()))),
+                    cond_layout: Builtin(Bool),
                     pass: &Expr::Str("bar"),
                     fail: &Expr::Str("foo"),
                     ret_layout: Builtin(Str),
@@ -190,11 +188,11 @@ mod test_mono {
 
                 Cond {
                     cond: &Expr::Bool(true),
-                    cond_layout: Builtin(Bool(Global("False".into()), Global("True".into()))),
+                    cond_layout: Builtin(Bool),
                     pass: &Expr::Str("bar"),
                     fail: &Cond {
                         cond: &Expr::Bool(false),
-                        cond_layout: Builtin(Bool(Global("False".into()), Global("True".into()))),
+                        cond_layout: Builtin(Bool),
                         pass: &Expr::Str("foo"),
                         fail: &Expr::Str("baz"),
                         ret_layout: Builtin(Str),
@@ -228,10 +226,7 @@ mod test_mono {
                         Builtin(Str),
                         Cond {
                             cond: &Expr::Bool(true),
-                            cond_layout: Builtin(Bool(
-                                Global("False".into()),
-                                Global("True".into()),
-                            )),
+                            cond_layout: Builtin(Bool),
                             pass: &Expr::Str("bar"),
                             fail: &Expr::Str("foo"),
                             ret_layout: Builtin(Str),
@@ -361,11 +356,7 @@ mod test_mono {
                 let home = test_home();
                 let var_x = interns.symbol(home, "x".into());
 
-                let stores = [(
-                    var_x,
-                    Layout::Builtin(Builtin::Bool(Global("False".into()), Global("True".into()))),
-                    Bool(true),
-                )];
+                let stores = [(var_x, Layout::Builtin(Builtin::Bool), Bool(true))];
 
                 let load = Load(var_x);
 
@@ -389,11 +380,7 @@ mod test_mono {
                 let home = test_home();
                 let var_x = interns.symbol(home, "x".into());
 
-                let stores = [(
-                    var_x,
-                    Layout::Builtin(Builtin::Bool(Global("No".into()), Global("Yes".into()))),
-                    Bool(false),
-                )];
+                let stores = [(var_x, Layout::Builtin(Builtin::Bool), Bool(false))];
 
                 let load = Load(var_x);
 
@@ -418,13 +405,8 @@ mod test_mono {
                 let home = test_home();
                 let var_x = interns.symbol(home, "x".into());
 
-                let mut fruits = MutMap::default();
-
-                fruits.insert(Global("Banana".into()), 0);
-                fruits.insert(Global("Orange".into()), 1);
-                fruits.insert(Global("Apple".into()), 2);
-
-                let stores = [(var_x, Layout::Builtin(Builtin::Byte(fruits)), Byte(1))];
+                // orange gets index (and therefore tag_id) 1
+                let stores = [(var_x, Layout::Builtin(Builtin::Byte), Byte(2))];
 
                 let load = Load(var_x);
 
@@ -466,32 +448,31 @@ mod test_mono {
 
     //    #[test]
     //    fn when_on_result() {
-    //        let arena = Bump::new();
-    //
-    //        compiles_to_with_interns(
+    //        compiles_to(
     //            r#"
-    //            x = Ok 0x3
-    //
-    //            when x is
-    //                Err _ -> 0
-    //                Ok n -> n + 1
+    //            when 1 is
+    //                1 -> 12
+    //                _ -> 34
     //            "#,
-    //            |interns| {
+    //            {
+    //                use self::Builtin::*;
+    //                use Layout::Builtin;
     //                let home = test_home();
-    //                let var_x = interns.symbol(home, "x".into());
     //
-    //                let mut fruits = MutMap::default();
+    //                let gen_symbol_3 = Interns::from_index(home, 3);
+    //                let gen_symbol_4 = Interns::from_index(home, 4);
     //
-    //                fruits.insert(Global("Banana".into()), 0);
-    //                fruits.insert(Global("Orange".into()), 1);
-    //                fruits.insert(Global("Apple".into()), 2);
-    //
-    //                let stores = [(var_x, Layout::Builtin(Builtin::Byte(fruits)), Byte(1))];
-    //
-    //                let load = Load(var_x);
-    //
-    //                Store(arena.alloc(stores), arena.alloc(load))
+    //                CallByName(
+    //                    gen_symbol_3,
+    //                    &[(
+    //                        Struct(&[(
+    //                            CallByName(gen_symbol_4, &[(Int(4), Builtin(Int64))]),
+    //                            Builtin(Int64),
+    //                        )]),
+    //                        Layout::Struct(&[("x".into(), Builtin(Int64))]),
+    //                    )],
+    //                )
     //            },
-    //        );
+    //        )
     //    }
 }
diff --git a/compiler/types/src/pretty_print.rs b/compiler/types/src/pretty_print.rs
index 2fa473ed08..7eb0e4b5f9 100644
--- a/compiler/types/src/pretty_print.rs
+++ b/compiler/types/src/pretty_print.rs
@@ -520,6 +520,11 @@ pub fn chase_ext_tag_union(
 
             chase_ext_tag_union(subs, ext_var, fields)
         }
+        Content::Structure(Apply(Symbol::ATTR_ATTR, arguments)) => {
+            debug_assert!(arguments.len() == 2);
+            chase_ext_tag_union(subs, arguments[1], fields)
+        }
+        Content::Alias(_, _, var) => chase_ext_tag_union(subs, var, fields),
 
         content => Err((var, content)),
     }