diff --git a/build.rs b/build.rs
index 7160086..502c779 100644
--- a/build.rs
+++ b/build.rs
@@ -9,12 +9,13 @@
 fn main() {
     static ENV_VAR: &str = "PLATFORM";
     static FILE_NAME: &str = "platform";
+    static APP_HEAP_SIZE: &str = "APP_HEAP_SIZE";
 
     println!("cargo:rerun-if-env-changed={}", ENV_VAR);
+    println!("cargo:rerun-if-env-changed={}", APP_HEAP_SIZE);
     println!("cargo:rerun-if-changed={}", FILE_NAME);
 
-    let platform_name =
-        read_board_name_from_env_var(ENV_VAR).or_else(|| read_board_name_from_file(FILE_NAME));
+    let platform_name = read_env_var(ENV_VAR).or_else(|| read_board_name_from_file(FILE_NAME));
     if let Some(platform_name) = platform_name {
         println!("cargo:rustc-env={}={}", ENV_VAR, platform_name);
         copy_linker_file(&platform_name.trim());
@@ -24,9 +25,16 @@
              Remember to manually specify a linker file.",
         );
     }
+
+    if let Some(s) = read_env_var(APP_HEAP_SIZE) {
+        println!("cargo:rustc-env=APP_HEAP_SIZE={}", s);
+    } else {
+        // Just use a default of 1024 if nothing is passed in
+        println!("cargo:rustc-env=APP_HEAP_SIZE=1024");
+    }
 }
 
-fn read_board_name_from_env_var(env_var: &str) -> Option<String> {
+fn read_env_var(env_var: &str) -> Option<String> {
     env::var_os(env_var).map(|os_string| os_string.into_string().unwrap())
 }
 
diff --git a/codegen/src/lib.rs b/codegen/src/lib.rs
index 9804e29..ccb0bfb 100644
--- a/codegen/src/lib.rs
+++ b/codegen/src/lib.rs
@@ -9,6 +9,55 @@
 use syn::ItemFn;
 
 #[allow(clippy::needless_doctest_main)]
+/// Procedural macro. This generates a function to read and parse
+/// an environment variable to a usize at compile time. We have to use a
+/// function since procedural macros can't generate expressions at the moment.
+/// Example:
+///
+///
+/// ```ignore
+/// make_read_env_var!("MAX_COUNT")
+///
+/// fn do_it() {
+///     let max = read_MAX_COUNT();
+/// }
+/// ```
+#[proc_macro]
+pub fn make_read_env_var(input: TokenStream) -> TokenStream {
+    let env_arg = syn::parse_macro_input!(input as syn::LitStr);
+    let env_var_name = env_arg.value();
+    let app_size = match std::env::var(&env_var_name) {
+        Ok(r) => r,
+        Err(_r) => {
+            return syn::Error::new(
+                env_arg.span(),
+                format!("Failed to find {} in environment, is it set?", env_var_name),
+            )
+            .to_compile_error()
+            .into()
+        }
+    };
+    let size = match app_size.parse::<usize>() {
+        Ok(r) => r,
+        Err(_r) => {
+            return syn::Error::new(
+                env_arg.span(),
+                format!("Environment var {} can't be parsed to usize", env_var_name),
+            )
+            .to_compile_error()
+            .into()
+        }
+    };
+
+    let concat = format!("read_{}", env_var_name);
+    let i = syn::Ident::new(&concat, proc_macro2::Span::call_site());
+    let result = quote! {
+        fn #i() -> usize { #size }
+    };
+    result.into()
+}
+
+#[allow(clippy::needless_doctest_main)]
 /// Procedural attribute macro. This is meant to be applied to a binary's async
 /// `main()`, transforming into a function that returns a type acceptable for
 /// `main()`. In other words, this will not compile with libtock-rs:
diff --git a/core/Cargo.toml b/core/Cargo.toml
index 64fa96e..3110346 100644
--- a/core/Cargo.toml
+++ b/core/Cargo.toml
@@ -11,3 +11,4 @@
 
 [dependencies]
 linked_list_allocator = { optional = true, version = "=0.6.5", default-features = false }
+libtock_codegen = { path = "../codegen" }
diff --git a/core/build.rs b/core/build.rs
new file mode 100644
index 0000000..e91df46
--- /dev/null
+++ b/core/build.rs
@@ -0,0 +1,22 @@
+use std::env;
+
+fn main() {
+    static APP_HEAP_SIZE: &str = "APP_HEAP_SIZE";
+
+    println!("cargo:rerun-if-env-changed={}", APP_HEAP_SIZE);
+
+    set_default_env(APP_HEAP_SIZE, "1024");
+}
+
+fn set_default_env(env_var: &str, default: &str) {
+    if let Some(s) = read_env_var(env_var) {
+        println!("cargo:rustc-env={}={}", env_var, s);
+    } else {
+        // Just use a default of 1024 if nothing is passed in
+        println!("cargo:rustc-env={}={}", env_var, default);
+    }
+}
+
+fn read_env_var(env_var: &str) -> Option<String> {
+    env::var_os(env_var).map(|os_string| os_string.into_string().unwrap())
+}
diff --git a/core/src/entry_point/mod.rs b/core/src/entry_point/mod.rs
index d63b174..c2628e1 100644
--- a/core/src/entry_point/mod.rs
+++ b/core/src/entry_point/mod.rs
@@ -75,6 +75,9 @@
     stack_size: usize,
 }
 
+//Procedural macro to generate a function to read APP_HEAP_SIZE
+libtock_codegen::make_read_env_var!("APP_HEAP_SIZE");
+
 /// Rust setup, called by _start. Uses the extern "C" calling convention so that
 /// the assembly in _start knows how to call it (the Rust ABI is not defined).
 /// Sets up the data segment (including relocations) and the heap, then calls
@@ -116,21 +119,19 @@
     // `sbrk` system call to dynamically request heap memory from the kernel, we
     // need to tell `linked_list_allocator` where the heap starts and ends.
     //
-    // Heap size is set using `elf2tab` with `--app-heap` option, which is
-    // currently at 1024. If you change the `elf2tab` heap size, make sure to
-    // make the corresponding change here.
-    const HEAP_SIZE: usize = 1024;
+    // We get this from the environment to make it easy to set per compile.
+    let app_heap_size: usize = read_APP_HEAP_SIZE();
 
     // Make the heap start exactly at bss_end. The suggested _app_heap_break
     // is almost always going to be too big and leads to us wasting memory.
     let app_heap_start = bss_end;
-    let app_heap_end = app_heap_start + HEAP_SIZE;
+    let app_heap_end = app_heap_start + app_heap_size;
 
     // Tell the kernel the new app heap break.
     memop::set_brk(app_heap_end as *const u8);
 
     #[cfg(feature = "alloc")]
-    crate::alloc::HEAP.init(app_heap_start, HEAP_SIZE);
+    crate::alloc::HEAP.init(app_heap_start, app_heap_size);
 
     main(0, ptr::null());
 
diff --git a/tools/flash.sh b/tools/flash.sh
index 7d20190..7d5dbbc 100755
--- a/tools/flash.sh
+++ b/tools/flash.sh
@@ -4,6 +4,10 @@
 
 artifact="$(basename $1)"
 rust_target_folder="$(readlink -f $(dirname $1)/../..)"
+if [ -z $APP_HEAP_SIZE ]; then
+	echo "Set APP_HEAP_SIZE to a value"
+	exit 1
+fi
 
 case "${PLATFORM}" in
     "nrf52"|"nrf52840")
@@ -39,7 +43,7 @@
 mkdir -p "${libtock_target_path}"
 cp "$1" "${elf_file_name}"
 
-elf2tab -n "${artifact}" -o "${tab_file_name}" "${elf_file_name}" --stack 2048 --app-heap 1024 --kernel-heap 1024 --protected-region-size=64
+elf2tab -n "${artifact}" -o "${tab_file_name}" "${elf_file_name}" --stack 2048 --app-heap $APP_HEAP_SIZE --kernel-heap 1024 --protected-region-size=64
 
 if [ $tockload == "n" ]; then
 	echo "Skipping flashing for platform \"${PLATFORM}\""