core/ndstrides: implement len(ndarray) & refactor len()

core/ndstrides: implement np_{zeros,ones,full,empty}
core/model: add util::gen_for_model
2024-10-04 15:47:55 +08:00 · 2024-10-04 15:46:56 +08:00 · 2024-10-04 15:45:47 +08:00 · 2024-10-04 15:44:42 +08:00 · 2024-10-04 15:42:52 +08:00 · 2024-10-04 15:39:17 +08:00
82 changed files with 4763 additions and 864 deletions
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -8,17 +8,17 @@ repos:
    hooks:
      - id: nac3-cargo-fmt
        name: nac3 cargo format
-        entry: cargo
+        entry: nix
        language: system
        types: [file, rust]
        pass_filenames: false
        description: Runs cargo fmt on the codebase.
-        args: [fmt]
+        args: [develop, -c, cargo, fmt, --all]
      - id: nac3-cargo-clippy
        name: nac3 cargo clippy
-        entry: cargo
+        entry: nix
        language: system
        types: [file, rust]
        pass_filenames: false
        description: Runs cargo clippy on the codebase.
-        args: [clippy, --tests]
+        args: [develop, -c, cargo, clippy, --tests]
--- a/Cargo.lock
+++ b/Cargo.lock
@ -75,33 +75,33 @@ dependencies = [

 [[package]]
 name = "ascii-canvas"
-version = "3.0.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6"
+checksum = "ef1e3e699d84ab1b0911a1010c5c106aa34ae89aeac103be5ce0c3859db1e891"
 dependencies = [
 "term",
 ]

 [[package]]
 name = "autocfg"
-version = "1.3.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"

 [[package]]
 name = "bit-set"
-version = "0.5.3"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
 dependencies = [
 "bit-vec",
 ]

 [[package]]
 name = "bit-vec"
-version = "0.6.3"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"

 [[package]]
 name = "bitflags"
@ -109,6 +109,15 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"

+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "byteorder"
 version = "1.5.0"
@ -117,9 +126,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"

 [[package]]
 name = "cc"
-version = "1.1.15"
+version = "1.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57b6a275aa2903740dc87da01c62040406b8812552e97129a63ea8850a17c6e6"
+checksum = "812acba72f0a070b003d3697490d2b55b837230ae7c6c6497f05cc2ddbb8d938"
 dependencies = [
 "shlex",
 ]
@ -132,9 +141,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

 [[package]]
 name = "clap"
-version = "4.5.16"
+version = "4.5.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019"
+checksum = "7be5744db7978a28d9df86a214130d106a89ce49644cbc4e3f0c22c3fba30615"
 dependencies = [
 "clap_builder",
 "clap_derive",
@ -142,9 +151,9 @@ dependencies = [

 [[package]]
 name = "clap_builder"
-version = "4.5.15"
+version = "4.5.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "216aec2b177652e3846684cbfe25c9964d18ec45234f0f5da5157b207ed1aab6"
+checksum = "a5fbc17d3ef8278f55b282b2a2e75ae6f6c7d4bb70ed3d0382375104bfafdb4b"
 dependencies = [
 "anstream",
 "anstyle",
@ -154,14 +163,14 @@ dependencies = [

 [[package]]
 name = "clap_derive"
-version = "4.5.13"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501d359d5f3dcaf6ecdeee48833ae73ec6e42723a1e52419c79abf9507eec0a0"
+checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
 dependencies = [
 "heck 0.5.0",
 "proc-macro2",
 "quote",
- "syn 2.0.76",
+ "syn 2.0.79",
 ]

 [[package]]
@ -188,6 +197,15 @@ dependencies = [
 "windows-sys 0.52.0",
 ]

+[[package]]
+name = "cpufeatures"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "crossbeam"
 version = "0.8.4"
@ -245,30 +263,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"

 [[package]]
-name = "crunchy"
-version = "0.2.2"
+name = "crypto-common"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
-
-[[package]]
-name = "dirs-next"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
- "cfg-if",
- "dirs-sys-next",
+ "generic-array",
+ "typenum",
 ]

 [[package]]
-name = "dirs-sys-next"
-version = "0.1.2"
+name = "digest"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
- "libc",
- "redox_users",
- "winapi",
+ "block-buffer",
+ "crypto-common",
 ]

 [[package]]
@ -329,6 +340,16 @@ dependencies = [
 "byteorder",
 ]

+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getopts"
 version = "0.2.21"
@ -364,6 +385,12 @@ dependencies = [
 "ahash",
 ]

+[[package]]
+name = "hashbrown"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb"
+
 [[package]]
 name = "heck"
 version = "0.4.1"
@ -376,6 +403,15 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

+[[package]]
+name = "home"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "indexmap"
 version = "1.9.3"
@ -388,12 +424,12 @@ dependencies = [

 [[package]]
 name = "indexmap"
-version = "2.4.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93ead53efc7ea8ed3cfb0c79fc8023fbb782a5432b52830b6518941cebe6505c"
+checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
 dependencies = [
 "equivalent",
- "hashbrown 0.14.5",
+ "hashbrown 0.15.0",
 ]

 [[package]]
@ -404,9 +440,9 @@ checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"

 [[package]]
 name = "inkwell"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b597a7b2cdf279aeef6d7149071e35e4bc87c2cf05a5b7f2d731300bffe587ea"
+checksum = "40fb405537710d51f6bdbc8471365ddd4cd6d3a3c3ad6e0c8291691031ba94b2"
 dependencies = [
 "either",
 "inkwell_internals",
@ -418,13 +454,13 @@ dependencies = [

 [[package]]
 name = "inkwell_internals"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fa4d8d74483041a882adaa9a29f633253a66dde85055f0495c121620ac484b2"
+checksum = "9dd28cfd4cfba665d47d31c08a6ba637eed16770abca2eccbbc3ca831fef1e44"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.76",
+ "syn 2.0.79",
 ]

 [[package]]
@ -447,15 +483,6 @@ version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"

-[[package]]
-name = "itertools"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itertools"
 version = "0.13.0"
@ -472,34 +499,44 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"

 [[package]]
-name = "lalrpop"
-version = "0.20.2"
+name = "keccak"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55cb077ad656299f160924eb2912aa147d7339ea7d69e1b5517326fdcec3c1ca"
+checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
+dependencies = [
+ "cpufeatures",
+]
+
+[[package]]
+name = "lalrpop"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06093b57658c723a21da679530e061a8c25340fa5a6f98e313b542268c7e2a1f"
 dependencies = [
 "ascii-canvas",
 "bit-set",
 "ena",
- "itertools 0.11.0",
+ "itertools",
 "lalrpop-util",
 "petgraph",
 "pico-args",
 "regex",
 "regex-syntax",
+ "sha3",
 "string_cache",
 "term",
- "tiny-keccak",
 "unicode-xid",
 "walkdir",
 ]

 [[package]]
 name = "lalrpop-util"
-version = "0.20.2"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "507460a910eb7b32ee961886ff48539633b788a36b65692b95f225b844c82553"
+checksum = "feee752d43abd0f4807a921958ab4131f692a44d4d599733d4419c5d586176ce"
 dependencies = [
 "regex-automata",
+ "rustversion",
 ]

 [[package]]
@ -510,9 +547,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"

 [[package]]
 name = "libc"
-version = "0.2.158"
+version = "0.2.159"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5"

 [[package]]
 name = "libloading"
@ -524,16 +561,6 @@ dependencies = [
 "windows-targets",
 ]

-[[package]]
-name = "libredox"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
-dependencies = [
- "bitflags",
- "libc",
-]
-
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@ -594,11 +621,9 @@ dependencies = [
 name = "nac3artiq"
 version = "0.1.0"
 dependencies = [
- "inkwell",
- "itertools 0.13.0",
+ "itertools",
 "nac3core",
 "nac3ld",
- "nac3parser",
 "parking_lot",
 "pyo3",
 "tempfile",
@ -619,11 +644,11 @@ name = "nac3core"
 version = "0.1.0"
 dependencies = [
 "crossbeam",
- "indexmap 2.4.0",
+ "indexmap 2.6.0",
 "indoc",
 "inkwell",
 "insta",
- "itertools 0.13.0",
+ "itertools",
 "nac3parser",
 "parking_lot",
 "rayon",
@ -661,9 +686,7 @@ name = "nac3standalone"
 version = "0.1.0"
 dependencies = [
 "clap",
- "inkwell",
 "nac3core",
- "nac3parser",
 "parking_lot",
 ]

@ -675,9 +698,12 @@ checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"

 [[package]]
 name = "once_cell"
-version = "1.19.0"
+version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "82881c4be219ab5faaf2ad5e5e5ecdff8c66bd7402ca3160975c93b24961afd1"
+dependencies = [
+ "portable-atomic",
+]

 [[package]]
 name = "parking_lot"
@ -709,7 +735,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
 "fixedbitset",
- "indexmap 2.4.0",
+ "indexmap 2.6.0",
 ]

 [[package]]
@ -752,7 +778,7 @@ dependencies = [
 "phf_shared 0.11.2",
 "proc-macro2",
 "quote",
- "syn 2.0.76",
+ "syn 2.0.79",
 ]

 [[package]]
@ -781,9 +807,9 @@ checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"

 [[package]]
 name = "portable-atomic"
-version = "1.7.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
+checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2"

 [[package]]
 name = "ppv-lite86"
@ -856,7 +882,7 @@ dependencies = [
 "proc-macro2",
 "pyo3-macros-backend",
 "quote",
- "syn 2.0.76",
+ "syn 2.0.79",
 ]

 [[package]]
@ -869,7 +895,7 @@ dependencies = [
 "proc-macro2",
 "pyo3-build-config",
 "quote",
- "syn 2.0.76",
+ "syn 2.0.79",
 ]

 [[package]]
@ -933,29 +959,18 @@ dependencies = [

 [[package]]
 name = "redox_syscall"
-version = "0.5.3"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4"
+checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
 dependencies = [
 "bitflags",
 ]

-[[package]]
-name = "redox_users"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
-dependencies = [
- "getrandom",
- "libredox",
- "thiserror",
-]
-
 [[package]]
 name = "regex"
-version = "1.10.6"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619"
+checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8"
 dependencies = [
 "aho-corasick",
 "memchr",
@ -965,9 +980,9 @@ dependencies = [

 [[package]]
 name = "regex-automata"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
 dependencies = [
 "aho-corasick",
 "memchr",
@ -976,9 +991,9 @@ dependencies = [

 [[package]]
 name = "regex-syntax"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"

 [[package]]
 name = "runkernel"
@ -989,9 +1004,9 @@ dependencies = [

 [[package]]
 name = "rustix"
-version = "0.38.35"
+version = "0.38.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a85d50532239da68e9addb745ba38ff4612a242c1c7ceea689c4bc7c2f43c36f"
+checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811"
 dependencies = [
 "bitflags",
 "errno",
@ -1035,29 +1050,29 @@ checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"

 [[package]]
 name = "serde"
-version = "1.0.209"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.209"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.76",
+ "syn 2.0.79",
 ]

 [[package]]
 name = "serde_json"
-version = "1.0.127"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
+checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
 dependencies = [
 "itoa",
 "memchr",
@ -1077,6 +1092,16 @@ dependencies = [
 "yaml-rust",
 ]

+[[package]]
+name = "sha3"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
+dependencies = [
+ "digest",
+ "keccak",
+]
+
 [[package]]
 name = "shlex"
 version = "1.3.0"
@ -1147,7 +1172,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 2.0.76",
+ "syn 2.0.79",
 ]

 [[package]]
@ -1163,9 +1188,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.76"
+version = "2.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+checksum = "89132cd0bf050864e1d38dc3bbc07a0eb8e7530af26344d3d2bbbef83499f590"
 dependencies = [
 "proc-macro2",
 "quote",
@ -1180,9 +1205,9 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"

 [[package]]
 name = "tempfile"
-version = "3.12.0"
+version = "3.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64"
+checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
 dependencies = [
 "cfg-if",
 "fastrand",
@ -1193,13 +1218,12 @@ dependencies = [

 [[package]]
 name = "term"
-version = "0.7.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
+checksum = "4df4175de05129f31b80458c6df371a15e7fc3fd367272e6bf938e5c351c7ea0"
 dependencies = [
- "dirs-next",
- "rustversion",
- "winapi",
+ "home",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@ -1217,32 +1241,29 @@ dependencies = [

 [[package]]
 name = "thiserror"
-version = "1.0.63"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
+checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84"
 dependencies = [
 "thiserror-impl",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "1.0.63"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
+checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.76",
+ "syn 2.0.79",
 ]

 [[package]]
-name = "tiny-keccak"
-version = "2.0.2"
+name = "typenum"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
-dependencies = [
- "crunchy",
-]
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"

 [[package]]
 name = "unic-char-property"
@ -1298,27 +1319,27 @@ dependencies = [

 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"

 [[package]]
 name = "unicode-width"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"

 [[package]]
 name = "unicode-xid"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "229730647fbc343e3a80e463c1db7f78f3855d3f3739bee0dda773c9a037c90a"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"

 [[package]]
 name = "unicode_names2"
-version = "1.2.2"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "addeebf294df7922a1164f729fb27ebbbcea99cc32b3bf08afab62757f707677"
+checksum = "d1673eca9782c84de5f81b82e4109dcfb3611c8ba0d52930ec4a9478f547b2dd"
 dependencies = [
 "phf",
 "unicode_names2_generator",
@ -1326,9 +1347,9 @@ dependencies = [

 [[package]]
 name = "unicode_names2_generator"
-version = "1.2.2"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f444b8bba042fe3c1251ffaca35c603f2dc2ccc08d595c65a8c4f76f3e8426c0"
+checksum = "b91e5b84611016120197efd7dc93ef76774f4e084cd73c9fb3ea4a86c570c56e"
 dependencies = [
 "getopts",
 "log",
@ -1370,22 +1391,6 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
 [[package]]
 name = "winapi-util"
 version = "0.1.9"
@ -1395,12 +1400,6 @@ dependencies = [
 "windows-sys 0.59.0",
 ]

-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@ -1510,5 +1509,5 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.76",
+ "syn 2.0.79",
 ]
--- a/flake.lock
+++ b/flake.lock
@ -2,11 +2,11 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1723637854,
-        "narHash": "sha256-med8+5DSWa2UnOqtdICndjDAEjxr5D7zaIiK4pn0Q7c=",
+        "lastModified": 1727348695,
+        "narHash": "sha256-J+PeFKSDV+pHL7ukkfpVzCOO7mBSrrpJ3svwBFABbhI=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "c3aa7b8938b17aebd2deecf7be0636000d62a2b9",
+        "rev": "1925c603f17fc89f4c8f6bf6f631a802ad85d784",
        "type": "github"
      },
      "original": {
--- a/nac3artiq/Cargo.toml
+++ b/nac3artiq/Cargo.toml
@ -12,16 +12,10 @@ crate-type = ["cdylib"]
 itertools = "0.13"
 pyo3 = { version = "0.21", features = ["extension-module", "gil-refs"] }
 parking_lot = "0.12"
-tempfile = "3.10"
-nac3parser = { path = "../nac3parser" }
+tempfile = "3.13"
 nac3core = { path = "../nac3core" }
 nac3ld = { path = "../nac3ld" }

-[dependencies.inkwell]
-version = "0.4"
-default-features = false
-features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
-
 [features]
 init-llvm-profile = []
 no-escape-analysis = ["nac3core/no-escape-analysis"]
--- a/nac3artiq/demo/min_artiq.py
+++ b/nac3artiq/demo/min_artiq.py
@ -112,10 +112,15 @@ def extern(function):
    register_function(function)
    return function

-def rpc(function):
-    """Decorates a function declaration defined by the core device runtime."""
-    register_function(function)
-    return function
+
+def rpc(arg=None, flags={}):
+    """Decorates a function or method to be executed on the host interpreter."""
+    if arg is None:
+        def inner_decorator(function):
+            return rpc(function, flags)
+        return inner_decorator
+    register_function(arg)
+    return arg

 def kernel(function_or_method):
    """Decorates a function or method to be executed on the core device."""
--- a/nac3artiq/src/codegen.rs
+++ b/nac3artiq/src/codegen.rs
@ -1,3 +1,17 @@
+use std::{
+    collections::{hash_map::DefaultHasher, HashMap},
+    hash::{Hash, Hasher},
+    iter::once,
+    mem,
+    sync::Arc,
+};
+
+use itertools::Itertools;
+use pyo3::{
+    types::{PyDict, PyList},
+    PyObject, PyResult, Python,
+};
+
 use nac3core::{
    codegen::{
        classes::{
@ -10,38 +24,21 @@ use nac3core::{
        stmt::{gen_block, gen_for_callback_incrementing, gen_if_callback, gen_with},
        CodeGenContext, CodeGenerator,
    },
+    inkwell::{
+        context::Context,
+        module::Linkage,
+        types::{BasicType, IntType},
+        values::{BasicValueEnum, IntValue, PointerValue, StructValue},
+        AddressSpace, IntPredicate, OptimizationLevel,
+    },
+    nac3parser::ast::{Expr, ExprKind, Located, Stmt, StmtKind, StrRef},
    symbol_resolver::ValueEnum,
    toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, DefinitionId, GenCall},
    typecheck::typedef::{iter_type_vars, FunSignature, FuncArg, Type, TypeEnum, VarMap},
 };

-use nac3parser::ast::{Expr, ExprKind, Located, Stmt, StmtKind, StrRef};
-
-use inkwell::{
-    context::Context,
-    module::Linkage,
-    types::{BasicType, IntType},
-    values::{BasicValueEnum, PointerValue, StructValue},
-    AddressSpace, IntPredicate, OptimizationLevel,
-};
-
-use pyo3::{
-    types::{PyDict, PyList},
-    PyObject, PyResult, Python,
-};
-
 use crate::{symbol_resolver::InnerResolver, timeline::TimeFns};

-use inkwell::values::IntValue;
-use itertools::Itertools;
-use std::{
-    collections::{hash_map::DefaultHasher, HashMap},
-    hash::{Hash, Hasher},
-    iter::once,
-    mem,
-    sync::Arc,
-};
-
 /// The parallelism mode within a block.
 #[derive(Copy, Clone, Eq, PartialEq)]
 enum ParallelMode {
@ -461,8 +458,8 @@ fn format_rpc_arg<'ctx>(
            let llvm_usize = generator.get_size_type(ctx.ctx);

            let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, arg_ty);
-            let llvm_arg_ty =
-                NDArrayType::new(generator, ctx.ctx, ctx.get_llvm_type(generator, elem_ty));
+            let llvm_elem_ty = ctx.get_llvm_type(generator, elem_ty);
+            let llvm_arg_ty = NDArrayType::new(generator, ctx.ctx, llvm_elem_ty);
            let llvm_arg = NDArrayValue::from_ptr_val(arg.into_pointer_value(), llvm_usize, None);

            let llvm_usize_sizeof = ctx
@ -472,7 +469,7 @@ fn format_rpc_arg<'ctx>(
            let llvm_pdata_sizeof = ctx
                .builder
                .build_int_truncate_or_bit_cast(
-                    llvm_arg_ty.element_type().ptr_type(AddressSpace::default()).size_of(),
+                    llvm_elem_ty.ptr_type(AddressSpace::default()).size_of(),
                    llvm_usize,
                    "",
                )
@ -515,7 +512,7 @@ fn format_rpc_arg<'ctx>(
            ctx.builder.build_store(arg_slot, arg).unwrap();

            ctx.builder
-                .build_bitcast(arg_slot, llvm_pi8, "rpc.arg")
+                .build_bit_cast(arg_slot, llvm_pi8, "rpc.arg")
                .map(BasicValueEnum::into_pointer_value)
                .unwrap()
        }
@ -630,7 +627,7 @@ fn format_rpc_ret<'ctx>(
            let llvm_pdata_sizeof = ctx
                .builder
                .build_int_truncate_or_bit_cast(
-                    llvm_ret_ty.element_type().size_of().unwrap(),
+                    llvm_elem_ty.ptr_type(AddressSpace::default()).size_of(),
                    llvm_usize,
                    "",
                )
@ -662,7 +659,7 @@ fn format_rpc_ret<'ctx>(
                .unwrap();
            let buffer = ctx
                .builder
-                .build_bitcast(buffer, llvm_pi8, "")
+                .build_bit_cast(buffer, llvm_pi8, "")
                .map(BasicValueEnum::into_pointer_value)
                .unwrap();
            let buffer = ArraySliceValue::from_ptr_val(buffer, buffer_size, None);
@ -785,7 +782,7 @@ fn format_rpc_ret<'ctx>(

        _ => {
            let slot = ctx.builder.build_alloca(llvm_ret_ty, "rpc.ret.slot").unwrap();
-            let slotgen = ctx.builder.build_bitcast(slot, llvm_pi8, "rpc.ret.ptr").unwrap();
+            let slotgen = ctx.builder.build_bit_cast(slot, llvm_pi8, "rpc.ret.ptr").unwrap();
            ctx.builder.build_unconditional_branch(head_bb).unwrap();
            ctx.builder.position_at_end(head_bb);

@ -806,7 +803,7 @@ fn format_rpc_ret<'ctx>(
            let alloc_ptr =
                ctx.builder.build_array_alloca(llvm_pi8, alloc_size, "rpc.alloc").unwrap();
            let alloc_ptr =
-                ctx.builder.build_bitcast(alloc_ptr, llvm_pi8, "rpc.alloc.ptr").unwrap();
+                ctx.builder.build_bit_cast(alloc_ptr, llvm_pi8, "rpc.alloc.ptr").unwrap();
            phi.add_incoming(&[(&alloc_ptr, alloc_bb)]);
            ctx.builder.build_unconditional_branch(head_bb).unwrap();

@ -824,6 +821,7 @@ fn rpc_codegen_callback_fn<'ctx>(
    fun: (&FunSignature, DefinitionId),
    args: Vec<(Option<StrRef>, ValueEnum<'ctx>)>,
    generator: &mut dyn CodeGenerator,
+    is_async: bool,
 ) -> Result<Option<BasicValueEnum<'ctx>>, String> {
    let int8 = ctx.ctx.i8_type();
    let int32 = ctx.ctx.i32_type();
@ -932,6 +930,29 @@ fn rpc_codegen_callback_fn<'ctx>(
    }

    // call
+    if is_async {
+        let rpc_send_async = ctx.module.get_function("rpc_send_async").unwrap_or_else(|| {
+            ctx.module.add_function(
+                "rpc_send_async",
+                ctx.ctx.void_type().fn_type(
+                    &[
+                        int32.into(),
+                        tag_ptr_type.ptr_type(AddressSpace::default()).into(),
+                        ptr_type.ptr_type(AddressSpace::default()).into(),
+                    ],
+                    false,
+                ),
+                None,
+            )
+        });
+        ctx.builder
+            .build_call(
+                rpc_send_async,
+                &[service_id.into(), tag_ptr.into(), args_ptr.into()],
+                "rpc.send",
+            )
+            .unwrap();
+    } else {
        let rpc_send = ctx.module.get_function("rpc_send").unwrap_or_else(|| {
            ctx.module.add_function(
                "rpc_send",
@ -949,10 +970,15 @@ fn rpc_codegen_callback_fn<'ctx>(
        ctx.builder
            .build_call(rpc_send, &[service_id.into(), tag_ptr.into(), args_ptr.into()], "rpc.send")
            .unwrap();
+    }

    // reclaim stack space used by arguments
    call_stackrestore(ctx, stackptr);

+    if is_async {
+        // async RPCs do not return any values
+        Ok(None)
+    } else {
        let result = format_rpc_ret(generator, ctx, fun.0.ret);

        if !result.is_some_and(|res| res.get_type().is_pointer_type()) {
@ -962,6 +988,7 @@ fn rpc_codegen_callback_fn<'ctx>(

        Ok(result)
    }
+}

 pub fn attributes_writeback(
    ctx: &mut CodeGenContext<'_, '_>,
@ -1055,7 +1082,7 @@ pub fn attributes_writeback(
        let args: Vec<_> =
            values.into_iter().map(|(_, val)| (None, ValueEnum::Dynamic(val))).collect();
        if let Err(e) =
-            rpc_codegen_callback_fn(ctx, None, (&fun, PrimDef::Int32.id()), args, generator)
+            rpc_codegen_callback_fn(ctx, None, (&fun, PrimDef::Int32.id()), args, generator, false)
        {
            return Ok(Err(e));
        }
@ -1065,9 +1092,9 @@ pub fn attributes_writeback(
    Ok(())
 }

-pub fn rpc_codegen_callback() -> Arc<GenCall> {
-    Arc::new(GenCall::new(Box::new(|ctx, obj, fun, args, generator| {
-        rpc_codegen_callback_fn(ctx, obj, fun, args, generator)
+pub fn rpc_codegen_callback(is_async: bool) -> Arc<GenCall> {
+    Arc::new(GenCall::new(Box::new(move |ctx, obj, fun, args, generator| {
+        rpc_codegen_callback_fn(ctx, obj, fun, args, generator, is_async)
    })))
 }

--- a/nac3artiq/src/lib.rs
+++ b/nac3artiq/src/lib.rs
@ -16,14 +16,30 @@
    clippy::wildcard_imports
 )]

-use std::collections::{HashMap, HashSet};
-use std::fs;
-use std::io::Write;
-use std::process::Command;
-use std::rc::Rc;
-use std::sync::Arc;
+use std::{
+    collections::{HashMap, HashSet},
+    fs,
+    io::Write,
+    process::Command,
+    rc::Rc,
+    sync::Arc,
+};

-use inkwell::{
+use itertools::Itertools;
+use parking_lot::{Mutex, RwLock};
+use pyo3::{
+    create_exception, exceptions,
+    prelude::*,
+    types::{PyBytes, PyDict, PySet},
+};
+use tempfile::{self, TempDir};
+
+use nac3core::{
+    codegen::{
+        concrete_type::ConcreteTypeStore, gen_func_impl, irrt::load_irrt, CodeGenLLVMOptions,
+        CodeGenTargetMachineOptions, CodeGenTask, WithCall, WorkerRegistry,
+    },
+    inkwell::{
        context::Context,
        memory_buffer::MemoryBuffer,
        module::{Linkage, Module},
@ -31,33 +47,22 @@ use inkwell::{
        support::is_multithreaded,
        targets::*,
        OptimizationLevel,
-};
-use itertools::Itertools;
-use nac3core::codegen::{gen_func_impl, CodeGenLLVMOptions, CodeGenTargetMachineOptions};
-use nac3core::toplevel::builtins::get_exn_constructor;
-use nac3core::typecheck::typedef::{into_var_map, TypeEnum, Unifier, VarMap};
-use nac3parser::{
-    ast::{ExprKind, Stmt, StmtKind, StrRef},
+    },
+    nac3parser::{
+        ast::{Constant, ExprKind, Located, Stmt, StmtKind, StrRef},
        parser::parse_program,
-};
-use pyo3::create_exception;
-use pyo3::prelude::*;
-use pyo3::{exceptions, types::PyBytes, types::PyDict, types::PySet};
-
-use parking_lot::{Mutex, RwLock};
-
-use nac3core::{
-    codegen::irrt::load_irrt,
-    codegen::{concrete_type::ConcreteTypeStore, CodeGenTask, WithCall, WorkerRegistry},
+    },
    symbol_resolver::SymbolResolver,
    toplevel::{
+        builtins::get_exn_constructor,
        composer::{BuiltinFuncCreator, BuiltinFuncSpec, ComposerConfig, TopLevelComposer},
        DefinitionId, GenCall, TopLevelDef,
    },
-    typecheck::typedef::{FunSignature, FuncArg},
-    typecheck::{type_inferencer::PrimitiveStore, typedef::Type},
+    typecheck::{
+        type_inferencer::PrimitiveStore,
+        typedef::{into_var_map, FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
+    },
 };
-
 use nac3ld::Linker;

 use crate::{
@ -65,15 +70,13 @@ use crate::{
        attributes_writeback, gen_core_log, gen_rtio_log, rpc_codegen_callback, ArtiqCodeGenerator,
    },
    symbol_resolver::{DeferredEvaluationStore, InnerResolver, PythonHelper, Resolver},
+    timeline::TimeFns,
 };
-use tempfile::{self, TempDir};

 mod codegen;
 mod symbol_resolver;
 mod timeline;

-use timeline::TimeFns;
-
 #[derive(PartialEq, Clone, Copy)]
 enum Isa {
    Host,
@ -194,10 +197,8 @@ impl Nac3 {
                    body.retain(|stmt| {
                        if let StmtKind::FunctionDef { ref decorator_list, .. } = stmt.node {
                            decorator_list.iter().any(|decorator| {
-                                if let ExprKind::Name { id, .. } = decorator.node {
-                                    id.to_string() == "kernel"
-                                        || id.to_string() == "portable"
-                                        || id.to_string() == "rpc"
+                                if let Some(id) = decorator_id_string(decorator) {
+                                    id == "kernel" || id == "portable" || id == "rpc"
                                } else {
                                    false
                                }
@ -210,9 +211,8 @@ impl Nac3 {
                }
                StmtKind::FunctionDef { ref decorator_list, .. } => {
                    decorator_list.iter().any(|decorator| {
-                        if let ExprKind::Name { id, .. } = decorator.node {
-                            let id = id.to_string();
-                            id == "extern" || id == "portable" || id == "kernel" || id == "rpc"
+                        if let Some(id) = decorator_id_string(decorator) {
+                            id == "extern" || id == "kernel" || id == "portable" || id == "rpc"
                        } else {
                            false
                        }
@ -478,9 +478,25 @@ impl Nac3 {

            match &stmt.node {
                StmtKind::FunctionDef { decorator_list, .. } => {
-                    if decorator_list.iter().any(|decorator| matches!(decorator.node, ExprKind::Name { id, .. } if id == "rpc".into())) {
-                        store_fun.call1(py, (def_id.0.into_py(py), module.getattr(py, name.to_string().as_str()).unwrap())).unwrap();
-                        rpc_ids.push((None, def_id));
+                    if decorator_list
+                        .iter()
+                        .any(|decorator| decorator_id_string(decorator) == Some("rpc".to_string()))
+                    {
+                        store_fun
+                            .call1(
+                                py,
+                                (
+                                    def_id.0.into_py(py),
+                                    module.getattr(py, name.to_string().as_str()).unwrap(),
+                                ),
+                            )
+                            .unwrap();
+                        let is_async = decorator_list.iter().any(|decorator| {
+                            decorator_get_flags(decorator)
+                                .iter()
+                                .any(|constant| *constant == Constant::Str("async".into()))
+                        });
+                        rpc_ids.push((None, def_id, is_async));
                    }
                }
                StmtKind::ClassDef { name, body, .. } => {
@ -488,19 +504,26 @@ impl Nac3 {
                    let class_obj = module.getattr(py, class_name.as_str()).unwrap();
                    for stmt in body {
                        if let StmtKind::FunctionDef { name, decorator_list, .. } = &stmt.node {
-                            if decorator_list.iter().any(|decorator| matches!(decorator.node, ExprKind::Name { id, .. } if id == "rpc".into())) {
+                            if decorator_list.iter().any(|decorator| {
+                                decorator_id_string(decorator) == Some("rpc".to_string())
+                            }) {
+                                let is_async = decorator_list.iter().any(|decorator| {
+                                    decorator_get_flags(decorator)
+                                        .iter()
+                                        .any(|constant| *constant == Constant::Str("async".into()))
+                                });
                                if name == &"__init__".into() {
                                    return Err(CompileError::new_err(format!(
                                        "compilation failed\n----------\nThe constructor of class {} should not be decorated with rpc decorator (at {})",
                                        class_name, stmt.location
                                    )));
                                }
-                                rpc_ids.push((Some((class_obj.clone(), *name)), def_id));
+                                rpc_ids.push((Some((class_obj.clone(), *name)), def_id, is_async));
                            }
                        }
                    }
                }
-                _ => ()
+                _ => (),
            }

            let id = *name_to_pyid.get(&name).unwrap();
@ -556,7 +579,7 @@ impl Nac3 {
            .unwrap();

        // Process IRRT
-        let context = inkwell::context::Context::create();
+        let context = Context::create();
        let irrt = load_irrt(&context, resolver.as_ref());

        let fun_signature =
@ -596,13 +619,12 @@ impl Nac3 {
        let top_level = Arc::new(composer.make_top_level_context());

        {
-            let rpc_codegen = rpc_codegen_callback();
            let defs = top_level.definitions.read();
-            for (class_data, id) in &rpc_ids {
+            for (class_data, id, is_async) in &rpc_ids {
                let mut def = defs[id.0].write();
                match &mut *def {
                    TopLevelDef::Function { codegen_callback, .. } => {
-                        *codegen_callback = Some(rpc_codegen.clone());
+                        *codegen_callback = Some(rpc_codegen_callback(*is_async));
                    }
                    TopLevelDef::Class { methods, .. } => {
                        let (class_def, method_name) = class_data.as_ref().unwrap();
@ -613,7 +635,7 @@ impl Nac3 {
                            if let TopLevelDef::Function { codegen_callback, .. } =
                                &mut *defs[id.0].write()
                            {
-                                *codegen_callback = Some(rpc_codegen.clone());
+                                *codegen_callback = Some(rpc_codegen_callback(*is_async));
                                store_fun
                                    .call1(
                                        py,
@ -628,6 +650,11 @@ impl Nac3 {
                            }
                        }
                    }
+                    TopLevelDef::Variable { .. } => {
+                        return Err(CompileError::new_err(String::from(
+                            "Unsupported @rpc annotation on global variable",
+                        )))
+                    }
                }
            }
        }
@ -687,7 +714,7 @@ impl Nac3 {
            let buffer = buffer.as_slice().into();
            membuffer.lock().push(buffer);
        })));
-        let size_t = Context::create()
+        let size_t = context
            .ptr_sized_int_type(&self.get_llvm_target_machine().get_target_data(), None)
            .get_bit_width();
        let num_threads = if is_multithreaded() { 4 } else { 1 };
@ -706,7 +733,7 @@ impl Nac3 {

            let mut generator =
                ArtiqCodeGenerator::new("attributes_writeback".to_string(), size_t, self.time_fns);
-            let context = inkwell::context::Context::create();
+            let context = Context::create();
            let module = context.create_module("attributes_writeback");
            let target_machine = self.llvm_options.create_target_machine().unwrap();
            module.set_data_layout(&target_machine.get_target_data().get_data_layout());
@ -844,6 +871,41 @@ impl Nac3 {
    }
 }

+/// Retrieves the Name.id from a decorator, supports decorators with arguments.
+fn decorator_id_string(decorator: &Located<ExprKind>) -> Option<String> {
+    if let ExprKind::Name { id, .. } = decorator.node {
+        // Bare decorator
+        return Some(id.to_string());
+    } else if let ExprKind::Call { func, .. } = &decorator.node {
+        // Decorators that are calls (e.g. "@rpc()") have Call for the node,
+        // need to extract the id from within.
+        if let ExprKind::Name { id, .. } = func.node {
+            return Some(id.to_string());
+        }
+    }
+    None
+}
+
+/// Retrieves flags from a decorator, if any.
+fn decorator_get_flags(decorator: &Located<ExprKind>) -> Vec<Constant> {
+    let mut flags = vec![];
+    if let ExprKind::Call { keywords, .. } = &decorator.node {
+        for keyword in keywords {
+            if keyword.node.arg != Some("flags".into()) {
+                continue;
+            }
+            if let ExprKind::Set { elts } = &keyword.node.value.node {
+                for elt in elts {
+                    if let ExprKind::Constant { value, .. } = &elt.node {
+                        flags.push(value.clone());
+                    }
+                }
+            }
+        }
+    }
+    flags
+}
+
 fn link_with_lld(elf_filename: String, obj_filename: String) -> PyResult<()> {
    let linker_args = vec![
        "-shared".to_string(),
--- a/nac3artiq/src/symbol_resolver.rs
+++ b/nac3artiq/src/symbol_resolver.rs
@ -1,16 +1,30 @@
-use crate::PrimitivePythonId;
-use inkwell::{
-    module::Linkage,
-    types::{BasicType, BasicTypeEnum},
-    values::BasicValueEnum,
-    AddressSpace,
+use std::{
+    collections::{HashMap, HashSet},
+    sync::{
+        atomic::{AtomicBool, Ordering::Relaxed},
+        Arc,
+    },
 };
+
 use itertools::Itertools;
+use parking_lot::RwLock;
+use pyo3::{
+    types::{PyDict, PyTuple},
+    PyAny, PyObject, PyResult, Python,
+};
+
 use nac3core::{
    codegen::{
        classes::{NDArrayType, ProxyType},
        CodeGenContext, CodeGenerator,
    },
+    inkwell::{
+        module::Linkage,
+        types::{BasicType, BasicTypeEnum},
+        values::BasicValueEnum,
+        AddressSpace,
+    },
+    nac3parser::ast::{self, StrRef},
    symbol_resolver::{StaticValue, SymbolResolver, SymbolValue, ValueEnum},
    toplevel::{
        helper::PrimDef,
@ -22,19 +36,8 @@ use nac3core::{
        typedef::{into_var_map, iter_type_vars, Type, TypeEnum, TypeVar, Unifier, VarMap},
    },
 };
-use nac3parser::ast::{self, StrRef};
-use parking_lot::RwLock;
-use pyo3::{
-    types::{PyDict, PyTuple},
-    PyAny, PyObject, PyResult, Python,
-};
-use std::{
-    collections::{HashMap, HashSet},
-    sync::{
-        atomic::{AtomicBool, Ordering::Relaxed},
-        Arc,
-    },
-};
+
+use crate::PrimitivePythonId;

 pub enum PrimitiveValue {
    I32(i32),
@ -1467,6 +1470,7 @@ impl SymbolResolver for Resolver {
        &self,
        id: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
+        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        let sym_value = {
            let id_to_val = self.0.id_to_pyval.read();
--- a/nac3artiq/src/timeline.rs
+++ b/nac3artiq/src/timeline.rs
@ -1,9 +1,12 @@
-use inkwell::{
+use itertools::Either;
+
+use nac3core::{
+    codegen::CodeGenContext,
+    inkwell::{
        values::{BasicValueEnum, CallSiteValue},
        AddressSpace, AtomicOrdering,
+    },
 };
-use itertools::Either;
-use nac3core::codegen::CodeGenContext;

 /// Functions for manipulating the timeline.
 pub trait TimeFns {
@ -31,7 +34,7 @@ impl TimeFns for NowPinningTimeFns64 {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();

@ -80,7 +83,7 @@ impl TimeFns for NowPinningTimeFns64 {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();

@ -109,7 +112,7 @@ impl TimeFns for NowPinningTimeFns64 {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();

@ -207,7 +210,7 @@ impl TimeFns for NowPinningTimeFns {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();

@ -258,7 +261,7 @@ impl TimeFns for NowPinningTimeFns {
        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "time.lo").unwrap();
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();

--- a/nac3core/Cargo.toml
+++ b/nac3core/Cargo.toml
@ -10,17 +10,17 @@ no-escape-analysis = []
 [dependencies]
 itertools = "0.13"
 crossbeam = "0.8"
-indexmap = "2.2"
+indexmap = "2.6"
 parking_lot = "0.12"
-rayon = "1.8"
+rayon = "1.10"
 nac3parser = { path = "../nac3parser" }
 strum = "0.26"
 strum_macros = "0.26"

 [dependencies.inkwell]
-version = "0.4"
+version = "0.5"
 default-features = false
-features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
+features = ["llvm14-0-prefer-dynamic", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]

 [dev-dependencies]
 test-case = "1.2.0"
--- a/nac3core/build.rs
+++ b/nac3core/build.rs
@ -1,4 +1,3 @@
-use regex::Regex;
 use std::{
    env,
    fs::File,
@ -7,6 +6,8 @@ use std::{
    process::{Command, Stdio},
 };

+use regex::Regex;
+
 fn main() {
    let out_dir = env::var("OUT_DIR").unwrap();
    let out_dir = Path::new(&out_dir);
--- a/nac3core/irrt/irrt.cpp
+++ b/nac3core/irrt/irrt.cpp
@ -4,3 +4,6 @@
 #include "irrt/math.hpp"
 #include "irrt/ndarray.hpp"
 #include "irrt/slice.hpp"
+#include "irrt/ndarray/basic.hpp"
+#include "irrt/ndarray/def.hpp"
+#include "irrt/ndarray/iter.hpp"
--- a/nac3core/irrt/irrt/exception.hpp
+++ b/nac3core/irrt/irrt/exception.hpp
@ -55,11 +55,14 @@ void _raise_exception_helper(ExceptionId id,
                             int64_t param2) {
    Exception<SizeT> e = {
        .id = id,
-        .filename = {.base = reinterpret_cast<const uint8_t*>(filename), .len = __builtin_strlen(filename)},
+        .filename = {.base = reinterpret_cast<uint8_t*>(const_cast<char*>(filename)),
+                     .len = static_cast<int32_t>(__builtin_strlen(filename))},
        .line = line,
        .column = 0,
-        .function = {.base = reinterpret_cast<const uint8_t*>(function), .len = __builtin_strlen(function)},
-        .msg = {.base = reinterpret_cast<const uint8_t*>(msg), .len = __builtin_strlen(msg)},
+        .function = {.base = reinterpret_cast<uint8_t*>(const_cast<char*>(function)),
+                     .len = static_cast<int32_t>(__builtin_strlen(function))},
+        .msg = {.base = reinterpret_cast<uint8_t*>(const_cast<char*>(msg)),
+                .len = static_cast<int32_t>(__builtin_strlen(msg))},
    };
    e.params[0] = param0;
    e.params[1] = param1;
--- a/nac3core/irrt/irrt/int_types.hpp
+++ b/nac3core/irrt/irrt/int_types.hpp
@ -1,11 +1,20 @@
 #pragma once

+#if __STDC_VERSION__ >= 202000
 using int8_t = _BitInt(8);
 using uint8_t = unsigned _BitInt(8);
 using int32_t = _BitInt(32);
 using uint32_t = unsigned _BitInt(32);
 using int64_t = _BitInt(64);
 using uint64_t = unsigned _BitInt(64);
+#else
+using int8_t = _ExtInt(8);
+using uint8_t = unsigned _ExtInt(8);
+using int32_t = _ExtInt(32);
+using uint32_t = unsigned _ExtInt(32);
+using int64_t = _ExtInt(64);
+using uint64_t = unsigned _ExtInt(64);
+#endif

 // NDArray indices are always `uint32_t`.
 using NDIndex = uint32_t;
--- a/nac3core/irrt/irrt/ndarray.hpp
+++ b/nac3core/irrt/irrt/ndarray.hpp
@ -2,6 +2,8 @@

 #include "irrt/int_types.hpp"

+// TODO: To be deleted since NDArray with strides is done.
+
 namespace {
 template<typename SizeT>
 SizeT __nac3_ndarray_calc_size_impl(const SizeT* list_data, SizeT list_len, SizeT begin_idx, SizeT end_idx) {
--- a/nac3core/irrt/irrt/ndarray/basic.hpp
+++ b/nac3core/irrt/irrt/ndarray/basic.hpp
@ -0,0 +1,341 @@
+#pragma once
+
+#include "irrt/debug.hpp"
+#include "irrt/exception.hpp"
+#include "irrt/int_types.hpp"
+#include "irrt/ndarray/def.hpp"
+
+namespace {
+namespace ndarray {
+namespace basic {
+/**
+ * @brief Assert that `shape` does not contain negative dimensions.
+ *
+ * @param ndims Number of dimensions in `shape`
+ * @param shape The shape to check on
+ */
+template<typename SizeT>
+void assert_shape_no_negative(SizeT ndims, const SizeT* shape) {
+    for (SizeT axis = 0; axis < ndims; axis++) {
+        if (shape[axis] < 0) {
+            raise_exception(SizeT, EXN_VALUE_ERROR,
+                            "negative dimensions are not allowed; axis {0} "
+                            "has dimension {1}",
+                            axis, shape[axis], NO_PARAM);
+        }
+    }
+}
+
+/**
+ * @brief Assert that two shapes are the same in the context of writing output to an ndarray.
+ */
+template<typename SizeT>
+void assert_output_shape_same(SizeT ndarray_ndims,
+                              const SizeT* ndarray_shape,
+                              SizeT output_ndims,
+                              const SizeT* output_shape) {
+    if (ndarray_ndims != output_ndims) {
+        // There is no corresponding NumPy error message like this.
+        raise_exception(SizeT, EXN_VALUE_ERROR, "Cannot write output of ndims {0} to an ndarray with ndims {1}",
+                        output_ndims, ndarray_ndims, NO_PARAM);
+    }
+
+    for (SizeT axis = 0; axis < ndarray_ndims; axis++) {
+        if (ndarray_shape[axis] != output_shape[axis]) {
+            // There is no corresponding NumPy error message like this.
+            raise_exception(SizeT, EXN_VALUE_ERROR,
+                            "Mismatched dimensions on axis {0}, output has "
+                            "dimension {1}, but destination ndarray has dimension {2}.",
+                            axis, output_shape[axis], ndarray_shape[axis]);
+        }
+    }
+}
+
+/**
+ * @brief Return the number of elements of an ndarray given its shape.
+ *
+ * @param ndims Number of dimensions in `shape`
+ * @param shape The shape of the ndarray
+ */
+template<typename SizeT>
+SizeT calc_size_from_shape(SizeT ndims, const SizeT* shape) {
+    SizeT size = 1;
+    for (SizeT axis = 0; axis < ndims; axis++)
+        size *= shape[axis];
+    return size;
+}
+
+/**
+ * @brief Compute the array indices of the `nth` (0-based) element of an ndarray given only its shape.
+ *
+ * @param ndims Number of elements in `shape` and `indices`
+ * @param shape The shape of the ndarray
+ * @param indices The returned indices indexing the ndarray with shape `shape`.
+ * @param nth The index of the element of interest.
+ */
+template<typename SizeT>
+void set_indices_by_nth(SizeT ndims, const SizeT* shape, SizeT* indices, SizeT nth) {
+    for (SizeT i = 0; i < ndims; i++) {
+        SizeT axis = ndims - i - 1;
+        SizeT dim = shape[axis];
+
+        indices[axis] = nth % dim;
+        nth /= dim;
+    }
+}
+
+/**
+ * @brief Return the number of elements of an `ndarray`
+ *
+ * This function corresponds to `<an_ndarray>.size`
+ */
+template<typename SizeT>
+SizeT size(const NDArray<SizeT>* ndarray) {
+    return calc_size_from_shape(ndarray->ndims, ndarray->shape);
+}
+
+/**
+ * @brief Return of the number of its content of an `ndarray`.
+ *
+ * This function corresponds to `<an_ndarray>.nbytes`.
+ */
+template<typename SizeT>
+SizeT nbytes(const NDArray<SizeT>* ndarray) {
+    return size(ndarray) * ndarray->itemsize;
+}
+
+/**
+ * @brief Get the `len()` of an ndarray, and asserts that `ndarray` is a sized object.
+ *
+ * This function corresponds to `<an_ndarray>.__len__`.
+ *
+ * @param dst_length The length.
+ */
+template<typename SizeT>
+SizeT len(const NDArray<SizeT>* ndarray) {
+    // numpy prohibits `__len__` on unsized objects
+    if (ndarray->ndims == 0) {
+        raise_exception(SizeT, EXN_TYPE_ERROR, "len() of unsized object", NO_PARAM, NO_PARAM, NO_PARAM);
+    } else {
+        return ndarray->shape[0];
+    }
+}
+
+/**
+ * @brief Return a boolean indicating if `ndarray` is (C-)contiguous.
+ *
+ * You may want to see ndarray's rules for C-contiguity:
+ * https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45
+ */
+template<typename SizeT>
+bool is_c_contiguous(const NDArray<SizeT>* ndarray) {
+    // References:
+    // - tinynumpy's implementation:
+    // https://github.com/wadetb/tinynumpy/blob/0d23d22e07062ffab2afa287374c7b366eebdda1/tinynumpy/tinynumpy.py#L102
+    // - ndarray's flags["C_CONTIGUOUS"]:
+    // https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html#numpy.ndarray.flags
+    // - ndarray's rules for C-contiguity:
+    // https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45
+
+    // From
+    // https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45:
+    //
+    // The traditional rule is that for an array to be flagged as C contiguous,
+    // the following must hold:
+    //
+    // strides[-1] == itemsize
+    // strides[i] == shape[i+1] * strides[i + 1]
+    // [...]
+    // According to these rules, a 0- or 1-dimensional array is either both
+    // C- and F-contiguous, or neither; and an array with 2+ dimensions
+    // can be C- or F- contiguous, or neither, but not both. Though there
+    // there are exceptions for arrays with zero or one item, in the first
+    // case the check is relaxed up to and including the first dimension
+    // with shape[i] == 0. In the second case `strides == itemsize` will
+    // can be true for all dimensions and both flags are set.
+
+    if (ndarray->ndims == 0) {
+        return true;
+    }
+
+    if (ndarray->strides[ndarray->ndims - 1] != ndarray->itemsize) {
+        return false;
+    }
+
+    for (SizeT i = 1; i < ndarray->ndims; i++) {
+        SizeT axis_i = ndarray->ndims - i - 1;
+        if (ndarray->strides[axis_i] != ndarray->shape[axis_i + 1] * ndarray->strides[axis_i + 1]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * @brief Return the pointer to the element indexed by `indices` along the ndarray's axes.
+ *
+ * This function does no bound check.
+ */
+template<typename SizeT>
+uint8_t* get_pelement_by_indices(const NDArray<SizeT>* ndarray, const SizeT* indices) {
+    uint8_t* element = ndarray->data;
+    for (SizeT dim_i = 0; dim_i < ndarray->ndims; dim_i++)
+        element += indices[dim_i] * ndarray->strides[dim_i];
+    return element;
+}
+
+/**
+ * @brief Return the pointer to the nth (0-based) element of `ndarray` in flattened view.
+ *
+ * This function does no bound check.
+ */
+template<typename SizeT>
+uint8_t* get_nth_pelement(const NDArray<SizeT>* ndarray, SizeT nth) {
+    uint8_t* element = ndarray->data;
+    for (SizeT i = 0; i < ndarray->ndims; i++) {
+        SizeT axis = ndarray->ndims - i - 1;
+        SizeT dim = ndarray->shape[axis];
+        element += ndarray->strides[axis] * (nth % dim);
+        nth /= dim;
+    }
+    return element;
+}
+
+/**
+ * @brief Update the strides of an ndarray given an ndarray `shape` to be contiguous.
+ *
+ * You might want to read https://ajcr.net/stride-guide-part-1/.
+ */
+template<typename SizeT>
+void set_strides_by_shape(NDArray<SizeT>* ndarray) {
+    SizeT stride_product = 1;
+    for (SizeT i = 0; i < ndarray->ndims; i++) {
+        SizeT axis = ndarray->ndims - i - 1;
+        ndarray->strides[axis] = stride_product * ndarray->itemsize;
+        stride_product *= ndarray->shape[axis];
+    }
+}
+
+/**
+ * @brief Set an element in `ndarray`.
+ *
+ * @param pelement Pointer to the element in `ndarray` to be set.
+ * @param pvalue Pointer to the value `pelement` will be set to.
+ */
+template<typename SizeT>
+void set_pelement_value(NDArray<SizeT>* ndarray, uint8_t* pelement, const uint8_t* pvalue) {
+    __builtin_memcpy(pelement, pvalue, ndarray->itemsize);
+}
+
+/**
+ * @brief Copy data from one ndarray to another of the exact same size and itemsize.
+ *
+ * Both ndarrays will be viewed in their flatten views when copying the elements.
+ */
+template<typename SizeT>
+void copy_data(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray) {
+    // TODO: Make this faster with memcpy when we see a contiguous segment.
+    // TODO: Handle overlapping.
+
+    debug_assert_eq(SizeT, src_ndarray->itemsize, dst_ndarray->itemsize);
+
+    for (SizeT i = 0; i < size(src_ndarray); i++) {
+        auto src_element = ndarray::basic::get_nth_pelement(src_ndarray, i);
+        auto dst_element = ndarray::basic::get_nth_pelement(dst_ndarray, i);
+        ndarray::basic::set_pelement_value(dst_ndarray, dst_element, src_element);
+    }
+}
+}  // namespace basic
+}  // namespace ndarray
+}  // namespace
+
+extern "C" {
+using namespace ndarray::basic;
+
+void __nac3_ndarray_util_assert_shape_no_negative(int32_t ndims, int32_t* shape) {
+    assert_shape_no_negative(ndims, shape);
+}
+
+void __nac3_ndarray_util_assert_shape_no_negative64(int64_t ndims, int64_t* shape) {
+    assert_shape_no_negative(ndims, shape);
+}
+
+void __nac3_ndarray_util_assert_output_shape_same(int32_t ndarray_ndims,
+                                                  const int32_t* ndarray_shape,
+                                                  int32_t output_ndims,
+                                                  const int32_t* output_shape) {
+    assert_output_shape_same(ndarray_ndims, ndarray_shape, output_ndims, output_shape);
+}
+
+void __nac3_ndarray_util_assert_output_shape_same64(int64_t ndarray_ndims,
+                                                    const int64_t* ndarray_shape,
+                                                    int64_t output_ndims,
+                                                    const int64_t* output_shape) {
+    assert_output_shape_same(ndarray_ndims, ndarray_shape, output_ndims, output_shape);
+}
+
+uint32_t __nac3_ndarray_size(NDArray<int32_t>* ndarray) {
+    return size(ndarray);
+}
+
+uint64_t __nac3_ndarray_size64(NDArray<int64_t>* ndarray) {
+    return size(ndarray);
+}
+
+uint32_t __nac3_ndarray_nbytes(NDArray<int32_t>* ndarray) {
+    return nbytes(ndarray);
+}
+
+uint64_t __nac3_ndarray_nbytes64(NDArray<int64_t>* ndarray) {
+    return nbytes(ndarray);
+}
+
+int32_t __nac3_ndarray_len(NDArray<int32_t>* ndarray) {
+    return len(ndarray);
+}
+
+int64_t __nac3_ndarray_len64(NDArray<int64_t>* ndarray) {
+    return len(ndarray);
+}
+
+bool __nac3_ndarray_is_c_contiguous(NDArray<int32_t>* ndarray) {
+    return is_c_contiguous(ndarray);
+}
+
+bool __nac3_ndarray_is_c_contiguous64(NDArray<int64_t>* ndarray) {
+    return is_c_contiguous(ndarray);
+}
+
+uint8_t* __nac3_ndarray_get_nth_pelement(const NDArray<int32_t>* ndarray, int32_t nth) {
+    return get_nth_pelement(ndarray, nth);
+}
+
+uint8_t* __nac3_ndarray_get_nth_pelement64(const NDArray<int64_t>* ndarray, int64_t nth) {
+    return get_nth_pelement(ndarray, nth);
+}
+
+uint8_t* __nac3_ndarray_get_pelement_by_indices(const NDArray<int32_t>* ndarray, int32_t* indices) {
+    return get_pelement_by_indices(ndarray, indices);
+}
+
+uint8_t* __nac3_ndarray_get_pelement_by_indices64(const NDArray<int64_t>* ndarray, int64_t* indices) {
+    return get_pelement_by_indices(ndarray, indices);
+}
+
+void __nac3_ndarray_set_strides_by_shape(NDArray<int32_t>* ndarray) {
+    set_strides_by_shape(ndarray);
+}
+
+void __nac3_ndarray_set_strides_by_shape64(NDArray<int64_t>* ndarray) {
+    set_strides_by_shape(ndarray);
+}
+
+void __nac3_ndarray_copy_data(NDArray<int32_t>* src_ndarray, NDArray<int32_t>* dst_ndarray) {
+    copy_data(src_ndarray, dst_ndarray);
+}
+
+void __nac3_ndarray_copy_data64(NDArray<int64_t>* src_ndarray, NDArray<int64_t>* dst_ndarray) {
+    copy_data(src_ndarray, dst_ndarray);
+}
+}
--- a/nac3core/irrt/irrt/ndarray/def.hpp
+++ b/nac3core/irrt/irrt/ndarray/def.hpp
@ -0,0 +1,45 @@
+#pragma once
+
+#include "irrt/int_types.hpp"
+
+namespace {
+/**
+ * @brief The NDArray object
+ *
+ * Official numpy implementation:
+ * https://github.com/numpy/numpy/blob/735a477f0bc2b5b84d0e72d92f224bde78d4e069/doc/source/reference/c-api/types-and-structures.rst
+ */
+template<typename SizeT>
+struct NDArray {
+    /**
+     * @brief The underlying data this `ndarray` is pointing to.
+     */
+    uint8_t* data;
+
+    /**
+     * @brief The number of bytes of a single element in `data`.
+     */
+    SizeT itemsize;
+
+    /**
+     * @brief The number of dimensions of this shape.
+     */
+    SizeT ndims;
+
+    /**
+     * @brief The NDArray shape, with length equal to `ndims`.
+     *
+     * Note that it may contain 0.
+     */
+    SizeT* shape;
+
+    /**
+     * @brief Array strides, with length equal to `ndims`
+     *
+     * The stride values are in units of bytes, not number of elements.
+     *
+     * Note that `strides` can have negative values or contain 0.
+     */
+    SizeT* strides;
+};
+}  // namespace
--- a/nac3core/irrt/irrt/ndarray/iter.hpp
+++ b/nac3core/irrt/irrt/ndarray/iter.hpp
@ -0,0 +1,146 @@
+#pragma once
+
+#include "irrt/int_types.hpp"
+#include "irrt/ndarray/def.hpp"
+
+namespace {
+/**
+ * @brief Helper struct to enumerate through an ndarray *efficiently*.
+ *
+ * Example usage (in pseudo-code):
+ * ```
+ * // Suppose my_ndarray has been initialized, with shape [2, 3] and dtype `double`
+ * NDIter nditer;
+ * nditer.initialize(my_ndarray);
+ * while (nditer.has_element()) {
+ *    // This body is run 6 (= my_ndarray.size) times.
+ *
+ *    // [0, 0] -> [0, 1] -> [0, 2] -> [1, 0] -> [1, 1] -> [1, 2] -> end
+ *    print(nditer.indices);
+ *
+ *    // 0 -> 1 -> 2 -> 3 -> 4 -> 5
+ *    print(nditer.nth);
+ *
+ *    // <1st element> -> <2nd element> -> ... -> <6th element> -> end
+ *    print(*((double *) nditer.element))
+ *
+ *    nditer.next(); // Go to next element.
+ * }
+ * ```
+ *
+ * Interesting cases:
+ * - If `my_ndarray.ndims` == 0, there is one iteration.
+ * - If `my_ndarray.shape` contains zeroes, there are no iterations.
+ */
+template<typename SizeT>
+struct NDIter {
+    // Information about the ndarray being iterated over.
+    SizeT ndims;
+    SizeT* shape;
+    SizeT* strides;
+
+    /**
+     * @brief The current indices.
+     *
+     * Must be allocated by the caller.
+     */
+    SizeT* indices;
+
+    /**
+     * @brief The nth (0-based) index of the current indices.
+     *
+     * Initially this is 0.
+     */
+    SizeT nth;
+
+    /**
+     * @brief Pointer to the current element.
+     *
+     * Initially this points to first element of the ndarray.
+     */
+    uint8_t* element;
+
+    /**
+     * @brief Cache for the product of shape.
+     *
+     * Could be 0 if `shape` has 0s in it.
+     */
+    SizeT size;
+
+    void initialize(SizeT ndims, SizeT* shape, SizeT* strides, uint8_t* element, SizeT* indices) {
+        this->ndims = ndims;
+        this->shape = shape;
+        this->strides = strides;
+
+        this->indices = indices;
+        this->element = element;
+
+        // Compute size
+        this->size = 1;
+        for (SizeT i = 0; i < ndims; i++) {
+            this->size *= shape[i];
+        }
+
+        // `indices` starts on all 0s.
+        for (SizeT axis = 0; axis < ndims; axis++)
+            indices[axis] = 0;
+        nth = 0;
+    }
+
+    void initialize_by_ndarray(NDArray<SizeT>* ndarray, SizeT* indices) {
+        // NOTE: ndarray->data is pointing to the first element, and `NDIter`'s `element` should also point to the first
+        // element as well.
+        this->initialize(ndarray->ndims, ndarray->shape, ndarray->strides, ndarray->data, indices);
+    }
+
+    // Is the current iteration valid?
+    // If true, then `element`, `indices` and `nth` contain details about the current element.
+    bool has_element() { return nth < size; }
+
+    // Go to the next element.
+    void next() {
+        for (SizeT i = 0; i < ndims; i++) {
+            SizeT axis = ndims - i - 1;
+            indices[axis]++;
+            if (indices[axis] >= shape[axis]) {
+                indices[axis] = 0;
+
+                // TODO: There is something called backstrides to speedup iteration.
+                // See https://ajcr.net/stride-guide-part-1/, and
+                // https://docs.scipy.org/doc/numpy-1.13.0/reference/c-api.types-and-structures.html#c.PyArrayIterObject.PyArrayIterObject.backstrides.
+                element -= strides[axis] * (shape[axis] - 1);
+            } else {
+                element += strides[axis];
+                break;
+            }
+        }
+        nth++;
+    }
+};
+}  // namespace
+
+extern "C" {
+void __nac3_nditer_initialize(NDIter<int32_t>* iter, NDArray<int32_t>* ndarray, int32_t* indices) {
+    iter->initialize_by_ndarray(ndarray, indices);
+}
+
+void __nac3_nditer_initialize64(NDIter<int64_t>* iter, NDArray<int64_t>* ndarray, int64_t* indices) {
+    iter->initialize_by_ndarray(ndarray, indices);
+}
+
+bool __nac3_nditer_has_element(NDIter<int32_t>* iter) {
+    return iter->has_element();
+}
+
+bool __nac3_nditer_has_element64(NDIter<int64_t>* iter) {
+    return iter->has_element();
+}
+
+void __nac3_nditer_next(NDIter<int32_t>* iter) {
+    iter->next();
+}
+
+void __nac3_nditer_next64(NDIter<int64_t>* iter) {
+    iter->next();
+}
+}
--- a/nac3core/src/codegen/builtin_fns.rs
+++ b/nac3core/src/codegen/builtin_fns.rs
@ -1,21 +1,33 @@
-use inkwell::types::BasicTypeEnum;
-use inkwell::values::{BasicValue, BasicValueEnum, IntValue, PointerValue};
-use inkwell::{FloatPredicate, IntPredicate, OptimizationLevel};
+use inkwell::{
+    types::BasicTypeEnum,
+    values::{BasicValue, BasicValueEnum, IntValue, PointerValue},
+    FloatPredicate, IntPredicate, OptimizationLevel,
+};
 use itertools::Itertools;

-use crate::codegen::classes::{
-    ArrayLikeValue, NDArrayValue, ProxyValue, RangeValue, TypedArrayLikeAccessor,
-    UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
+use super::{
+    model::*,
+    object::{any::AnyObject, list::ListObject, ndarray::NDArrayObject, tuple::TupleObject},
+};
+use crate::{
+    codegen::{
+        classes::{
+            NDArrayValue, ProxyValue, RangeValue, UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
+        },
+        expr::destructure_range,
+        extern_fns, irrt,
+        irrt::calculate_len_for_slice_range,
+        llvm_intrinsics,
+        macros::codegen_unreachable,
+        numpy,
+        numpy::ndarray_elementwise_unaryop_impl,
+        stmt::gen_for_callback_incrementing,
+        CodeGenContext, CodeGenerator,
+    },
+    toplevel::helper::PrimDef,
+    toplevel::numpy::unpack_ndarray_var_tys,
+    typecheck::typedef::{Type, TypeEnum},
 };
-use crate::codegen::expr::destructure_range;
-use crate::codegen::irrt::calculate_len_for_slice_range;
-use crate::codegen::macros::codegen_unreachable;
-use crate::codegen::numpy::ndarray_elementwise_unaryop_impl;
-use crate::codegen::stmt::gen_for_callback_incrementing;
-use crate::codegen::{extern_fns, irrt, llvm_intrinsics, numpy, CodeGenContext, CodeGenerator};
-use crate::toplevel::helper::PrimDef;
-use crate::toplevel::numpy::unpack_ndarray_var_tys;
-use crate::typecheck::typedef::{Type, TypeEnum};

 /// Shorthand for [`unreachable!()`] when a type of argument is not supported.
 ///
@ -34,58 +46,33 @@ pub fn call_len<'ctx, G: CodeGenerator + ?Sized>(
    ctx: &mut CodeGenContext<'ctx, '_>,
    n: (Type, BasicValueEnum<'ctx>),
 ) -> Result<IntValue<'ctx>, String> {
-    let llvm_i32 = ctx.ctx.i32_type();
-    let range_ty = ctx.primitives.range;
    let (arg_ty, arg) = n;
-
-    Ok(if ctx.unifier.unioned(arg_ty, range_ty) {
+    Ok(if ctx.unifier.unioned(arg_ty, ctx.primitives.range) {
        let arg = RangeValue::from_ptr_val(arg.into_pointer_value(), Some("range"));
        let (start, end, step) = destructure_range(ctx, arg);
        calculate_len_for_slice_range(generator, ctx, start, end, step)
    } else {
-        match &*ctx.unifier.get_ty_immutable(arg_ty) {
-            TypeEnum::TTuple { ty, .. } => llvm_i32.const_int(ty.len() as u64, false),
-            TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::List.id() => {
-                let zero = llvm_i32.const_zero();
-                let len = ctx
-                    .build_gep_and_load(
-                        arg.into_pointer_value(),
-                        &[zero, llvm_i32.const_int(1, false)],
-                        None,
-                    )
-                    .into_int_value();
-                ctx.builder.build_int_truncate_or_bit_cast(len, llvm_i32, "len").unwrap()
+        let arg = AnyObject { ty: arg_ty, value: arg };
+        let len: Instance<'ctx, Int<Int32>> = match &*ctx.unifier.get_ty(arg_ty) {
+            TypeEnum::TTuple { .. } => {
+                let tuple = TupleObject::from_object(ctx, arg);
+                tuple.len(generator, ctx).truncate_or_bit_cast(generator, ctx, Int32)
            }
-            TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
-                let llvm_usize = generator.get_size_type(ctx.ctx);
-
-                let arg = NDArrayValue::from_ptr_val(arg.into_pointer_value(), llvm_usize, None);
-
-                let ndims = arg.dim_sizes().size(ctx, generator);
-                ctx.make_assert(
-                    generator,
-                    ctx.builder
-                        .build_int_compare(IntPredicate::NE, ndims, llvm_usize.const_zero(), "")
-                        .unwrap(),
-                    "0:TypeError",
-                    "len() of unsized object",
-                    [None, None, None],
-                    ctx.current_loc,
-                );
-
-                let len = unsafe {
-                    arg.dim_sizes().get_typed_unchecked(
-                        ctx,
-                        generator,
-                        &llvm_usize.const_zero(),
-                        None,
-                    )
+            TypeEnum::TObj { obj_id, .. }
+                if *obj_id == ctx.primitives.ndarray.obj_id(&ctx.unifier).unwrap() =>
+            {
+                let ndarray = NDArrayObject::from_object(generator, ctx, arg);
+                ndarray.len(generator, ctx).truncate_or_bit_cast(generator, ctx, Int32)
+            }
+            TypeEnum::TObj { obj_id, .. }
+                if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
+            {
+                let list = ListObject::from_object(generator, ctx, arg);
+                list.len(generator, ctx).truncate_or_bit_cast(generator, ctx, Int32)
+            }
+            _ => unsupported_type(ctx, "len", &[arg_ty]),
        };
-
-                ctx.builder.build_int_truncate_or_bit_cast(len, llvm_i32, "len").unwrap()
-            }
-            _ => codegen_unreachable!(ctx),
-        }
+        len.value
    })
 }

--- a/nac3core/src/codegen/classes.rs
+++ b/nac3core/src/codegen/classes.rs
@ -1,17 +1,16 @@
+use inkwell::{
+    context::Context,
+    types::{AnyTypeEnum, ArrayType, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
+    values::{ArrayValue, BasicValue, BasicValueEnum, IntValue, PointerValue, StructValue},
+    AddressSpace, IntPredicate,
+};
+
 use crate::codegen::{
    irrt::{call_ndarray_calc_size, call_ndarray_flatten_index},
    llvm_intrinsics::call_int_umin,
    stmt::gen_for_callback_incrementing,
    CodeGenContext, CodeGenerator,
 };
-use inkwell::context::Context;
-use inkwell::types::{ArrayType, BasicType, StructType};
-use inkwell::values::{ArrayValue, BasicValue, StructValue};
-use inkwell::{
-    types::{AnyTypeEnum, BasicTypeEnum, IntType, PointerType},
-    values::{BasicValueEnum, IntValue, PointerValue},
-    AddressSpace, IntPredicate,
-};

 /// A LLVM type that is used to represent a non-primitive type in NAC3.
 pub trait ProxyType<'ctx>: Into<Self::Base> {
@ -1250,11 +1249,13 @@ impl<'ctx> NDArrayType<'ctx> {

    /// Returns the element type of this `ndarray` type.
    #[must_use]
-    pub fn element_type(&self) -> BasicTypeEnum<'ctx> {
+    pub fn element_type(&self) -> AnyTypeEnum<'ctx> {
        self.as_base_type()
            .get_element_type()
            .into_struct_type()
            .get_field_type_at_index(2)
+            .map(BasicTypeEnum::into_pointer_type)
+            .map(PointerType::get_element_type)
            .unwrap()
    }
 }
--- a/nac3core/src/codegen/concrete_type.rs
+++ b/nac3core/src/codegen/concrete_type.rs
@ -1,3 +1,9 @@
+use std::collections::HashMap;
+
+use indexmap::IndexMap;
+
+use nac3parser::ast::StrRef;
+
 use crate::{
    symbol_resolver::SymbolValue,
    toplevel::DefinitionId,
@ -9,10 +15,6 @@ use crate::{
    },
 };

-use indexmap::IndexMap;
-use nac3parser::ast::StrRef;
-use std::collections::HashMap;
-
 pub struct ConcreteTypeStore {
    store: Vec<ConcreteTypeEnum>,
 }
--- a/nac3core/src/codegen/expr.rs
+++ b/nac3core/src/codegen/expr.rs
@ -1,3 +1,23 @@
+use std::{
+    cmp::min,
+    collections::HashMap,
+    convert::TryInto,
+    iter::{once, repeat, repeat_with, zip},
+};
+
+use inkwell::{
+    attributes::{Attribute, AttributeLoc},
+    types::{AnyType, BasicType, BasicTypeEnum},
+    values::{BasicValueEnum, CallSiteValue, FunctionValue, IntValue, PointerValue, StructValue},
+    AddressSpace, IntPredicate, OptimizationLevel,
+};
+use itertools::{chain, izip, Either, Itertools};
+
+use nac3parser::ast::{
+    self, Boolop, Cmpop, Comprehension, Constant, Expr, ExprKind, Location, Operator, StrRef,
+    Unaryop,
+};
+
 use crate::{
    codegen::{
        classes::{
@ -30,20 +50,6 @@ use crate::{
        typedef::{FunSignature, FuncArg, Type, TypeEnum, TypeVarId, Unifier, VarMap},
    },
 };
-use inkwell::{
-    attributes::{Attribute, AttributeLoc},
-    types::{AnyType, BasicType, BasicTypeEnum},
-    values::{BasicValueEnum, CallSiteValue, FunctionValue, IntValue, PointerValue, StructValue},
-    AddressSpace, IntPredicate, OptimizationLevel,
-};
-use itertools::{chain, izip, Either, Itertools};
-use nac3parser::ast::{
-    self, Boolop, Cmpop, Comprehension, Constant, Expr, ExprKind, Location, Operator, StrRef,
-    Unaryop,
-};
-use std::cmp::min;
-use std::iter::{repeat, repeat_with};
-use std::{collections::HashMap, convert::TryInto, iter::once, iter::zip};

 pub fn get_subst_key(
    unifier: &mut Unifier,
@ -551,7 +557,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
                            && val_ty.get_element_type().is_struct_type()
                    } =>
                {
-                    self.builder.build_bitcast(*val, arg_ty, "call_arg_cast").unwrap()
+                    self.builder.build_bit_cast(*val, arg_ty, "call_arg_cast").unwrap()
                }
                _ => *val,
            })
@ -971,6 +977,7 @@ pub fn gen_call<'ctx, G: CodeGenerator>(
            TopLevelDef::Class { .. } => {
                return Ok(Some(generator.gen_constructor(ctx, fun.0, &def, params)?))
            }
+            TopLevelDef::Variable { .. } => unreachable!(),
        }
    }
    .or_else(|_: String| {
@ -2879,7 +2886,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
            Some((_, Some(static_value), _)) => ValueEnum::Static(static_value.clone()),
            None => {
                let resolver = ctx.resolver.clone();
-                resolver.get_symbol_value(*id, ctx).unwrap()
+                resolver.get_symbol_value(*id, ctx, generator).unwrap()
            }
        },
        ExprKind::List { elts, .. } => {
--- a/nac3core/src/codegen/extern_fns.rs
+++ b/nac3core/src/codegen/extern_fns.rs
@ -1,5 +1,7 @@
-use inkwell::attributes::{Attribute, AttributeLoc};
-use inkwell::values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue};
+use inkwell::{
+    attributes::{Attribute, AttributeLoc},
+    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue},
+};
 use itertools::Either;

 use crate::codegen::CodeGenContext;
--- a/nac3core/src/codegen/generator.rs
+++ b/nac3core/src/codegen/generator.rs
@ -1,15 +1,17 @@
+use inkwell::{
+    context::Context,
+    types::{BasicTypeEnum, IntType},
+    values::{BasicValueEnum, IntValue, PointerValue},
+};
+
+use nac3parser::ast::{Expr, Stmt, StrRef};
+
 use crate::{
    codegen::{bool_to_i1, bool_to_i8, classes::ArraySliceValue, expr::*, stmt::*, CodeGenContext},
    symbol_resolver::ValueEnum,
    toplevel::{DefinitionId, TopLevelDef},
    typecheck::typedef::{FunSignature, Type},
 };
-use inkwell::{
-    context::Context,
-    types::{BasicTypeEnum, IntType},
-    values::{BasicValueEnum, IntValue, PointerValue},
-};
-use nac3parser::ast::{Expr, Stmt, StrRef};

 pub trait CodeGenerator {
    /// Return the module name for the code generator.
--- a/nac3core/src/codegen/irrt/mod.rs
+++ b/nac3core/src/codegen/irrt/mod.rs
@ -1,15 +1,3 @@
-use crate::{symbol_resolver::SymbolResolver, typecheck::typedef::Type};
-
-use super::{
-    classes::{
-        ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ListValue, NDArrayValue,
-        TypedArrayLikeAccessor, TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
-    },
-    llvm_intrinsics,
-    macros::codegen_unreachable,
-    stmt::gen_for_callback_incrementing,
-    CodeGenContext, CodeGenerator,
-};
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
    context::Context,
@ -20,8 +8,24 @@ use inkwell::{
    AddressSpace, IntPredicate,
 };
 use itertools::Either;
+
 use nac3parser::ast::Expr;

+use super::{
+    classes::{
+        ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ListValue, NDArrayValue,
+        TypedArrayLikeAccessor, TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
+    },
+    llvm_intrinsics,
+    macros::codegen_unreachable,
+    model::*,
+    object::ndarray::{nditer::NDIter, NDArray},
+    stmt::gen_for_callback_incrementing,
+    CodeGenContext, CodeGenerator,
+};
+use crate::{symbol_resolver::SymbolResolver, typecheck::typedef::Type};
+use function::FnCall;
+
 #[must_use]
 pub fn load_irrt<'ctx>(ctx: &'ctx Context, symbol_resolver: &dyn SymbolResolver) -> Module<'ctx> {
    let bitcode_buf = MemoryBuffer::create_from_memory_range(
@ -949,3 +953,163 @@ pub fn call_ndarray_calc_broadcast_index<
        Box::new(|_, v| v.into()),
    )
 }
+
+// When [`TypeContext::size_type`] is 32-bits, the function name is "{fn_name}".
+// When [`TypeContext::size_type`] is 64-bits, the function name is "{fn_name}64".
+#[must_use]
+pub fn get_sizet_dependent_function_name<G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &CodeGenContext<'_, '_>,
+    name: &str,
+) -> String {
+    let mut name = name.to_owned();
+    match generator.get_size_type(ctx.ctx).get_bit_width() {
+        32 => {}
+        64 => name.push_str("64"),
+        bit_width => {
+            panic!("Unsupported int type bit width {bit_width}, must be either 32-bits or 64-bits")
+        }
+    }
+    name
+}
+
+pub fn call_nac3_ndarray_util_assert_shape_no_negative<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndims: Instance<'ctx, Int<SizeT>>,
+    shape: Instance<'ctx, Ptr<Int<SizeT>>>,
+) {
+    let name = get_sizet_dependent_function_name(
+        generator,
+        ctx,
+        "__nac3_ndarray_util_assert_shape_no_negative",
+    );
+    FnCall::builder(generator, ctx, &name).arg(ndims).arg(shape).returning_void();
+}
+
+pub fn call_nac3_ndarray_util_assert_output_shape_same<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray_ndims: Instance<'ctx, Int<SizeT>>,
+    ndarray_shape: Instance<'ctx, Ptr<Int<SizeT>>>,
+    output_ndims: Instance<'ctx, Int<SizeT>>,
+    output_shape: Instance<'ctx, Ptr<Int<SizeT>>>,
+) {
+    let name = get_sizet_dependent_function_name(
+        generator,
+        ctx,
+        "__nac3_ndarray_util_assert_output_shape_same",
+    );
+    FnCall::builder(generator, ctx, &name)
+        .arg(ndarray_ndims)
+        .arg(ndarray_shape)
+        .arg(output_ndims)
+        .arg(output_shape)
+        .returning_void();
+}
+
+pub fn call_nac3_ndarray_size<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
+) -> Instance<'ctx, Int<SizeT>> {
+    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_size");
+    FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("size")
+}
+
+pub fn call_nac3_ndarray_nbytes<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
+) -> Instance<'ctx, Int<SizeT>> {
+    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_nbytes");
+    FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("nbytes")
+}
+
+pub fn call_nac3_ndarray_len<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
+) -> Instance<'ctx, Int<SizeT>> {
+    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_len");
+    FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("len")
+}
+
+pub fn call_nac3_ndarray_is_c_contiguous<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
+) -> Instance<'ctx, Int<Bool>> {
+    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_is_c_contiguous");
+    FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("is_c_contiguous")
+}
+
+pub fn call_nac3_ndarray_get_nth_pelement<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
+    index: Instance<'ctx, Int<SizeT>>,
+) -> Instance<'ctx, Ptr<Int<Byte>>> {
+    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_get_nth_pelement");
+    FnCall::builder(generator, ctx, &name).arg(ndarray).arg(index).returning_auto("pelement")
+}
+
+pub fn call_nac3_ndarray_get_pelement_by_indices<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
+    indices: Instance<'ctx, Ptr<Int<SizeT>>>,
+) -> Instance<'ctx, Ptr<Int<Byte>>> {
+    let name =
+        get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_get_pelement_by_indices");
+    FnCall::builder(generator, ctx, &name).arg(ndarray).arg(indices).returning_auto("pelement")
+}
+
+pub fn call_nac3_ndarray_set_strides_by_shape<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
+) {
+    let name =
+        get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_set_strides_by_shape");
+    FnCall::builder(generator, ctx, &name).arg(ndarray).returning_void();
+}
+
+pub fn call_nac3_ndarray_copy_data<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    src_ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
+    dst_ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
+) {
+    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_copy_data");
+    FnCall::builder(generator, ctx, &name).arg(src_ndarray).arg(dst_ndarray).returning_void();
+}
+
+pub fn call_nac3_nditer_initialize<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    iter: Instance<'ctx, Ptr<Struct<NDIter>>>,
+    ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
+    indices: Instance<'ctx, Ptr<Int<SizeT>>>,
+) {
+    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_nditer_initialize");
+    FnCall::builder(generator, ctx, &name).arg(iter).arg(ndarray).arg(indices).returning_void();
+}
+
+pub fn call_nac3_nditer_has_element<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    iter: Instance<'ctx, Ptr<Struct<NDIter>>>,
+) -> Instance<'ctx, Int<Bool>> {
+    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_nditer_has_element");
+    FnCall::builder(generator, ctx, &name).arg(iter).returning_auto("has_element")
+}
+
+pub fn call_nac3_nditer_next<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    iter: Instance<'ctx, Ptr<Struct<NDIter>>>,
+) {
+    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_nditer_next");
+    FnCall::builder(generator, ctx, &name).arg(iter).returning_void();
+}
--- a/nac3core/src/codegen/llvm_intrinsics.rs
+++ b/nac3core/src/codegen/llvm_intrinsics.rs
@ -1,12 +1,14 @@
-use crate::codegen::CodeGenContext;
-use inkwell::context::Context;
-use inkwell::intrinsics::Intrinsic;
-use inkwell::types::AnyTypeEnum::IntType;
-use inkwell::types::FloatType;
-use inkwell::values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, PointerValue};
-use inkwell::AddressSpace;
+use inkwell::{
+    context::Context,
+    intrinsics::Intrinsic,
+    types::{AnyTypeEnum::IntType, FloatType},
+    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, PointerValue},
+    AddressSpace,
+};
 use itertools::Either;

+use crate::codegen::CodeGenContext;
+
 /// Returns the string representation for the floating-point type `ft` when used in intrinsic
 /// functions.
 fn get_float_intrinsic_repr(ctx: &Context, ft: FloatType) -> &'static str {
@ -183,7 +185,7 @@ pub fn call_memcpy_generic<'ctx>(
        dest
    } else {
        ctx.builder
-            .build_bitcast(dest, llvm_p0i8, "")
+            .build_bit_cast(dest, llvm_p0i8, "")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap()
    };
@ -191,7 +193,7 @@ pub fn call_memcpy_generic<'ctx>(
        src
    } else {
        ctx.builder
-            .build_bitcast(src, llvm_p0i8, "")
+            .build_bit_cast(src, llvm_p0i8, "")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap()
    };
--- a/nac3core/src/codegen/mod.rs
+++ b/nac3core/src/codegen/mod.rs
@ -1,12 +1,12 @@
-use crate::{
-    codegen::classes::{ListType, NDArrayType, ProxyType, RangeType},
-    symbol_resolver::{StaticValue, SymbolResolver},
-    toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, TopLevelContext, TopLevelDef},
-    typecheck::{
-        type_inferencer::{CodeLocation, PrimitiveStore},
-        typedef::{CallId, FuncArg, Type, TypeEnum, Unifier},
+use std::{
+    collections::{HashMap, HashSet},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
    },
+    thread,
 };
+
 use crossbeam::channel::{unbounded, Receiver, Sender};
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
@ -24,14 +24,21 @@ use inkwell::{
    AddressSpace, IntPredicate, OptimizationLevel,
 };
 use itertools::Itertools;
-use nac3parser::ast::{Location, Stmt, StrRef};
 use parking_lot::{Condvar, Mutex};
-use std::collections::{HashMap, HashSet};
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
+
+use nac3parser::ast::{Location, Stmt, StrRef};
+
+use crate::{
+    codegen::classes::{ListType, ProxyType, RangeType},
+    symbol_resolver::{StaticValue, SymbolResolver},
+    toplevel::{helper::PrimDef, TopLevelContext, TopLevelDef},
+    typecheck::{
+        type_inferencer::{CodeLocation, PrimitiveStore},
+        typedef::{CallId, FuncArg, Type, TypeEnum, Unifier},
+    },
 };
-use std::thread;
+use model::*;
+use object::ndarray::NDArray;

 pub mod builtin_fns;
 pub mod classes;
@ -41,7 +48,9 @@ pub mod extern_fns;
 mod generator;
 pub mod irrt;
 pub mod llvm_intrinsics;
+pub mod model;
 pub mod numpy;
+pub mod object;
 pub mod stmt;

 #[cfg(test)]
@ -505,12 +514,7 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                        }

                        TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
-                            let (dtype, _) = unpack_ndarray_var_tys(unifier, ty);
-                            let element_type = get_llvm_type(
-                                ctx, module, generator, unifier, top_level, type_cache, dtype,
-                            );
-
-                            NDArrayType::new(generator, ctx, element_type).as_base_type().into()
+                            Ptr(Struct(NDArray)).llvm_type(generator, ctx).as_basic_type_enum()
                        }

                        _ => unreachable!(
@ -848,10 +852,9 @@ pub fn gen_func_impl<
    builder.position_at_end(init_bb);
    let body_bb = context.append_basic_block(fn_val, "body");

+    // Store non-vararg argument values into local variables
    let mut var_assignment = HashMap::new();
    let offset = u32::from(has_sret);
-
-    // Store non-vararg argument values into local variables
    for (n, arg) in args.iter().enumerate().filter(|(_, arg)| !arg.is_vararg) {
        let param = fn_val.get_nth_param((n as u32) + offset).unwrap();
        let local_type = get_llvm_type(
--- a/nac3core/src/codegen/model/any.rs
+++ b/nac3core/src/codegen/model/any.rs
@ -0,0 +1,41 @@
+use inkwell::{
+    context::Context,
+    types::{BasicType, BasicTypeEnum},
+    values::BasicValueEnum,
+};
+
+use super::*;
+use crate::codegen::CodeGenerator;
+
+/// A [`Model`] of any [`BasicTypeEnum`].
+///
+/// Use this when it is infeasible to use model abstractions.
+#[derive(Debug, Clone, Copy)]
+pub struct Any<'ctx>(pub BasicTypeEnum<'ctx>);
+
+impl<'ctx> Model<'ctx> for Any<'ctx> {
+    type Value = BasicValueEnum<'ctx>;
+    type Type = BasicTypeEnum<'ctx>;
+
+    fn llvm_type<G: CodeGenerator + ?Sized>(
+        &self,
+        _generator: &G,
+        _ctx: &'ctx Context,
+    ) -> Self::Type {
+        self.0
+    }
+
+    fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        _generator: &mut G,
+        _ctx: &'ctx Context,
+        ty: T,
+    ) -> Result<(), ModelError> {
+        let ty = ty.as_basic_type_enum();
+        if ty == self.0 {
+            Ok(())
+        } else {
+            Err(ModelError(format!("Expecting {}, but got {}", self.0, ty)))
+        }
+    }
+}
--- a/nac3core/src/codegen/model/array.rs
+++ b/nac3core/src/codegen/model/array.rs
@ -0,0 +1,146 @@
+use std::fmt;
+
+use inkwell::{
+    context::Context,
+    types::{ArrayType, BasicType, BasicTypeEnum},
+    values::{ArrayValue, IntValue},
+};
+
+use super::*;
+use crate::codegen::{CodeGenContext, CodeGenerator};
+
+/// Trait for Rust structs identifying length values for [`Array`].
+pub trait ArrayLen: fmt::Debug + Clone + Copy {
+    fn length(&self) -> u32;
+}
+
+/// A statically known length.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Len<const N: u32>;
+
+/// A dynamically known length.
+#[derive(Debug, Clone, Copy)]
+pub struct AnyLen(pub u32);
+
+impl<const N: u32> ArrayLen for Len<N> {
+    fn length(&self) -> u32 {
+        N
+    }
+}
+
+impl ArrayLen for AnyLen {
+    fn length(&self) -> u32 {
+        self.0
+    }
+}
+
+/// A Model for an [`ArrayType`].
+///
+/// `Len` should be of a [`LenKind`] and `Item` should be a of [`Model`].
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Array<Len, Item> {
+    /// Length of this array.
+    pub len: Len,
+    /// [`Model`] of the array items.
+    pub item: Item,
+}
+
+impl<'ctx, Len: ArrayLen, Item: Model<'ctx>> Model<'ctx> for Array<Len, Item> {
+    type Value = ArrayValue<'ctx>;
+    type Type = ArrayType<'ctx>;
+
+    fn llvm_type<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> Self::Type {
+        self.item.llvm_type(generator, ctx).array_type(self.len.length())
+    }
+
+    fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        ty: T,
+    ) -> Result<(), ModelError> {
+        let ty = ty.as_basic_type_enum();
+        let BasicTypeEnum::ArrayType(ty) = ty else {
+            return Err(ModelError(format!("Expecting ArrayType, but got {ty:?}")));
+        };
+
+        if ty.len() != self.len.length() {
+            return Err(ModelError(format!(
+                "Expecting ArrayType with size {}, but got an ArrayType with size {}",
+                ty.len(),
+                self.len.length()
+            )));
+        }
+
+        self.item
+            .check_type(generator, ctx, ty.get_element_type())
+            .map_err(|err| err.under_context("an ArrayType"))?;
+
+        Ok(())
+    }
+}
+
+impl<'ctx, Len: ArrayLen, Item: Model<'ctx>> Instance<'ctx, Ptr<Array<Len, Item>>> {
+    /// Get the pointer to the `i`-th (0-based) array element.
+    pub fn gep(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        i: IntValue<'ctx>,
+    ) -> Instance<'ctx, Ptr<Item>> {
+        let zero = ctx.ctx.i32_type().const_zero();
+        let ptr = unsafe { ctx.builder.build_in_bounds_gep(self.value, &[zero, i], "").unwrap() };
+
+        unsafe { Ptr(self.model.0.item).believe_value(ptr) }
+    }
+
+    /// Like `gep` but `i` is a constant.
+    pub fn gep_const(&self, ctx: &CodeGenContext<'ctx, '_>, i: u64) -> Instance<'ctx, Ptr<Item>> {
+        assert!(
+            i < u64::from(self.model.0.len.length()),
+            "Index {i} is out of bounds. Array length = {}",
+            self.model.0.len.length()
+        );
+
+        let i = ctx.ctx.i32_type().const_int(i, false);
+        self.gep(ctx, i)
+    }
+
+    /// Convenience function equivalent to `.gep(...).load(...)`.
+    pub fn get<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        i: IntValue<'ctx>,
+    ) -> Instance<'ctx, Item> {
+        self.gep(ctx, i).load(generator, ctx)
+    }
+
+    /// Like `get` but `i` is a constant.
+    pub fn get_const<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        i: u64,
+    ) -> Instance<'ctx, Item> {
+        self.gep_const(ctx, i).load(generator, ctx)
+    }
+
+    /// Convenience function equivalent to `.gep(...).store(...)`.
+    pub fn set(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        i: IntValue<'ctx>,
+        value: Instance<'ctx, Item>,
+    ) {
+        self.gep(ctx, i).store(ctx, value);
+    }
+
+    /// Like `set` but `i` is a constant.
+    pub fn set_const(&self, ctx: &CodeGenContext<'ctx, '_>, i: u64, value: Instance<'ctx, Item>) {
+        self.gep_const(ctx, i).store(ctx, value);
+    }
+}
--- a/nac3core/src/codegen/model/core.rs
+++ b/nac3core/src/codegen/model/core.rs
@ -0,0 +1,207 @@
+use std::fmt;
+
+use inkwell::{context::Context, types::*, values::*};
+use itertools::Itertools;
+
+use super::*;
+use crate::codegen::{CodeGenContext, CodeGenerator};
+
+/// A error type for reporting any [`Model`]-related error (e.g., a [`BasicType`] mismatch).
+#[derive(Debug, Clone)]
+pub struct ModelError(pub String);
+
+impl ModelError {
+    /// Append a context message to the error.
+    pub(super) fn under_context(mut self, context: &str) -> Self {
+        self.0.push_str(" ... in ");
+        self.0.push_str(context);
+        self
+    }
+}
+
+/// Trait for Rust structs identifying [`BasicType`]s in the context of a known [`CodeGenerator`] and [`CodeGenContext`].
+///
+/// For instance,
+/// - [`Int<Int32>`] identifies an [`IntType`] with 32-bits.
+/// - [`Int<SizeT>`] identifies an [`IntType`] with bit-width [`CodeGenerator::get_size_type`].
+/// - [`Ptr<Int<SizeT>>`] identifies a [`PointerType`] that points to an [`IntType`] with bit-width [`CodeGenerator::get_size_type`].
+/// - [`Int<AnyInt>`] identifies an [`IntType`] with bit-width of whatever is set in the [`AnyInt`] object.
+/// - [`Any`] identifies a [`BasicType`] set in the [`Any`] object itself.
+///
+/// You can get the [`BasicType`] out of a model with [`Model::get_type`].
+///
+/// Furthermore, [`Instance<'ctx, M>`] is a simple structure that carries a [`BasicValue`] with [`BasicType`] identified by model `M`.
+///
+/// The main purpose of this abstraction is to have a more Rust type-safe way to use Inkwell and give type-hints for programmers.
+///
+/// ### Notes on `Default` trait
+///
+/// For some models like [`Int<Int32>`] or [`Int<SizeT>`], they have a [`Default`] trait since just by looking at their types, it is possible
+/// to tell the [`BasicType`]s they are identifying.
+///
+/// This can be used to create strongly-typed interfaces accepting only values of a specific [`BasicType`] without having to worry about
+/// writing debug assertions to check, for example, if the programmer has passed in an [`IntValue`] with the wrong bit-width.
+/// ```ignore
+/// fn give_me_i32_and_get_a_size_t_back<'ctx>(i32: Instance<'ctx, Int<Int32>>) -> Instance<'ctx, Int<SizeT>> {
+///     // code...
+/// }
+/// ```
+///
+/// ### Notes on converting between Inkwell and model/ge.
+///
+/// Suppose you have an [`IntValue`], and you want to pass it into a function that takes a [`Instance<'ctx, Int<Int32>>`]. You can do use
+/// [`Model::check_value`] or [`Model::believe_value`].
+/// ```ignore
+/// let my_value: IntValue<'ctx>;
+///
+/// let my_value = Int(Int32).check_value(my_value).unwrap(); // Panics if `my_value` is not 32-bit with a descriptive error message.
+///
+/// // or, if you are absolutely certain that `my_value` is 32-bit and doing extra checks is a waste of time:
+/// let my_value = Int(Int32).believe_value(my_value);
+/// ```
+pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
+    /// The [`BasicType`] *variant* this model is identifying.
+    type Type: BasicType<'ctx>;
+
+    /// The [`BasicValue`] type of the [`BasicType`] of this model.
+    type Value: BasicValue<'ctx> + TryFrom<BasicValueEnum<'ctx>>;
+
+    /// Return the [`BasicType`] of this model.
+    #[must_use]
+    fn llvm_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context)
+        -> Self::Type;
+
+    /// Get the number of bytes of the [`BasicType`] of this model.
+    fn size_of<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+    ) -> IntValue<'ctx> {
+        self.llvm_type(generator, ctx).size_of().unwrap()
+    }
+
+    /// Check if a [`BasicType`] matches the [`BasicType`] of this model.
+    fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        ty: T,
+    ) -> Result<(), ModelError>;
+
+    /// Create an instance from a value.
+    ///
+    /// # Safety
+    ///
+    /// Caller must make sure the type of `value` and the type of this `model` are equivalent.
+    #[must_use]
+    unsafe fn believe_value(&self, value: Self::Value) -> Instance<'ctx, Self> {
+        Instance { model: *self, value }
+    }
+
+    /// Check if a [`BasicValue`]'s type is equivalent to the type of this model.
+    /// Wrap the [`BasicValue`] into an [`Instance`] if it is.
+    fn check_value<V: BasicValue<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        value: V,
+    ) -> Result<Instance<'ctx, Self>, ModelError> {
+        let value = value.as_basic_value_enum();
+        self.check_type(generator, ctx, value.get_type())
+            .map_err(|err| err.under_context(format!("the value {value:?}").as_str()))?;
+
+        let Ok(value) = Self::Value::try_from(value) else {
+            unreachable!("check_type() has bad implementation")
+        };
+        unsafe { Ok(self.believe_value(value)) }
+    }
+
+    // Allocate a value on the stack and return its pointer.
+    fn alloca<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+    ) -> Instance<'ctx, Ptr<Self>> {
+        let p = ctx.builder.build_alloca(self.llvm_type(generator, ctx.ctx), "").unwrap();
+        unsafe { Ptr(*self).believe_value(p) }
+    }
+
+    // Allocate an array on the stack and return its pointer.
+    fn array_alloca<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        len: IntValue<'ctx>,
+    ) -> Instance<'ctx, Ptr<Self>> {
+        let p =
+            ctx.builder.build_array_alloca(self.llvm_type(generator, ctx.ctx), len, "").unwrap();
+        unsafe { Ptr(*self).believe_value(p) }
+    }
+
+    fn var_alloca<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&str>,
+    ) -> Result<Instance<'ctx, Ptr<Self>>, String> {
+        let ty = self.llvm_type(generator, ctx.ctx).as_basic_type_enum();
+        let p = generator.gen_var_alloc(ctx, ty, name)?;
+        unsafe { Ok(Ptr(*self).believe_value(p)) }
+    }
+
+    fn array_var_alloca<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        len: IntValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> Result<Instance<'ctx, Ptr<Self>>, String> {
+        // TODO: Remove ArraySliceValue
+        let ty = self.llvm_type(generator, ctx.ctx).as_basic_type_enum();
+        let p = generator.gen_array_var_alloc(ctx, ty, len, name)?;
+        unsafe { Ok(Ptr(*self).believe_value(PointerValue::from(p))) }
+    }
+
+    /// Allocate a constant array.
+    fn const_array<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        values: &[Instance<'ctx, Self>],
+    ) -> Instance<'ctx, Array<AnyLen, Self>> {
+        macro_rules! make {
+            ($t:expr, $into_value:expr) => {
+                $t.const_array(
+                    &values
+                        .iter()
+                        .map(|x| $into_value(x.value.as_basic_value_enum()))
+                        .collect_vec(),
+                )
+            };
+        }
+
+        let value = match self.llvm_type(generator, ctx).as_basic_type_enum() {
+            BasicTypeEnum::ArrayType(t) => make!(t, BasicValueEnum::into_array_value),
+            BasicTypeEnum::IntType(t) => make!(t, BasicValueEnum::into_int_value),
+            BasicTypeEnum::FloatType(t) => make!(t, BasicValueEnum::into_float_value),
+            BasicTypeEnum::PointerType(t) => make!(t, BasicValueEnum::into_pointer_value),
+            BasicTypeEnum::StructType(t) => make!(t, BasicValueEnum::into_struct_value),
+            BasicTypeEnum::VectorType(t) => make!(t, BasicValueEnum::into_vector_value),
+        };
+
+        Array { len: AnyLen(values.len() as u32), item: *self }
+            .check_value(generator, ctx, value)
+            .unwrap()
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Instance<'ctx, M: Model<'ctx>> {
+    /// The model of this instance.
+    pub model: M,
+
+    /// The value of this instance.
+    ///
+    /// It is guaranteed the [`BasicType`] of `value` is consistent with that of `model`.
+    pub value: M::Value,
+}
--- a/nac3core/src/codegen/model/float.rs
+++ b/nac3core/src/codegen/model/float.rs
@ -0,0 +1,93 @@
+use std::fmt;
+
+use inkwell::{
+    context::Context,
+    types::{BasicType, FloatType},
+    values::FloatValue,
+};
+
+use super::*;
+use crate::codegen::CodeGenerator;
+
+pub trait FloatKind<'ctx>: fmt::Debug + Clone + Copy {
+    fn get_float_type<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> FloatType<'ctx>;
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Float32;
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Float64;
+
+impl<'ctx> FloatKind<'ctx> for Float32 {
+    fn get_float_type<G: CodeGenerator + ?Sized>(
+        &self,
+        _generator: &G,
+        ctx: &'ctx Context,
+    ) -> FloatType<'ctx> {
+        ctx.f32_type()
+    }
+}
+
+impl<'ctx> FloatKind<'ctx> for Float64 {
+    fn get_float_type<G: CodeGenerator + ?Sized>(
+        &self,
+        _generator: &G,
+        ctx: &'ctx Context,
+    ) -> FloatType<'ctx> {
+        ctx.f64_type()
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct AnyFloat<'ctx>(FloatType<'ctx>);
+
+impl<'ctx> FloatKind<'ctx> for AnyFloat<'ctx> {
+    fn get_float_type<G: CodeGenerator + ?Sized>(
+        &self,
+        _generator: &G,
+        _ctx: &'ctx Context,
+    ) -> FloatType<'ctx> {
+        self.0
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Float<N>(pub N);
+
+impl<'ctx, N: FloatKind<'ctx>> Model<'ctx> for Float<N> {
+    type Value = FloatValue<'ctx>;
+    type Type = FloatType<'ctx>;
+
+    fn llvm_type<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> Self::Type {
+        self.0.get_float_type(generator, ctx)
+    }
+
+    fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        ty: T,
+    ) -> Result<(), ModelError> {
+        let ty = ty.as_basic_type_enum();
+        let Ok(ty) = FloatType::try_from(ty) else {
+            return Err(ModelError(format!("Expecting FloatType, but got {ty:?}")));
+        };
+
+        let exp_ty = self.0.get_float_type(generator, ctx);
+
+        // TODO: Inkwell does not have get_bit_width for FloatType?
+        if ty != exp_ty {
+            return Err(ModelError(format!("Expecting {exp_ty:?}, but got {ty:?}")));
+        }
+
+        Ok(())
+    }
+}
--- a/nac3core/src/codegen/model/function.rs
+++ b/nac3core/src/codegen/model/function.rs
@ -0,0 +1,121 @@
+use inkwell::{
+    attributes::{Attribute, AttributeLoc},
+    types::{BasicMetadataTypeEnum, BasicType, FunctionType},
+    values::{AnyValue, BasicMetadataValueEnum, BasicValue, BasicValueEnum, CallSiteValue},
+};
+use itertools::Itertools;
+
+use super::*;
+use crate::codegen::{CodeGenContext, CodeGenerator};
+
+#[derive(Debug, Clone, Copy)]
+struct Arg<'ctx> {
+    ty: BasicMetadataTypeEnum<'ctx>,
+    val: BasicMetadataValueEnum<'ctx>,
+}
+
+/// A convenience structure to construct & call an LLVM function.
+///
+/// ### Usage
+///
+/// The syntax is like this:
+/// ```ignore
+/// let result = CallFunction::begin("my_function_name")
+///   .attrs(...)
+///   .arg(arg1)
+///   .arg(arg2)
+///   .arg(arg3)
+///   .returning("my_function_result", Int32);
+/// ```
+///
+/// The function `my_function_name` is called when `.returning()` (or its variants) is called, returning
+/// the result as an `Instance<'ctx, Int<Int32>>`.
+///
+/// If `my_function_name` has not been declared in `ctx.module`, once `.returning()` is called, a function
+/// declaration of `my_function_name` is added to `ctx.module`, where the [`FunctionType`] is deduced from
+/// the argument types and returning type.
+pub struct FnCall<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> {
+    generator: &'d mut G,
+    ctx: &'b CodeGenContext<'ctx, 'a>,
+    /// Function name
+    name: &'c str,
+    /// Call arguments
+    args: Vec<Arg<'ctx>>,
+    /// LLVM function Attributes
+    attrs: Vec<&'static str>,
+}
+
+impl<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> FnCall<'ctx, 'a, 'b, 'c, 'd, G> {
+    pub fn builder(generator: &'d mut G, ctx: &'b CodeGenContext<'ctx, 'a>, name: &'c str) -> Self {
+        FnCall { generator, ctx, name, args: Vec::new(), attrs: Vec::new() }
+    }
+
+    /// Push a list of LLVM function attributes to the function declaration.
+    #[must_use]
+    pub fn attrs(mut self, attrs: Vec<&'static str>) -> Self {
+        self.attrs = attrs;
+        self
+    }
+
+    /// Push a call argument to the function call.
+    #[allow(clippy::needless_pass_by_value)]
+    #[must_use]
+    pub fn arg<M: Model<'ctx>>(mut self, arg: Instance<'ctx, M>) -> Self {
+        let arg = Arg {
+            ty: arg.model.llvm_type(self.generator, self.ctx.ctx).as_basic_type_enum().into(),
+            val: arg.value.as_basic_value_enum().into(),
+        };
+        self.args.push(arg);
+        self
+    }
+
+    /// Call the function and expect the function to return a value of type of `return_model`.
+    #[must_use]
+    pub fn returning<M: Model<'ctx>>(self, name: &str, return_model: M) -> Instance<'ctx, M> {
+        let ret_ty = return_model.llvm_type(self.generator, self.ctx.ctx);
+
+        let ret = self.call(|tys| ret_ty.fn_type(tys, false), name);
+        let ret = BasicValueEnum::try_from(ret.as_any_value_enum()).unwrap(); // Must work
+        let ret = return_model.check_value(self.generator, self.ctx.ctx, ret).unwrap(); // Must work
+        ret
+    }
+
+    /// Like [`CallFunction::returning_`] but `return_model` is automatically inferred.
+    #[must_use]
+    pub fn returning_auto<M: Model<'ctx> + Default>(self, name: &str) -> Instance<'ctx, M> {
+        self.returning(name, M::default())
+    }
+
+    /// Call the function and expect the function to return a void-type.
+    pub fn returning_void(self) {
+        let ret_ty = self.ctx.ctx.void_type();
+
+        let _ = self.call(|tys| ret_ty.fn_type(tys, false), "");
+    }
+
+    fn call<F>(&self, make_fn_type: F, return_value_name: &str) -> CallSiteValue<'ctx>
+    where
+        F: FnOnce(&[BasicMetadataTypeEnum<'ctx>]) -> FunctionType<'ctx>,
+    {
+        // Get the LLVM function.
+        let func = self.ctx.module.get_function(self.name).unwrap_or_else(|| {
+            // Declare the function if it doesn't exist.
+            let tys = self.args.iter().map(|arg| arg.ty).collect_vec();
+
+            let func_type = make_fn_type(&tys);
+            let func = self.ctx.module.add_function(self.name, func_type, None);
+
+            for attr in &self.attrs {
+                func.add_attribute(
+                    AttributeLoc::Function,
+                    self.ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
+                );
+            }
+
+            func
+        });
+
+        let vals = self.args.iter().map(|arg| arg.val).collect_vec();
+        self.ctx.builder.build_call(func, &vals, return_value_name).unwrap()
+    }
+}
--- a/nac3core/src/codegen/model/int.rs
+++ b/nac3core/src/codegen/model/int.rs
@ -0,0 +1,421 @@
+use std::{cmp::Ordering, fmt};
+
+use inkwell::{
+    context::Context,
+    types::{BasicType, IntType},
+    values::IntValue,
+    IntPredicate,
+};
+
+use super::*;
+use crate::codegen::{CodeGenContext, CodeGenerator};
+
+pub trait IntKind<'ctx>: fmt::Debug + Clone + Copy {
+    fn get_int_type<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> IntType<'ctx>;
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Bool;
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Byte;
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Int32;
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Int64;
+#[derive(Debug, Clone, Copy, Default)]
+pub struct SizeT;
+
+impl<'ctx> IntKind<'ctx> for Bool {
+    fn get_int_type<G: CodeGenerator + ?Sized>(
+        &self,
+        _generator: &G,
+        ctx: &'ctx Context,
+    ) -> IntType<'ctx> {
+        ctx.bool_type()
+    }
+}
+
+impl<'ctx> IntKind<'ctx> for Byte {
+    fn get_int_type<G: CodeGenerator + ?Sized>(
+        &self,
+        _generator: &G,
+        ctx: &'ctx Context,
+    ) -> IntType<'ctx> {
+        ctx.i8_type()
+    }
+}
+
+impl<'ctx> IntKind<'ctx> for Int32 {
+    fn get_int_type<G: CodeGenerator + ?Sized>(
+        &self,
+        _generator: &G,
+        ctx: &'ctx Context,
+    ) -> IntType<'ctx> {
+        ctx.i32_type()
+    }
+}
+
+impl<'ctx> IntKind<'ctx> for Int64 {
+    fn get_int_type<G: CodeGenerator + ?Sized>(
+        &self,
+        _generator: &G,
+        ctx: &'ctx Context,
+    ) -> IntType<'ctx> {
+        ctx.i64_type()
+    }
+}
+
+impl<'ctx> IntKind<'ctx> for SizeT {
+    fn get_int_type<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> IntType<'ctx> {
+        generator.get_size_type(ctx)
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct AnyInt<'ctx>(pub IntType<'ctx>);
+
+impl<'ctx> IntKind<'ctx> for AnyInt<'ctx> {
+    fn get_int_type<G: CodeGenerator + ?Sized>(
+        &self,
+        _generator: &G,
+        _ctx: &'ctx Context,
+    ) -> IntType<'ctx> {
+        self.0
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Int<N>(pub N);
+
+impl<'ctx, N: IntKind<'ctx>> Model<'ctx> for Int<N> {
+    type Value = IntValue<'ctx>;
+    type Type = IntType<'ctx>;
+
+    fn llvm_type<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> Self::Type {
+        self.0.get_int_type(generator, ctx)
+    }
+
+    fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        ty: T,
+    ) -> Result<(), ModelError> {
+        let ty = ty.as_basic_type_enum();
+        let Ok(ty) = IntType::try_from(ty) else {
+            return Err(ModelError(format!("Expecting IntType, but got {ty:?}")));
+        };
+
+        let exp_ty = self.0.get_int_type(generator, ctx);
+        if ty.get_bit_width() != exp_ty.get_bit_width() {
+            return Err(ModelError(format!(
+                "Expecting IntType to have {} bit(s), but got {} bit(s)",
+                exp_ty.get_bit_width(),
+                ty.get_bit_width()
+            )));
+        }
+
+        Ok(())
+    }
+}
+
+impl<'ctx, N: IntKind<'ctx>> Int<N> {
+    pub fn const_int<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        value: u64,
+        sign_extend: bool,
+    ) -> Instance<'ctx, Self> {
+        let value = self.llvm_type(generator, ctx).const_int(value, sign_extend);
+        unsafe { self.believe_value(value) }
+    }
+
+    pub fn const_0<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+    ) -> Instance<'ctx, Self> {
+        let value = self.llvm_type(generator, ctx).const_zero();
+        unsafe { self.believe_value(value) }
+    }
+
+    pub fn const_1<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+    ) -> Instance<'ctx, Self> {
+        self.const_int(generator, ctx, 1, false)
+    }
+
+    pub fn const_all_ones<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+    ) -> Instance<'ctx, Self> {
+        let value = self.llvm_type(generator, ctx).const_all_ones();
+        unsafe { self.believe_value(value) }
+    }
+
+    pub fn s_extend_or_bit_cast<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        value: IntValue<'ctx>,
+    ) -> Instance<'ctx, Self> {
+        assert!(
+            value.get_type().get_bit_width()
+                <= self.0.get_int_type(generator, ctx.ctx).get_bit_width()
+        );
+        let value = ctx
+            .builder
+            .build_int_s_extend_or_bit_cast(value, self.llvm_type(generator, ctx.ctx), "")
+            .unwrap();
+        unsafe { self.believe_value(value) }
+    }
+
+    pub fn s_extend<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        value: IntValue<'ctx>,
+    ) -> Instance<'ctx, Self> {
+        assert!(
+            value.get_type().get_bit_width()
+                < self.0.get_int_type(generator, ctx.ctx).get_bit_width()
+        );
+        let value =
+            ctx.builder.build_int_s_extend(value, self.llvm_type(generator, ctx.ctx), "").unwrap();
+        unsafe { self.believe_value(value) }
+    }
+
+    pub fn z_extend_or_bit_cast<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        value: IntValue<'ctx>,
+    ) -> Instance<'ctx, Self> {
+        assert!(
+            value.get_type().get_bit_width()
+                <= self.0.get_int_type(generator, ctx.ctx).get_bit_width()
+        );
+        let value = ctx
+            .builder
+            .build_int_z_extend_or_bit_cast(value, self.llvm_type(generator, ctx.ctx), "")
+            .unwrap();
+        unsafe { self.believe_value(value) }
+    }
+
+    pub fn z_extend<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        value: IntValue<'ctx>,
+    ) -> Instance<'ctx, Self> {
+        assert!(
+            value.get_type().get_bit_width()
+                < self.0.get_int_type(generator, ctx.ctx).get_bit_width()
+        );
+        let value =
+            ctx.builder.build_int_z_extend(value, self.llvm_type(generator, ctx.ctx), "").unwrap();
+        unsafe { self.believe_value(value) }
+    }
+
+    pub fn truncate_or_bit_cast<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        value: IntValue<'ctx>,
+    ) -> Instance<'ctx, Self> {
+        assert!(
+            value.get_type().get_bit_width()
+                >= self.0.get_int_type(generator, ctx.ctx).get_bit_width()
+        );
+        let value = ctx
+            .builder
+            .build_int_truncate_or_bit_cast(value, self.llvm_type(generator, ctx.ctx), "")
+            .unwrap();
+        unsafe { self.believe_value(value) }
+    }
+
+    pub fn truncate<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        value: IntValue<'ctx>,
+    ) -> Instance<'ctx, Self> {
+        assert!(
+            value.get_type().get_bit_width()
+                > self.0.get_int_type(generator, ctx.ctx).get_bit_width()
+        );
+        let value =
+            ctx.builder.build_int_truncate(value, self.llvm_type(generator, ctx.ctx), "").unwrap();
+        unsafe { self.believe_value(value) }
+    }
+
+    /// `sext` or `trunc` an int to this model's int type. Does nothing if equal bit-widths.
+    pub fn s_extend_or_truncate<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        value: IntValue<'ctx>,
+    ) -> Instance<'ctx, Self> {
+        let their_width = value.get_type().get_bit_width();
+        let our_width = self.0.get_int_type(generator, ctx.ctx).get_bit_width();
+        match their_width.cmp(&our_width) {
+            Ordering::Less => self.s_extend(generator, ctx, value),
+            Ordering::Equal => unsafe { self.believe_value(value) },
+            Ordering::Greater => self.truncate(generator, ctx, value),
+        }
+    }
+
+    /// `zext` or `trunc` an int to this model's int type. Does nothing if equal bit-widths.
+    pub fn z_extend_or_truncate<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        value: IntValue<'ctx>,
+    ) -> Instance<'ctx, Self> {
+        let their_width = value.get_type().get_bit_width();
+        let our_width = self.0.get_int_type(generator, ctx.ctx).get_bit_width();
+        match their_width.cmp(&our_width) {
+            Ordering::Less => self.z_extend(generator, ctx, value),
+            Ordering::Equal => unsafe { self.believe_value(value) },
+            Ordering::Greater => self.truncate(generator, ctx, value),
+        }
+    }
+}
+
+impl Int<Bool> {
+    #[must_use]
+    pub fn const_false<'ctx, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+    ) -> Instance<'ctx, Self> {
+        self.const_int(generator, ctx, 0, false)
+    }
+
+    #[must_use]
+    pub fn const_true<'ctx, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+    ) -> Instance<'ctx, Self> {
+        self.const_int(generator, ctx, 1, false)
+    }
+}
+
+impl<'ctx, N: IntKind<'ctx>> Instance<'ctx, Int<N>> {
+    pub fn s_extend_or_bit_cast<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        to_int_kind: NewN,
+    ) -> Instance<'ctx, Int<NewN>> {
+        Int(to_int_kind).s_extend_or_bit_cast(generator, ctx, self.value)
+    }
+
+    pub fn s_extend<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        to_int_kind: NewN,
+    ) -> Instance<'ctx, Int<NewN>> {
+        Int(to_int_kind).s_extend(generator, ctx, self.value)
+    }
+
+    pub fn z_extend_or_bit_cast<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        to_int_kind: NewN,
+    ) -> Instance<'ctx, Int<NewN>> {
+        Int(to_int_kind).z_extend_or_bit_cast(generator, ctx, self.value)
+    }
+
+    pub fn z_extend<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        to_int_kind: NewN,
+    ) -> Instance<'ctx, Int<NewN>> {
+        Int(to_int_kind).z_extend(generator, ctx, self.value)
+    }
+
+    pub fn truncate_or_bit_cast<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        to_int_kind: NewN,
+    ) -> Instance<'ctx, Int<NewN>> {
+        Int(to_int_kind).truncate_or_bit_cast(generator, ctx, self.value)
+    }
+
+    pub fn truncate<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        to_int_kind: NewN,
+    ) -> Instance<'ctx, Int<NewN>> {
+        Int(to_int_kind).truncate(generator, ctx, self.value)
+    }
+
+    pub fn s_extend_or_truncate<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        to_int_kind: NewN,
+    ) -> Instance<'ctx, Int<NewN>> {
+        Int(to_int_kind).s_extend_or_truncate(generator, ctx, self.value)
+    }
+
+    pub fn z_extend_or_truncate<NewN: IntKind<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        to_int_kind: NewN,
+    ) -> Instance<'ctx, Int<NewN>> {
+        Int(to_int_kind).z_extend_or_truncate(generator, ctx, self.value)
+    }
+
+    #[must_use]
+    pub fn add(&self, ctx: &CodeGenContext<'ctx, '_>, other: Self) -> Self {
+        let value = ctx.builder.build_int_add(self.value, other.value, "").unwrap();
+        unsafe { self.model.believe_value(value) }
+    }
+
+    #[must_use]
+    pub fn sub(&self, ctx: &CodeGenContext<'ctx, '_>, other: Self) -> Self {
+        let value = ctx.builder.build_int_sub(self.value, other.value, "").unwrap();
+        unsafe { self.model.believe_value(value) }
+    }
+
+    #[must_use]
+    pub fn mul(&self, ctx: &CodeGenContext<'ctx, '_>, other: Self) -> Self {
+        let value = ctx.builder.build_int_mul(self.value, other.value, "").unwrap();
+        unsafe { self.model.believe_value(value) }
+    }
+
+    pub fn compare(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        op: IntPredicate,
+        other: Self,
+    ) -> Instance<'ctx, Int<Bool>> {
+        let value = ctx.builder.build_int_compare(op, self.value, other.value, "").unwrap();
+        unsafe { Int(Bool).believe_value(value) }
+    }
+}
--- a/nac3core/src/codegen/model/mod.rs
+++ b/nac3core/src/codegen/model/mod.rs
@ -0,0 +1,17 @@
+mod any;
+mod array;
+mod core;
+mod float;
+pub mod function;
+mod int;
+mod ptr;
+mod structure;
+pub mod util;
+
+pub use any::*;
+pub use array::*;
+pub use core::*;
+pub use float::*;
+pub use int::*;
+pub use ptr::*;
+pub use structure::*;
--- a/nac3core/src/codegen/model/ptr.rs
+++ b/nac3core/src/codegen/model/ptr.rs
@ -0,0 +1,213 @@
+use inkwell::{
+    context::Context,
+    types::{BasicType, BasicTypeEnum, PointerType},
+    values::{IntValue, PointerValue},
+    AddressSpace,
+};
+
+use super::*;
+use crate::codegen::{llvm_intrinsics::call_memcpy_generic, CodeGenContext, CodeGenerator};
+
+/// A model for [`PointerType`].
+///
+/// `Item` is the element type this pointer is pointing to, and should be of a [`Model`].
+///
+// TODO: LLVM 15: `Item` is a Rust type-hint for the LLVM type of value the `.store()/.load()` family
+// of functions return. If a truly opaque pointer is needed, tell the programmer to use `OpaquePtr`.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Ptr<Item>(pub Item);
+
+/// An opaque pointer. Like [`Ptr`] but without any Rust type-hints about its element type.
+///
+/// `.load()/.store()` is not available for [`Instance`]s of opaque pointers.
+pub type OpaquePtr = Ptr<()>;
+
+// TODO: LLVM 15: `Item: Model<'ctx>` don't even need to be a model anymore. It will only be
+// a type-hint for the `.load()/.store()` functions for the `pointee_ty`.
+//
+// See https://thedan64.github.io/inkwell/inkwell/builder/struct.Builder.html#method.build_load.
+impl<'ctx, Item: Model<'ctx>> Model<'ctx> for Ptr<Item> {
+    type Value = PointerValue<'ctx>;
+    type Type = PointerType<'ctx>;
+
+    fn llvm_type<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> Self::Type {
+        // TODO: LLVM 15: ctx.ptr_type(AddressSpace::default())
+        self.0.llvm_type(generator, ctx).ptr_type(AddressSpace::default())
+    }
+
+    fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        ty: T,
+    ) -> Result<(), ModelError> {
+        let ty = ty.as_basic_type_enum();
+        let Ok(ty) = PointerType::try_from(ty) else {
+            return Err(ModelError(format!("Expecting PointerType, but got {ty:?}")));
+        };
+
+        let elem_ty = ty.get_element_type();
+        let Ok(elem_ty) = BasicTypeEnum::try_from(elem_ty) else {
+            return Err(ModelError(format!(
+                "Expecting pointer element type to be a BasicTypeEnum, but got {elem_ty:?}"
+            )));
+        };
+
+        // TODO: inkwell `get_element_type()` will be deprecated.
+        // Remove the check for `get_element_type()` when the time comes.
+        self.0
+            .check_type(generator, ctx, elem_ty)
+            .map_err(|err| err.under_context("a PointerType"))?;
+
+        Ok(())
+    }
+}
+
+impl<'ctx, Item: Model<'ctx>> Ptr<Item> {
+    /// Return a ***constant*** nullptr.
+    pub fn nullptr<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+    ) -> Instance<'ctx, Ptr<Item>> {
+        let ptr = self.llvm_type(generator, ctx).const_null();
+        unsafe { self.believe_value(ptr) }
+    }
+
+    /// Cast a pointer into this model with [`inkwell::builder::Builder::build_pointer_cast`]
+    pub fn pointer_cast<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        ptr: PointerValue<'ctx>,
+    ) -> Instance<'ctx, Ptr<Item>> {
+        // TODO: LLVM 15: Write in an impl where `Item` does not have to be `Model<'ctx>`.
+        // TODO: LLVM 15: This function will only have to be:
+        // ```
+        // return self.believe_value(ptr);
+        // ```
+        let t = self.llvm_type(generator, ctx.ctx);
+        let ptr = ctx.builder.build_pointer_cast(ptr, t, "").unwrap();
+        unsafe { self.believe_value(ptr) }
+    }
+}
+
+impl<'ctx, Item: Model<'ctx>> Instance<'ctx, Ptr<Item>> {
+    /// Offset the pointer by [`inkwell::builder::Builder::build_in_bounds_gep`].
+    #[must_use]
+    pub fn offset(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        offset: IntValue<'ctx>,
+    ) -> Instance<'ctx, Ptr<Item>> {
+        let p = unsafe { ctx.builder.build_in_bounds_gep(self.value, &[offset], "").unwrap() };
+        unsafe { self.model.believe_value(p) }
+    }
+
+    /// Offset the pointer by [`inkwell::builder::Builder::build_in_bounds_gep`] by a constant offset.
+    #[must_use]
+    pub fn offset_const(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        offset: i64,
+    ) -> Instance<'ctx, Ptr<Item>> {
+        let offset = ctx.ctx.i32_type().const_int(offset as u64, true);
+        self.offset(ctx, offset)
+    }
+
+    pub fn set_index(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        index: IntValue<'ctx>,
+        value: Instance<'ctx, Item>,
+    ) {
+        self.offset(ctx, index).store(ctx, value);
+    }
+
+    pub fn set_index_const(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        index: i64,
+        value: Instance<'ctx, Item>,
+    ) {
+        self.offset_const(ctx, index).store(ctx, value);
+    }
+
+    pub fn get_index<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        index: IntValue<'ctx>,
+    ) -> Instance<'ctx, Item> {
+        self.offset(ctx, index).load(generator, ctx)
+    }
+
+    pub fn get_index_const<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        index: i64,
+    ) -> Instance<'ctx, Item> {
+        self.offset_const(ctx, index).load(generator, ctx)
+    }
+
+    /// Load the value with [`inkwell::builder::Builder::build_load`].
+    pub fn load<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+    ) -> Instance<'ctx, Item> {
+        let value = ctx.builder.build_load(self.value, "").unwrap();
+        self.model.0.check_value(generator, ctx.ctx, value).unwrap() // If unwrap() panics, there is a logic error.
+    }
+
+    /// Store a value with [`inkwell::builder::Builder::build_store`].
+    pub fn store(&self, ctx: &CodeGenContext<'ctx, '_>, value: Instance<'ctx, Item>) {
+        ctx.builder.build_store(self.value, value.value).unwrap();
+    }
+
+    /// Return a casted pointer of element type `NewElement` with [`inkwell::builder::Builder::build_pointer_cast`].
+    pub fn pointer_cast<NewItem: Model<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        new_item: NewItem,
+    ) -> Instance<'ctx, Ptr<NewItem>> {
+        // TODO: LLVM 15: Write in an impl where `Item` does not have to be `Model<'ctx>`.
+        Ptr(new_item).pointer_cast(generator, ctx, self.value)
+    }
+
+    /// Check if the pointer is null with [`inkwell::builder::Builder::build_is_null`].
+    pub fn is_null(&self, ctx: &CodeGenContext<'ctx, '_>) -> Instance<'ctx, Int<Bool>> {
+        let value = ctx.builder.build_is_null(self.value, "").unwrap();
+        unsafe { Int(Bool).believe_value(value) }
+    }
+
+    /// Check if the pointer is not null with [`inkwell::builder::Builder::build_is_not_null`].
+    pub fn is_not_null(&self, ctx: &CodeGenContext<'ctx, '_>) -> Instance<'ctx, Int<Bool>> {
+        let value = ctx.builder.build_is_not_null(self.value, "").unwrap();
+        unsafe { Int(Bool).believe_value(value) }
+    }
+
+    /// `memcpy` from another pointer.
+    pub fn copy_from<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        source: Self,
+        num_items: IntValue<'ctx>,
+    ) {
+        // Force extend `num_items` and `itemsize` to `i64` so their types would match.
+        let itemsize = self.model.size_of(generator, ctx.ctx);
+        let itemsize = Int(SizeT).z_extend_or_truncate(generator, ctx, itemsize);
+        let num_items = Int(SizeT).z_extend_or_truncate(generator, ctx, num_items);
+        let totalsize = itemsize.mul(ctx, num_items);
+
+        let is_volatile = ctx.ctx.bool_type().const_zero(); // is_volatile = false
+        call_memcpy_generic(ctx, self.value, source.value, totalsize.value, is_volatile);
+    }
+}
--- a/nac3core/src/codegen/model/structure.rs
+++ b/nac3core/src/codegen/model/structure.rs
@ -0,0 +1,363 @@
+use std::fmt;
+
+use inkwell::{
+    context::Context,
+    types::{BasicType, BasicTypeEnum, StructType},
+    values::{BasicValueEnum, StructValue},
+};
+
+use super::*;
+use crate::codegen::{CodeGenContext, CodeGenerator};
+
+/// A traveral that traverses a Rust `struct` that is used to declare an LLVM's struct's field types.
+pub trait FieldTraversal<'ctx> {
+    /// Output type of [`FieldTraversal::add`].
+    type Output<M>;
+
+    /// Traverse through the type of a declared field and do something with it.
+    ///
+    /// * `name` - The cosmetic name of the LLVM field. Used for debugging.
+    /// * `model` - The [`Model`] representing the LLVM type of this field.
+    fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Output<M>;
+
+    /// Like [`FieldTraversal::add`] but [`Model`] is automatically inferred from its [`Default`] trait.
+    fn add_auto<M: Model<'ctx> + Default>(&mut self, name: &'static str) -> Self::Output<M> {
+        self.add(name, M::default())
+    }
+}
+
+/// Descriptor of an LLVM struct field.
+#[derive(Debug, Clone, Copy)]
+pub struct GepField<M> {
+    /// The GEP index of this field. This is the index to use with `build_gep`.
+    pub gep_index: u32,
+    /// The cosmetic name of this field.
+    pub name: &'static str,
+    /// The [`Model`] of this field's type.
+    pub model: M,
+}
+
+/// A traversal to calculate the GEP index of fields.
+pub struct GepFieldTraversal {
+    /// The current GEP index.
+    gep_index_counter: u32,
+}
+
+impl<'ctx> FieldTraversal<'ctx> for GepFieldTraversal {
+    type Output<M> = GepField<M>;
+
+    fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Output<M> {
+        let gep_index = self.gep_index_counter;
+        self.gep_index_counter += 1;
+        Self::Output { gep_index, name, model }
+    }
+}
+
+/// A traversal to collect the field types of a struct.
+///
+/// This is used to collect field types and construct the LLVM struct type with [`Context::struct_type`].
+struct TypeFieldTraversal<'ctx, 'a, G: CodeGenerator + ?Sized> {
+    generator: &'a G,
+    ctx: &'ctx Context,
+    /// The collected field types so far in exact order.
+    field_types: Vec<BasicTypeEnum<'ctx>>,
+}
+
+impl<'ctx, 'a, G: CodeGenerator + ?Sized> FieldTraversal<'ctx> for TypeFieldTraversal<'ctx, 'a, G> {
+    type Output<M> = (); // Checking types return nothing.
+
+    fn add<M: Model<'ctx>>(&mut self, _name: &'static str, model: M) -> Self::Output<M> {
+        let t = model.llvm_type(self.generator, self.ctx).as_basic_type_enum();
+        self.field_types.push(t);
+    }
+}
+
+/// A traversal to check the types of fields.
+struct CheckTypeFieldTraversal<'ctx, 'a, G: CodeGenerator + ?Sized> {
+    generator: &'a mut G,
+    ctx: &'ctx Context,
+    /// The current GEP index, so we can tell the index of the field we are checking
+    /// and report the GEP index.
+    gep_index_counter: u32,
+    /// The [`StructType`] to check.
+    scrutinee: StructType<'ctx>,
+    /// The list of collected errors so far.
+    errors: Vec<ModelError>,
+}
+
+impl<'ctx, 'a, G: CodeGenerator + ?Sized> FieldTraversal<'ctx>
+    for CheckTypeFieldTraversal<'ctx, 'a, G>
+{
+    type Output<M> = (); // Checking types return nothing.
+
+    fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Output<M> {
+        let gep_index = self.gep_index_counter;
+        self.gep_index_counter += 1;
+
+        if let Some(t) = self.scrutinee.get_field_type_at_index(gep_index) {
+            if let Err(err) = model.check_type(self.generator, self.ctx, t) {
+                self.errors
+                    .push(err.under_context(format!("field #{gep_index} '{name}'").as_str()));
+            }
+        }
+        // Otherwise, it will be caught by Struct's `check_type`.
+    }
+}
+
+/// A trait for Rust structs identifying LLVM structures.
+///
+/// ### Example
+///
+/// Suppose you want to define this structure:
+/// ```c
+/// template <typename T>
+/// struct ContiguousNDArray {
+///     size_t ndims;
+///     size_t* shape;
+///     T* data;
+/// }
+/// ```
+///
+/// This is how it should be done:
+/// ```ignore
+/// pub struct ContiguousNDArrayFields<'ctx, F: FieldTraversal<'ctx>, Item: Model<'ctx>> {
+///     pub ndims: F::Out<Int<SizeT>>,
+///     pub shape: F::Out<Ptr<Int<SizeT>>>,
+///     pub data: F::Out<Ptr<Item>>,
+/// }
+///
+/// /// An ndarray without strides and non-opaque `data` field in NAC3.
+/// #[derive(Debug, Clone, Copy)]
+/// pub struct ContiguousNDArray<M> {
+///     /// [`Model`] of the items.
+///     pub item: M,
+/// }
+///
+/// impl<'ctx, Item: Model<'ctx>> StructKind<'ctx> for ContiguousNDArray<Item> {
+///     type Fields<F: FieldTraversal<'ctx>> = ContiguousNDArrayFields<'ctx, F, Item>;
+///
+///     fn traverse_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
+///         // The order of `traversal.add*` is important
+///         Self::Fields {
+///             ndims: traversal.add_auto("ndims"),
+///             shape: traversal.add_auto("shape"),
+///             data: traversal.add("data", Ptr(self.item)),
+///         }
+///     }
+/// }
+/// ```
+///
+/// The [`FieldTraversal`] here is a mechanism to allow the fields of `ContiguousNDArrayFields` to be
+/// traversed to do useful work such as:
+///
+/// - To create the [`StructType`] of `ContiguousNDArray` by collecting [`BasicType`]s of the fields.
+/// - To enable the `.gep(ctx, |f| f.ndims).store(ctx, ...)` syntax.
+///
+/// Suppose now that you have defined `ContiguousNDArray` and you want to allocate a `ContiguousNDArray`
+/// with dtype `float64` in LLVM, this is how you do it:
+/// ```ignore
+/// type F64NDArray = Struct<ContiguousNDArray<Float<Float64>>>; // Type alias for leaner documentation
+/// let model: F64NDArray = Struct(ContigousNDArray { item: Float(Float64) });
+/// let ndarray: Instance<'ctx, Ptr<F64NDArray>> = model.alloca(generator, ctx);
+/// ```
+///
+/// ...and here is how you may manipulate/access `ndarray`:
+///
+/// (NOTE: some arguments have been omitted)
+///
+/// ```ignore
+/// // Get `&ndarray->data`
+/// ndarray.gep(|f| f.data); // type: Instance<'ctx, Ptr<Float<Float64>>>
+///
+/// // Get `ndarray->ndims`
+/// ndarray.get(|f| f.ndims); // type: Instance<'ctx, Int<SizeT>>
+///
+/// // Get `&ndarray->ndims`
+/// ndarray.gep(|f| f.ndims); // type: Instance<'ctx, Ptr<Int<SizeT>>>
+///
+/// // Get `ndarray->shape[0]`
+/// ndarray.get(|f| f.shape).get_index_const(0); // Instance<'ctx, Int<SizeT>>
+///
+/// // Get `&ndarray->shape[2]`
+/// ndarray.get(|f| f.shape).offset_const(2); // Instance<'ctx, Ptr<Int<SizeT>>>
+///
+/// // Do `ndarray->ndims = 3;`
+/// let num_3 = Int(SizeT).const_int(3);
+/// ndarray.set(|f| f.ndims, num_3);
+/// ```
+pub trait StructKind<'ctx>: fmt::Debug + Clone + Copy {
+    /// The associated fields of this struct.
+    type Fields<F: FieldTraversal<'ctx>>;
+
+    /// Traverse through all fields of this [`StructKind`].
+    ///
+    /// Only used internally in this module for implementing other components.
+    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F>;
+
+    /// Get a convenience structure to get a struct field's GEP index through its corresponding Rust field.
+    ///
+    /// Only used internally in this module for implementing other components.
+    fn fields(&self) -> Self::Fields<GepFieldTraversal> {
+        self.iter_fields(&mut GepFieldTraversal { gep_index_counter: 0 })
+    }
+
+    /// Get the LLVM [`StructType`] of this [`StructKind`].
+    fn get_struct_type<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> StructType<'ctx> {
+        let mut traversal = TypeFieldTraversal { generator, ctx, field_types: Vec::new() };
+        self.iter_fields(&mut traversal);
+
+        ctx.struct_type(&traversal.field_types, false)
+    }
+}
+
+/// A model for LLVM struct.
+///
+/// `S` should be of a [`StructKind`].
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Struct<S>(pub S);
+
+impl<'ctx, S: StructKind<'ctx>> Struct<S> {
+    /// Create a constant struct value from its fields.
+    ///
+    /// This function also validates `fields` and panic when there is something wrong.
+    pub fn const_struct<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        fields: &[BasicValueEnum<'ctx>],
+    ) -> Instance<'ctx, Self> {
+        // NOTE: There *could* have been a functor `F<M> = Instance<'ctx, M>` for `S::Fields<F>`
+        // to create a more user-friendly interface, but Rust's type system is not sophisticated enough
+        // and if you try doing that Rust would force you put lifetimes everywhere.
+        let val = ctx.const_struct(fields, false);
+        self.check_value(generator, ctx, val).unwrap()
+    }
+}
+
+impl<'ctx, S: StructKind<'ctx>> Model<'ctx> for Struct<S> {
+    type Value = StructValue<'ctx>;
+    type Type = StructType<'ctx>;
+
+    fn llvm_type<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> Self::Type {
+        self.0.get_struct_type(generator, ctx)
+    }
+
+    fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        ty: T,
+    ) -> Result<(), ModelError> {
+        let ty = ty.as_basic_type_enum();
+        let Ok(ty) = StructType::try_from(ty) else {
+            return Err(ModelError(format!("Expecting StructType, but got {ty:?}")));
+        };
+
+        // Check each field individually.
+        let mut traversal = CheckTypeFieldTraversal {
+            generator,
+            ctx,
+            gep_index_counter: 0,
+            errors: Vec::new(),
+            scrutinee: ty,
+        };
+        self.0.iter_fields(&mut traversal);
+
+        // Check the number of fields.
+        let exp_num_fields = traversal.gep_index_counter;
+        let got_num_fields = u32::try_from(ty.get_field_types().len()).unwrap();
+        if exp_num_fields != got_num_fields {
+            return Err(ModelError(format!(
+                "Expecting StructType with {exp_num_fields} field(s), but got {got_num_fields}"
+            )));
+        }
+
+        if !traversal.errors.is_empty() {
+            // Currently, only the first error is reported.
+            return Err(traversal.errors[0].clone());
+        }
+
+        Ok(())
+    }
+}
+
+impl<'ctx, S: StructKind<'ctx>> Instance<'ctx, Struct<S>> {
+    /// Get a field with [`StructValue::get_field_at_index`].
+    pub fn get_field<G: CodeGenerator + ?Sized, M, GetField>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+        get_field: GetField,
+    ) -> Instance<'ctx, M>
+    where
+        M: Model<'ctx>,
+        GetField: FnOnce(S::Fields<GepFieldTraversal>) -> GepField<M>,
+    {
+        let field = get_field(self.model.0.fields());
+        let val = self.value.get_field_at_index(field.gep_index).unwrap();
+        field.model.check_value(generator, ctx, val).unwrap()
+    }
+}
+
+impl<'ctx, S: StructKind<'ctx>> Instance<'ctx, Ptr<Struct<S>>> {
+    /// Get a pointer to a field with [`Builder::build_in_bounds_gep`].
+    pub fn gep<M, GetField>(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        get_field: GetField,
+    ) -> Instance<'ctx, Ptr<M>>
+    where
+        M: Model<'ctx>,
+        GetField: FnOnce(S::Fields<GepFieldTraversal>) -> GepField<M>,
+    {
+        let field = get_field(self.model.0 .0.fields());
+        let llvm_i32 = ctx.ctx.i32_type();
+
+        let ptr = unsafe {
+            ctx.builder
+                .build_in_bounds_gep(
+                    self.value,
+                    &[llvm_i32.const_zero(), llvm_i32.const_int(u64::from(field.gep_index), false)],
+                    field.name,
+                )
+                .unwrap()
+        };
+
+        unsafe { Ptr(field.model).believe_value(ptr) }
+    }
+
+    /// Convenience function equivalent to `.gep(...).load(...)`.
+    pub fn get<M, GetField, G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        get_field: GetField,
+    ) -> Instance<'ctx, M>
+    where
+        M: Model<'ctx>,
+        GetField: FnOnce(S::Fields<GepFieldTraversal>) -> GepField<M>,
+    {
+        self.gep(ctx, get_field).load(generator, ctx)
+    }
+
+    /// Convenience function equivalent to `.gep(...).store(...)`.
+    pub fn set<M, GetField>(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        get_field: GetField,
+        value: Instance<'ctx, M>,
+    ) where
+        M: Model<'ctx>,
+        GetField: FnOnce(S::Fields<GepFieldTraversal>) -> GepField<M>,
+    {
+        self.gep(ctx, get_field).store(ctx, value);
+    }
+}
--- a/nac3core/src/codegen/model/util.rs
+++ b/nac3core/src/codegen/model/util.rs
@ -0,0 +1,41 @@
+use super::*;
+use crate::codegen::{
+    stmt::{gen_for_callback_incrementing, BreakContinueHooks},
+    CodeGenContext, CodeGenerator,
+};
+
+/// Like [`gen_for_callback_incrementing`] with [`Model`] abstractions.
+///
+/// The value for `stop` is exclusive.
+pub fn gen_for_model<'ctx, 'a, G, F, N>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, 'a>,
+    start: Instance<'ctx, Int<N>>,
+    stop: Instance<'ctx, Int<N>>,
+    step: Instance<'ctx, Int<N>>,
+    body: F,
+) -> Result<(), String>
+where
+    G: CodeGenerator + ?Sized,
+    F: FnOnce(
+        &mut G,
+        &mut CodeGenContext<'ctx, 'a>,
+        BreakContinueHooks<'ctx>,
+        Instance<'ctx, Int<N>>,
+    ) -> Result<(), String>,
+    N: IntKind<'ctx> + Default,
+{
+    let int_model = Int(N::default());
+    gen_for_callback_incrementing(
+        generator,
+        ctx,
+        None,
+        start.value,
+        (stop.value, false),
+        |g, ctx, hooks, i| {
+            let i = unsafe { int_model.believe_value(i) };
+            body(g, ctx, hooks, i)
+        },
+        step.value,
+    )
+}
--- a/nac3core/src/codegen/numpy.rs
+++ b/nac3core/src/codegen/numpy.rs
@ -1,3 +1,11 @@
+use inkwell::{
+    types::{AnyTypeEnum, BasicType, BasicTypeEnum, PointerType},
+    values::{BasicValue, BasicValueEnum, IntValue, PointerValue},
+    AddressSpace, IntPredicate, OptimizationLevel,
+};
+
+use nac3parser::ast::{Operator, StrRef};
+
 use crate::{
    codegen::{
        classes::{
@ -13,12 +21,16 @@ use crate::{
        },
        llvm_intrinsics::{self, call_memcpy_generic},
        macros::codegen_unreachable,
+        object::{
+            any::AnyObject,
+            ndarray::{shape_util::parse_numpy_int_sequence, NDArrayObject},
+        },
        stmt::{gen_for_callback_incrementing, gen_for_range_callback, gen_if_else_expr_callback},
        CodeGenContext, CodeGenerator,
    },
    symbol_resolver::ValueEnum,
    toplevel::{
-        helper::PrimDef,
+        helper::{extract_ndims, PrimDef},
        numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
        DefinitionId,
    },
@ -27,16 +39,6 @@ use crate::{
        typedef::{FunSignature, Type, TypeEnum},
    },
 };
-use inkwell::{
-    types::BasicType,
-    values::{BasicValueEnum, IntValue, PointerValue},
-    AddressSpace, IntPredicate, OptimizationLevel,
-};
-use inkwell::{
-    types::{AnyTypeEnum, BasicTypeEnum, PointerType},
-    values::BasicValue,
-};
-use nac3parser::ast::{Operator, StrRef};

 /// Creates an uninitialized `NDArray` instance.
 fn create_ndarray_uninitialized<'ctx, G: CodeGenerator + ?Sized>(
@ -942,7 +944,7 @@ fn call_ndarray_array_impl<'ctx, G: CodeGenerator + ?Sized>(
                        .build_store(
                            lst,
                            ctx.builder
-                                .build_bitcast(object.as_base_value(), llvm_plist_i8, "")
+                                .build_bit_cast(object.as_base_value(), llvm_plist_i8, "")
                                .unwrap(),
                        )
                        .unwrap();
@ -964,7 +966,7 @@ fn call_ndarray_array_impl<'ctx, G: CodeGenerator + ?Sized>(
                                .builder
                                .build_load(lst, "")
                                .map(BasicValueEnum::into_pointer_value)
-                                .map(|v| ctx.builder.build_bitcast(v, plist_plist_i8, "").unwrap())
+                                .map(|v| ctx.builder.build_bit_cast(v, plist_plist_i8, "").unwrap())
                                .map(BasicValueEnum::into_pointer_value)
                                .unwrap();
                            let this_dim = ListValue::from_ptr_val(this_dim, llvm_usize, None);
@ -983,7 +985,9 @@ fn call_ndarray_array_impl<'ctx, G: CodeGenerator + ?Sized>(
                            ctx.builder
                                .build_store(
                                    lst,
-                                    ctx.builder.build_bitcast(next_dim, llvm_plist_i8, "").unwrap(),
+                                    ctx.builder
+                                        .build_bit_cast(next_dim, llvm_plist_i8, "")
+                                        .unwrap(),
                                )
                                .unwrap();

@ -1743,8 +1747,13 @@ pub fn gen_ndarray_empty<'ctx>(
    let shape_ty = fun.0.args[0].ty;
    let shape_arg = args[0].1.clone().to_basic_value_enum(context, generator, shape_ty)?;

-    call_ndarray_empty_impl(generator, context, context.primitives.float, shape_arg)
-        .map(NDArrayValue::into)
+    let (dtype, ndims) = unpack_ndarray_var_tys(&mut context.unifier, fun.0.ret);
+    let ndims = extract_ndims(&context.unifier, ndims);
+
+    let shape = AnyObject { value: shape_arg, ty: shape_ty };
+    let (_, shape) = parse_numpy_int_sequence(generator, context, shape);
+    let ndarray = NDArrayObject::make_np_empty(generator, context, dtype, ndims, shape);
+    Ok(ndarray.instance.value)
 }

 /// Generates LLVM IR for `ndarray.zeros`.
@ -1761,8 +1770,13 @@ pub fn gen_ndarray_zeros<'ctx>(
    let shape_ty = fun.0.args[0].ty;
    let shape_arg = args[0].1.clone().to_basic_value_enum(context, generator, shape_ty)?;

-    call_ndarray_zeros_impl(generator, context, context.primitives.float, shape_arg)
-        .map(NDArrayValue::into)
+    let (dtype, ndims) = unpack_ndarray_var_tys(&mut context.unifier, fun.0.ret);
+    let ndims = extract_ndims(&context.unifier, ndims);
+
+    let shape = AnyObject { value: shape_arg, ty: shape_ty };
+    let (_, shape) = parse_numpy_int_sequence(generator, context, shape);
+    let ndarray = NDArrayObject::make_np_zeros(generator, context, dtype, ndims, shape);
+    Ok(ndarray.instance.value)
 }

 /// Generates LLVM IR for `ndarray.ones`.
@ -1779,8 +1793,13 @@ pub fn gen_ndarray_ones<'ctx>(
    let shape_ty = fun.0.args[0].ty;
    let shape_arg = args[0].1.clone().to_basic_value_enum(context, generator, shape_ty)?;

-    call_ndarray_ones_impl(generator, context, context.primitives.float, shape_arg)
-        .map(NDArrayValue::into)
+    let (dtype, ndims) = unpack_ndarray_var_tys(&mut context.unifier, fun.0.ret);
+    let ndims = extract_ndims(&context.unifier, ndims);
+
+    let shape = AnyObject { value: shape_arg, ty: shape_ty };
+    let (_, shape) = parse_numpy_int_sequence(generator, context, shape);
+    let ndarray = NDArrayObject::make_np_ones(generator, context, dtype, ndims, shape);
+    Ok(ndarray.instance.value)
 }

 /// Generates LLVM IR for `ndarray.full`.
@ -1800,8 +1819,14 @@ pub fn gen_ndarray_full<'ctx>(
    let fill_value_arg =
        args[1].1.clone().to_basic_value_enum(context, generator, fill_value_ty)?;

-    call_ndarray_full_impl(generator, context, fill_value_ty, shape_arg, fill_value_arg)
-        .map(NDArrayValue::into)
+    let (dtype, ndims) = unpack_ndarray_var_tys(&mut context.unifier, fun.0.ret);
+    let ndims = extract_ndims(&context.unifier, ndims);
+
+    let shape = AnyObject { value: shape_arg, ty: shape_ty };
+    let (_, shape) = parse_numpy_int_sequence(generator, context, shape);
+    let ndarray =
+        NDArrayObject::make_np_full(generator, context, dtype, ndims, shape, fill_value_arg);
+    Ok(ndarray.instance.value)
 }

 pub fn gen_ndarray_array<'ctx>(
--- a/nac3core/src/codegen/object/any.rs
+++ b/nac3core/src/codegen/object/any.rs
@ -0,0 +1,12 @@
+use inkwell::values::BasicValueEnum;
+
+use crate::typecheck::typedef::Type;
+
+/// A NAC3 LLVM Python object of any type.
+#[derive(Debug, Clone, Copy)]
+pub struct AnyObject<'ctx> {
+    /// Typechecker type of the object.
+    pub ty: Type,
+    /// LLVM value of the object.
+    pub value: BasicValueEnum<'ctx>,
+}
--- a/nac3core/src/codegen/object/list.rs
+++ b/nac3core/src/codegen/object/list.rs
@ -0,0 +1,75 @@
+use super::any::AnyObject;
+use crate::{
+    codegen::{model::*, CodeGenContext, CodeGenerator},
+    typecheck::typedef::{iter_type_vars, Type, TypeEnum},
+};
+
+/// Fields of [`List`]
+pub struct ListFields<'ctx, F: FieldTraversal<'ctx>, Item: Model<'ctx>> {
+    /// Array pointer to content
+    pub items: F::Output<Ptr<Item>>,
+    /// Number of items in the array
+    pub len: F::Output<Int<SizeT>>,
+}
+
+/// A list in NAC3.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct List<Item> {
+    /// Model of the list items
+    pub item: Item,
+}
+
+impl<'ctx, Item: Model<'ctx>> StructKind<'ctx> for List<Item> {
+    type Fields<F: FieldTraversal<'ctx>> = ListFields<'ctx, F, Item>;
+
+    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
+        Self::Fields {
+            items: traversal.add("items", Ptr(self.item)),
+            len: traversal.add_auto("len"),
+        }
+    }
+}
+
+/// A NAC3 Python List object.
+#[derive(Debug, Clone, Copy)]
+pub struct ListObject<'ctx> {
+    /// Typechecker type of the list items
+    pub item_type: Type,
+    pub instance: Instance<'ctx, Ptr<Struct<List<Any<'ctx>>>>>,
+}
+
+impl<'ctx> ListObject<'ctx> {
+    /// Create a [`ListObject`] from an LLVM value and its typechecker [`Type`].
+    pub fn from_object<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        object: AnyObject<'ctx>,
+    ) -> Self {
+        // Check typechecker type and extract `item_type`
+        let item_type = match &*ctx.unifier.get_ty(object.ty) {
+            TypeEnum::TObj { obj_id, params, .. }
+                if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
+            {
+                iter_type_vars(params).next().unwrap().ty // Extract `item_type`
+            }
+            _ => {
+                panic!("Expecting type to be a list, but got {}", ctx.unifier.stringify(object.ty))
+            }
+        };
+
+        let plist = Ptr(Struct(List { item: Any(ctx.get_llvm_type(generator, item_type)) }));
+
+        // Create object
+        let value = plist.check_value(generator, ctx.ctx, object.value).unwrap();
+        ListObject { item_type, instance: value }
+    }
+
+    /// Get the `len()` of this list.
+    pub fn len<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> Instance<'ctx, Int<SizeT>> {
+        self.instance.get(generator, ctx, |f| f.len)
+    }
+}
--- a/nac3core/src/codegen/object/mod.rs
+++ b/nac3core/src/codegen/object/mod.rs
@ -0,0 +1,4 @@
+pub mod any;
+pub mod list;
+pub mod ndarray;
+pub mod tuple;
--- a/nac3core/src/codegen/object/ndarray/factory.rs
+++ b/nac3core/src/codegen/object/ndarray/factory.rs
@ -0,0 +1,125 @@
+use inkwell::values::BasicValueEnum;
+
+use super::NDArrayObject;
+use crate::{
+    codegen::{
+        irrt::call_nac3_ndarray_util_assert_shape_no_negative, model::*, CodeGenContext,
+        CodeGenerator,
+    },
+    typecheck::typedef::Type,
+};
+
+/// Get the zero value in `np.zeros()` of a `dtype`.
+fn ndarray_zero_value<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    dtype: Type,
+) -> BasicValueEnum<'ctx> {
+    if [ctx.primitives.int32, ctx.primitives.uint32]
+        .iter()
+        .any(|ty| ctx.unifier.unioned(dtype, *ty))
+    {
+        ctx.ctx.i32_type().const_zero().into()
+    } else if [ctx.primitives.int64, ctx.primitives.uint64]
+        .iter()
+        .any(|ty| ctx.unifier.unioned(dtype, *ty))
+    {
+        ctx.ctx.i64_type().const_zero().into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.float) {
+        ctx.ctx.f64_type().const_zero().into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.bool) {
+        ctx.ctx.bool_type().const_zero().into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.str) {
+        ctx.gen_string(generator, "").into()
+    } else {
+        panic!("unrecognized dtype: {}", ctx.unifier.stringify(dtype));
+    }
+}
+
+/// Get the one value in `np.ones()` of a `dtype`.
+fn ndarray_one_value<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    dtype: Type,
+) -> BasicValueEnum<'ctx> {
+    if [ctx.primitives.int32, ctx.primitives.uint32]
+        .iter()
+        .any(|ty| ctx.unifier.unioned(dtype, *ty))
+    {
+        let is_signed = ctx.unifier.unioned(dtype, ctx.primitives.int32);
+        ctx.ctx.i32_type().const_int(1, is_signed).into()
+    } else if [ctx.primitives.int64, ctx.primitives.uint64]
+        .iter()
+        .any(|ty| ctx.unifier.unioned(dtype, *ty))
+    {
+        let is_signed = ctx.unifier.unioned(dtype, ctx.primitives.int64);
+        ctx.ctx.i64_type().const_int(1, is_signed).into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.float) {
+        ctx.ctx.f64_type().const_float(1.0).into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.bool) {
+        ctx.ctx.bool_type().const_int(1, false).into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.str) {
+        ctx.gen_string(generator, "1").into()
+    } else {
+        panic!("unrecognized dtype: {}", ctx.unifier.stringify(dtype));
+    }
+}
+
+impl<'ctx> NDArrayObject<'ctx> {
+    /// Create an ndarray like `np.empty`.
+    pub fn make_np_empty<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        ndims: u64,
+        shape: Instance<'ctx, Ptr<Int<SizeT>>>,
+    ) -> Self {
+        // Validate `shape`
+        let ndims_llvm = Int(SizeT).const_int(generator, ctx.ctx, ndims, false);
+        call_nac3_ndarray_util_assert_shape_no_negative(generator, ctx, ndims_llvm, shape);
+
+        let ndarray = NDArrayObject::alloca(generator, ctx, dtype, ndims);
+        ndarray.copy_shape_from_array(generator, ctx, shape);
+        ndarray.create_data(generator, ctx);
+
+        ndarray
+    }
+
+    /// Create an ndarray like `np.full`.
+    pub fn make_np_full<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        ndims: u64,
+        shape: Instance<'ctx, Ptr<Int<SizeT>>>,
+        fill_value: BasicValueEnum<'ctx>,
+    ) -> Self {
+        let ndarray = NDArrayObject::make_np_empty(generator, ctx, dtype, ndims, shape);
+        ndarray.fill(generator, ctx, fill_value);
+        ndarray
+    }
+
+    /// Create an ndarray like `np.zero`.
+    pub fn make_np_zeros<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        ndims: u64,
+        shape: Instance<'ctx, Ptr<Int<SizeT>>>,
+    ) -> Self {
+        let fill_value = ndarray_zero_value(generator, ctx, dtype);
+        NDArrayObject::make_np_full(generator, ctx, dtype, ndims, shape, fill_value)
+    }
+
+    /// Create an ndarray like `np.ones`.
+    pub fn make_np_ones<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        ndims: u64,
+        shape: Instance<'ctx, Ptr<Int<SizeT>>>,
+    ) -> Self {
+        let fill_value = ndarray_one_value(generator, ctx, dtype);
+        NDArrayObject::make_np_full(generator, ctx, dtype, ndims, shape, fill_value)
+    }
+}
--- a/nac3core/src/codegen/object/ndarray/mod.rs
+++ b/nac3core/src/codegen/object/ndarray/mod.rs
@ -0,0 +1,371 @@
+use inkwell::{
+    context::Context,
+    types::BasicType,
+    values::{BasicValueEnum, PointerValue},
+    AddressSpace,
+};
+
+use super::any::AnyObject;
+use crate::{
+    codegen::{
+        irrt::{
+            call_nac3_ndarray_copy_data, call_nac3_ndarray_get_nth_pelement,
+            call_nac3_ndarray_get_pelement_by_indices, call_nac3_ndarray_is_c_contiguous,
+            call_nac3_ndarray_len, call_nac3_ndarray_nbytes,
+            call_nac3_ndarray_set_strides_by_shape, call_nac3_ndarray_size,
+        },
+        model::*,
+        CodeGenContext, CodeGenerator,
+    },
+    toplevel::{helper::extract_ndims, numpy::unpack_ndarray_var_tys},
+    typecheck::typedef::Type,
+};
+
+pub mod factory;
+pub mod nditer;
+pub mod shape_util;
+
+/// Fields of [`NDArray`]
+pub struct NDArrayFields<'ctx, F: FieldTraversal<'ctx>> {
+    pub data: F::Output<Ptr<Int<Byte>>>,
+    pub itemsize: F::Output<Int<SizeT>>,
+    pub ndims: F::Output<Int<SizeT>>,
+    pub shape: F::Output<Ptr<Int<SizeT>>>,
+    pub strides: F::Output<Ptr<Int<SizeT>>>,
+}
+
+/// A strided ndarray in NAC3.
+///
+/// See IRRT implementation for details about its fields.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct NDArray;
+
+impl<'ctx> StructKind<'ctx> for NDArray {
+    type Fields<F: FieldTraversal<'ctx>> = NDArrayFields<'ctx, F>;
+
+    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
+        Self::Fields {
+            data: traversal.add_auto("data"),
+            itemsize: traversal.add_auto("itemsize"),
+            ndims: traversal.add_auto("ndims"),
+            shape: traversal.add_auto("shape"),
+            strides: traversal.add_auto("strides"),
+        }
+    }
+}
+
+/// A NAC3 Python ndarray object.
+#[derive(Debug, Clone, Copy)]
+pub struct NDArrayObject<'ctx> {
+    pub dtype: Type,
+    pub ndims: u64,
+    pub instance: Instance<'ctx, Ptr<Struct<NDArray>>>,
+}
+
+impl<'ctx> NDArrayObject<'ctx> {
+    /// Attempt to convert an [`AnyObject`] into an [`NDArrayObject`].
+    pub fn from_object<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        object: AnyObject<'ctx>,
+    ) -> NDArrayObject<'ctx> {
+        let (dtype, ndims) = unpack_ndarray_var_tys(&mut ctx.unifier, object.ty);
+        let ndims = extract_ndims(&ctx.unifier, ndims);
+
+        let value = Ptr(Struct(NDArray)).check_value(generator, ctx.ctx, object.value).unwrap();
+        NDArrayObject { dtype, ndims, instance: value }
+    }
+
+    /// Get this ndarray's `ndims` as an LLVM constant.
+    pub fn ndims_llvm<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &'ctx Context,
+    ) -> Instance<'ctx, Int<SizeT>> {
+        Int(SizeT).const_int(generator, ctx, self.ndims, false)
+    }
+
+    /// Allocate an ndarray on the stack given its `ndims` and `dtype`.
+    ///
+    /// `shape` and `strides` will be automatically allocated onto the stack.
+    ///
+    /// The returned ndarray's content will be:
+    /// - `data`: uninitialized.
+    /// - `itemsize`: set to the `sizeof()` of `dtype`.
+    /// - `ndims`: set to the value of  `ndims`.
+    /// - `shape`: allocated with an array of length `ndims` with uninitialized values.
+    /// - `strides`: allocated with an array of length `ndims` with uninitialized values.
+    pub fn alloca<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        ndims: u64,
+    ) -> Self {
+        let ndarray = Struct(NDArray).alloca(generator, ctx);
+
+        let itemsize = ctx.get_llvm_type(generator, dtype).size_of().unwrap();
+        let itemsize = Int(SizeT).z_extend_or_truncate(generator, ctx, itemsize);
+        ndarray.set(ctx, |f| f.itemsize, itemsize);
+
+        let ndims_val = Int(SizeT).const_int(generator, ctx.ctx, ndims, false);
+        ndarray.set(ctx, |f| f.ndims, ndims_val);
+
+        let shape = Int(SizeT).array_alloca(generator, ctx, ndims_val.value);
+        ndarray.set(ctx, |f| f.shape, shape);
+
+        let strides = Int(SizeT).array_alloca(generator, ctx, ndims_val.value);
+        ndarray.set(ctx, |f| f.strides, strides);
+
+        NDArrayObject { dtype, ndims, instance: ndarray }
+    }
+
+    /// Convenience function. Allocate an [`NDArrayObject`] with a statically known shape.
+    ///
+    /// The returned [`NDArrayObject`]'s `data` and `strides` are uninitialized.
+    pub fn alloca_constant_shape<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        shape: &[u64],
+    ) -> Self {
+        let ndarray = NDArrayObject::alloca(generator, ctx, dtype, shape.len() as u64);
+
+        // Write shape
+        let dst_shape = ndarray.instance.get(generator, ctx, |f| f.shape);
+        for (i, dim) in shape.iter().enumerate() {
+            let dim = Int(SizeT).const_int(generator, ctx.ctx, *dim, false);
+            dst_shape.offset_const(ctx, i64::try_from(i).unwrap()).store(ctx, dim);
+        }
+
+        ndarray
+    }
+
+    /// Convenience function. Allocate an [`NDArrayObject`] with a dynamically known shape.
+    ///
+    /// The returned [`NDArrayObject`]'s `data` and `strides` are uninitialized.
+    pub fn alloca_dynamic_shape<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        shape: &[Instance<'ctx, Int<SizeT>>],
+    ) -> Self {
+        let ndarray = NDArrayObject::alloca(generator, ctx, dtype, shape.len() as u64);
+
+        // Write shape
+        let dst_shape = ndarray.instance.get(generator, ctx, |f| f.shape);
+        for (i, dim) in shape.iter().enumerate() {
+            dst_shape.offset_const(ctx, i64::try_from(i).unwrap()).store(ctx, *dim);
+        }
+
+        ndarray
+    }
+
+    /// Initialize an ndarray's `data` by allocating a buffer on the stack.
+    /// The allocated data buffer is considered to be *owned* by the ndarray.
+    ///
+    /// `strides` of the ndarray will also be updated with `set_strides_by_shape`.
+    ///
+    /// `shape` and `itemsize` of the ndarray ***must*** be initialized first.
+    pub fn create_data<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) {
+        let nbytes = self.nbytes(generator, ctx);
+
+        let data = Int(Byte).array_alloca(generator, ctx, nbytes.value);
+        self.instance.set(ctx, |f| f.data, data);
+
+        self.set_strides_contiguous(generator, ctx);
+    }
+
+    /// Copy shape dimensions from an array.
+    pub fn copy_shape_from_array<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        shape: Instance<'ctx, Ptr<Int<SizeT>>>,
+    ) {
+        let num_items = self.ndims_llvm(generator, ctx.ctx).value;
+        self.instance.get(generator, ctx, |f| f.shape).copy_from(generator, ctx, shape, num_items);
+    }
+
+    /// Copy shape dimensions from an ndarray.
+    /// Panics if `ndims` mismatches.
+    pub fn copy_shape_from_ndarray<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        src_ndarray: NDArrayObject<'ctx>,
+    ) {
+        assert_eq!(self.ndims, src_ndarray.ndims);
+        let src_shape = src_ndarray.instance.get(generator, ctx, |f| f.shape);
+        self.copy_shape_from_array(generator, ctx, src_shape);
+    }
+
+    /// Copy strides dimensions from an array.
+    pub fn copy_strides_from_array<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        strides: Instance<'ctx, Ptr<Int<SizeT>>>,
+    ) {
+        let num_items = self.ndims_llvm(generator, ctx.ctx).value;
+        self.instance
+            .get(generator, ctx, |f| f.strides)
+            .copy_from(generator, ctx, strides, num_items);
+    }
+
+    /// Copy strides dimensions from an ndarray.
+    /// Panics if `ndims` mismatches.
+    pub fn copy_strides_from_ndarray<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        src_ndarray: NDArrayObject<'ctx>,
+    ) {
+        assert_eq!(self.ndims, src_ndarray.ndims);
+        let src_strides = src_ndarray.instance.get(generator, ctx, |f| f.strides);
+        self.copy_strides_from_array(generator, ctx, src_strides);
+    }
+
+    /// Get the `np.size()` of this ndarray.
+    pub fn size<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> Instance<'ctx, Int<SizeT>> {
+        call_nac3_ndarray_size(generator, ctx, self.instance)
+    }
+
+    /// Get the `ndarray.nbytes` of this ndarray.
+    pub fn nbytes<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> Instance<'ctx, Int<SizeT>> {
+        call_nac3_ndarray_nbytes(generator, ctx, self.instance)
+    }
+
+    /// Get the `len()` of this ndarray.
+    pub fn len<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> Instance<'ctx, Int<SizeT>> {
+        call_nac3_ndarray_len(generator, ctx, self.instance)
+    }
+
+    /// Check if this ndarray is C-contiguous.
+    ///
+    /// See NumPy's `flags["C_CONTIGUOUS"]`: <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html#numpy.ndarray.flags>
+    pub fn is_c_contiguous<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> Instance<'ctx, Int<Bool>> {
+        call_nac3_ndarray_is_c_contiguous(generator, ctx, self.instance)
+    }
+
+    /// Get the pointer to the n-th (0-based) element.
+    ///
+    /// The returned pointer has the element type of the LLVM type of this ndarray's `dtype`.
+    pub fn get_nth_pelement<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        nth: Instance<'ctx, Int<SizeT>>,
+    ) -> PointerValue<'ctx> {
+        let elem_ty = ctx.get_llvm_type(generator, self.dtype);
+
+        let p = call_nac3_ndarray_get_nth_pelement(generator, ctx, self.instance, nth);
+        ctx.builder
+            .build_pointer_cast(p.value, elem_ty.ptr_type(AddressSpace::default()), "")
+            .unwrap()
+    }
+
+    /// Get the n-th (0-based) scalar.
+    pub fn get_nth_scalar<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        nth: Instance<'ctx, Int<SizeT>>,
+    ) -> AnyObject<'ctx> {
+        let ptr = self.get_nth_pelement(generator, ctx, nth);
+        let value = ctx.builder.build_load(ptr, "").unwrap();
+        AnyObject { ty: self.dtype, value }
+    }
+
+    /// Get the pointer to the element indexed by `indices`.
+    ///
+    /// The returned pointer has the element type of the LLVM type of this ndarray's `dtype`.
+    pub fn get_pelement_by_indices<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        indices: Instance<'ctx, Ptr<Int<SizeT>>>,
+    ) -> PointerValue<'ctx> {
+        let elem_ty = ctx.get_llvm_type(generator, self.dtype);
+
+        let p = call_nac3_ndarray_get_pelement_by_indices(generator, ctx, self.instance, indices);
+        ctx.builder
+            .build_pointer_cast(p.value, elem_ty.ptr_type(AddressSpace::default()), "")
+            .unwrap()
+    }
+
+    /// Get the scalar indexed by `indices`.
+    pub fn get_scalar_by_indices<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        indices: Instance<'ctx, Ptr<Int<SizeT>>>,
+    ) -> AnyObject<'ctx> {
+        let ptr = self.get_pelement_by_indices(generator, ctx, indices);
+        let value = ctx.builder.build_load(ptr, "").unwrap();
+        AnyObject { ty: self.dtype, value }
+    }
+
+    /// Call [`call_nac3_ndarray_set_strides_by_shape`] on this ndarray to update `strides`.
+    ///
+    /// Update the ndarray's strides to make the ndarray contiguous.
+    pub fn set_strides_contiguous<G: CodeGenerator + ?Sized>(
+        self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) {
+        call_nac3_ndarray_set_strides_by_shape(generator, ctx, self.instance);
+    }
+
+    /// Copy data from another ndarray.
+    ///
+    /// This ndarray and `src` is that their `np.size()` should be the same. Their shapes
+    /// do not matter. The copying order is determined by how their flattened views look.
+    ///
+    /// Panics if the `dtype`s of ndarrays are different.
+    pub fn copy_data_from<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        src: NDArrayObject<'ctx>,
+    ) {
+        assert!(ctx.unifier.unioned(self.dtype, src.dtype), "self and src dtype should match");
+        call_nac3_ndarray_copy_data(generator, ctx, src.instance, self.instance);
+    }
+
+    /// Fill the ndarray with a scalar.
+    ///
+    /// `fill_value` must have the same LLVM type as the `dtype` of this ndarray.
+    pub fn fill<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        value: BasicValueEnum<'ctx>,
+    ) {
+        self.foreach(generator, ctx, |generator, ctx, _hooks, nditer| {
+            let p = nditer.get_pointer(generator, ctx);
+            ctx.builder.build_store(p, value).unwrap();
+            Ok(())
+        })
+        .unwrap();
+    }
+}
--- a/nac3core/src/codegen/object/ndarray/nditer.rs
+++ b/nac3core/src/codegen/object/ndarray/nditer.rs
@ -0,0 +1,178 @@
+use inkwell::{types::BasicType, values::PointerValue, AddressSpace};
+
+use super::NDArrayObject;
+use crate::codegen::{
+    irrt::{call_nac3_nditer_has_element, call_nac3_nditer_initialize, call_nac3_nditer_next},
+    model::*,
+    object::any::AnyObject,
+    stmt::{gen_for_callback, BreakContinueHooks},
+    CodeGenContext, CodeGenerator,
+};
+
+/// Fields of [`NDIter`]
+pub struct NDIterFields<'ctx, F: FieldTraversal<'ctx>> {
+    pub ndims: F::Output<Int<SizeT>>,
+    pub shape: F::Output<Ptr<Int<SizeT>>>,
+    pub strides: F::Output<Ptr<Int<SizeT>>>,
+
+    pub indices: F::Output<Ptr<Int<SizeT>>>,
+    pub nth: F::Output<Int<SizeT>>,
+    pub element: F::Output<Ptr<Int<Byte>>>,
+
+    pub size: F::Output<Int<SizeT>>,
+}
+
+/// An IRRT helper structure used to iterate through an ndarray.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct NDIter;
+
+impl<'ctx> StructKind<'ctx> for NDIter {
+    type Fields<F: FieldTraversal<'ctx>> = NDIterFields<'ctx, F>;
+
+    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
+        Self::Fields {
+            ndims: traversal.add_auto("ndims"),
+            shape: traversal.add_auto("shape"),
+            strides: traversal.add_auto("strides"),
+
+            indices: traversal.add_auto("indices"),
+            nth: traversal.add_auto("nth"),
+            element: traversal.add_auto("element"),
+
+            size: traversal.add_auto("size"),
+        }
+    }
+}
+
+/// A helper structure with a convenient interface to interact with [`NDIter`].
+#[derive(Debug, Clone)]
+pub struct NDIterHandle<'ctx> {
+    instance: Instance<'ctx, Ptr<Struct<NDIter>>>,
+    /// The ndarray this [`NDIter`] to iterating over.
+    ndarray: NDArrayObject<'ctx>,
+    /// The current indices of [`NDIter`].
+    indices: Instance<'ctx, Ptr<Int<SizeT>>>,
+}
+
+impl<'ctx> NDIterHandle<'ctx> {
+    /// Allocate an [`NDIter`] that iterates through an ndarray.
+    pub fn new<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        ndarray: NDArrayObject<'ctx>,
+    ) -> Self {
+        let nditer = Struct(NDIter).alloca(generator, ctx);
+        let ndims = ndarray.ndims_llvm(generator, ctx.ctx);
+
+        // The caller has the responsibility to allocate 'indices' for `NDIter`.
+        let indices = Int(SizeT).array_alloca(generator, ctx, ndims.value);
+        call_nac3_nditer_initialize(generator, ctx, nditer, ndarray.instance, indices);
+
+        NDIterHandle { ndarray, instance: nditer, indices }
+    }
+
+    /// Is the current iteration valid?
+    ///
+    /// If true, then `element`, `indices` and `nth` contain details about the current element.
+    ///
+    /// If `ndarray` is unsized, this returns true only for the first iteration.
+    /// If `ndarray` is 0-sized, this always returns false.
+    #[must_use]
+    pub fn has_element<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> Instance<'ctx, Int<Bool>> {
+        call_nac3_nditer_has_element(generator, ctx, self.instance)
+    }
+
+    /// Go to the next element. If `has_element()` is false, then this has undefined behavior.
+    ///
+    /// If `ndarray` is unsized, this can only be called once.
+    /// If `ndarray` is 0-sized, this can never be called.
+    pub fn next<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) {
+        call_nac3_nditer_next(generator, ctx, self.instance);
+    }
+
+    /// Get pointer to the current element.
+    #[must_use]
+    pub fn get_pointer<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> PointerValue<'ctx> {
+        let elem_ty = ctx.get_llvm_type(generator, self.ndarray.dtype);
+
+        let p = self.instance.get(generator, ctx, |f| f.element);
+        ctx.builder
+            .build_pointer_cast(p.value, elem_ty.ptr_type(AddressSpace::default()), "element")
+            .unwrap()
+    }
+
+    /// Get the value of the current element.
+    #[must_use]
+    pub fn get_scalar<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> AnyObject<'ctx> {
+        let p = self.get_pointer(generator, ctx);
+        let value = ctx.builder.build_load(p, "value").unwrap();
+        AnyObject { ty: self.ndarray.dtype, value }
+    }
+
+    /// Get the index of the current element if this ndarray were a flat ndarray.
+    #[must_use]
+    pub fn get_index<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> Instance<'ctx, Int<SizeT>> {
+        self.instance.get(generator, ctx, |f| f.nth)
+    }
+
+    /// Get the indices of the current element.
+    #[must_use]
+    pub fn get_indices(&self) -> Instance<'ctx, Ptr<Int<SizeT>>> {
+        self.indices
+    }
+}
+
+impl<'ctx> NDArrayObject<'ctx> {
+    /// Iterate through every element in the ndarray.
+    ///
+    /// `body` has access to [`BreakContinueHooks`] to short-circuit and [`NDIterHandle`] to
+    /// get properties of the current iteration (e.g., the current element, indices, etc.)
+    pub fn foreach<'a, G, F>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, 'a>,
+        body: F,
+    ) -> Result<(), String>
+    where
+        G: CodeGenerator + ?Sized,
+        F: FnOnce(
+            &mut G,
+            &mut CodeGenContext<'ctx, 'a>,
+            BreakContinueHooks<'ctx>,
+            NDIterHandle<'ctx>,
+        ) -> Result<(), String>,
+    {
+        gen_for_callback(
+            generator,
+            ctx,
+            Some("ndarray_foreach"),
+            |generator, ctx| Ok(NDIterHandle::new(generator, ctx, *self)),
+            |generator, ctx, nditer| Ok(nditer.has_element(generator, ctx).value),
+            |generator, ctx, hooks, nditer| body(generator, ctx, hooks, nditer),
+            |generator, ctx, nditer| {
+                nditer.next(generator, ctx);
+                Ok(())
+            },
+        )
+    }
+}
--- a/nac3core/src/codegen/object/ndarray/shape_util.rs
+++ b/nac3core/src/codegen/object/ndarray/shape_util.rs
@ -0,0 +1,104 @@
+use crate::{
+    codegen::{
+        model::*,
+        object::{any::AnyObject, list::ListObject, tuple::TupleObject},
+        CodeGenContext, CodeGenerator,
+    },
+    typecheck::typedef::TypeEnum,
+};
+use util::gen_for_model;
+
+/// Parse a NumPy-like "int sequence" input and return the int sequence as an array and its length.
+///
+/// * `sequence` - The `sequence` parameter.
+/// * `sequence_ty` - The typechecker type of `sequence`
+///
+/// The `sequence` argument type may only be one of the following:
+///   1. A list of `int32`;   e.g., `np.empty([600, 800, 3])`
+///   2. A tuple of `int32`;  e.g., `np.empty((600, 800, 3))`
+///   3. A scalar `int32`;    e.g., `np.empty(3)`, this is functionally equivalent to `np.empty([3])`
+///
+/// All `int32` values will be sign-extended to `SizeT`.
+pub fn parse_numpy_int_sequence<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    input_sequence: AnyObject<'ctx>,
+) -> (Instance<'ctx, Int<SizeT>>, Instance<'ctx, Ptr<Int<SizeT>>>) {
+    let zero = Int(SizeT).const_0(generator, ctx.ctx);
+    let one = Int(SizeT).const_1(generator, ctx.ctx);
+
+    // The result `list` to return.
+    match &*ctx.unifier.get_ty(input_sequence.ty) {
+        TypeEnum::TObj { obj_id, .. }
+            if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
+        {
+            // 1. A list of `int32`; e.g., `np.empty([600, 800, 3])`
+
+            // Check `input_sequence`
+            let input_sequence = ListObject::from_object(generator, ctx, input_sequence);
+
+            let len = input_sequence.instance.get(generator, ctx, |f| f.len);
+            let result = Int(SizeT).array_alloca(generator, ctx, len.value);
+
+            // Load all the `int32`s from the input_sequence, cast them to `SizeT`, and store them into `result`
+            gen_for_model(generator, ctx, zero, len, one, |generator, ctx, _hooks, i| {
+                // Load the i-th int32 in the input sequence
+                let int = input_sequence
+                    .instance
+                    .get(generator, ctx, |f| f.items)
+                    .get_index(generator, ctx, i.value)
+                    .value
+                    .into_int_value();
+
+                // Cast to SizeT
+                let int = Int(SizeT).s_extend_or_bit_cast(generator, ctx, int);
+
+                // Store
+                result.set_index(ctx, i.value, int);
+
+                Ok(())
+            })
+            .unwrap();
+
+            (len, result)
+        }
+        TypeEnum::TTuple { .. } => {
+            // 2. A tuple of ints; e.g., `np.empty((600, 800, 3))`
+
+            let input_sequence = TupleObject::from_object(ctx, input_sequence);
+
+            let len = input_sequence.len(generator, ctx);
+
+            let result = Int(SizeT).array_alloca(generator, ctx, len.value);
+
+            for i in 0..input_sequence.num_elements() {
+                // Get the i-th element off of the tuple and load it into `result`.
+                let int = input_sequence.index(ctx, i).value.into_int_value();
+                let int = Int(SizeT).s_extend_or_bit_cast(generator, ctx, int);
+
+                result.set_index_const(ctx, i64::try_from(i).unwrap(), int);
+            }
+
+            (len, result)
+        }
+        TypeEnum::TObj { obj_id, .. }
+            if *obj_id == ctx.primitives.int32.obj_id(&ctx.unifier).unwrap() =>
+        {
+            // 3. A scalar int; e.g., `np.empty(3)`, this is functionally equivalent to `np.empty([3])`
+            let input_int = input_sequence.value.into_int_value();
+
+            let len = Int(SizeT).const_1(generator, ctx.ctx);
+            let result = Int(SizeT).array_alloca(generator, ctx, len.value);
+            let int = Int(SizeT).s_extend_or_bit_cast(generator, ctx, input_int);
+
+            // Storing into result[0]
+            result.store(ctx, int);
+
+            (len, result)
+        }
+        _ => panic!(
+            "encountered unknown sequence type: {}",
+            ctx.unifier.stringify(input_sequence.ty)
+        ),
+    }
+}
--- a/nac3core/src/codegen/object/tuple.rs
+++ b/nac3core/src/codegen/object/tuple.rs
@ -0,0 +1,98 @@
+use inkwell::values::StructValue;
+use itertools::Itertools;
+
+use super::any::AnyObject;
+use crate::{
+    codegen::{model::*, CodeGenContext, CodeGenerator},
+    typecheck::typedef::{Type, TypeEnum},
+};
+
+/// A NAC3 tuple object.
+///
+/// NOTE: This struct has no copy trait.
+#[derive(Debug, Clone)]
+pub struct TupleObject<'ctx> {
+    /// The type of the tuple.
+    pub tys: Vec<Type>,
+    /// The underlying LLVM struct value of this tuple.
+    pub value: StructValue<'ctx>,
+}
+
+impl<'ctx> TupleObject<'ctx> {
+    pub fn from_object(ctx: &mut CodeGenContext<'ctx, '_>, object: AnyObject<'ctx>) -> Self {
+        // TODO: Keep `is_vararg_ctx` from TTuple?
+
+        // Sanity check on object type.
+        let TypeEnum::TTuple { ty: tys, .. } = &*ctx.unifier.get_ty(object.ty) else {
+            panic!(
+                "Expected type to be a TypeEnum::TTuple, got {}",
+                ctx.unifier.stringify(object.ty)
+            );
+        };
+
+        // Check number of fields
+        let value = object.value.into_struct_value();
+        let value_num_fields = value.get_type().count_fields() as usize;
+        assert!(
+            value_num_fields == tys.len(),
+            "Tuple type has {} item(s), but the LLVM struct value has {} field(s)",
+            tys.len(),
+            value_num_fields
+        );
+
+        TupleObject { tys: tys.clone(), value }
+    }
+
+    /// Convenience function. Create a [`TupleObject`] from an iterator of objects.
+    pub fn from_objects<I, G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        objects: I,
+    ) -> Self
+    where
+        I: IntoIterator<Item = AnyObject<'ctx>>,
+    {
+        let (values, tys): (Vec<_>, Vec<_>) =
+            objects.into_iter().map(|object| (object.value, object.ty)).unzip();
+
+        let llvm_tys = tys.iter().map(|ty| ctx.get_llvm_type(generator, *ty)).collect_vec();
+        let llvm_tuple_ty = ctx.ctx.struct_type(&llvm_tys, false);
+
+        let pllvm_tuple = ctx.builder.build_alloca(llvm_tuple_ty, "tuple").unwrap();
+        for (i, val) in values.into_iter().enumerate() {
+            let pval = ctx.builder.build_struct_gep(pllvm_tuple, i as u32, "value").unwrap();
+            ctx.builder.build_store(pval, val).unwrap();
+        }
+
+        let value = ctx.builder.build_load(pllvm_tuple, "").unwrap().into_struct_value();
+        TupleObject { tys, value }
+    }
+
+    #[must_use]
+    pub fn num_elements(&self) -> usize {
+        self.tys.len()
+    }
+
+    /// Get the `len()` of this tuple.
+    #[must_use]
+    pub fn len<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> Instance<'ctx, Int<SizeT>> {
+        Int(SizeT).const_int(generator, ctx.ctx, self.num_elements() as u64, false)
+    }
+
+    /// Get the `i`-th (0-based) object in this tuple.
+    pub fn index(&self, ctx: &mut CodeGenContext<'ctx, '_>, i: usize) -> AnyObject<'ctx> {
+        assert!(
+            i < self.num_elements(),
+            "Tuple object with length {} have index {i}",
+            self.num_elements()
+        );
+
+        let value = ctx.builder.build_extract_value(self.value, i as u32, "tuple[{i}]").unwrap();
+        let ty = self.tys[i];
+        AnyObject { ty, value }
+    }
+}
--- a/nac3core/src/codegen/stmt.rs
+++ b/nac3core/src/codegen/stmt.rs
@ -1,3 +1,16 @@
+use inkwell::{
+    attributes::{Attribute, AttributeLoc},
+    basic_block::BasicBlock,
+    types::{BasicType, BasicTypeEnum},
+    values::{BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue},
+    IntPredicate,
+};
+use itertools::{izip, Itertools};
+
+use nac3parser::ast::{
+    Constant, ExcepthandlerKind, Expr, ExprKind, Location, Stmt, StmtKind, StrRef,
+};
+
 use super::{
    classes::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
    expr::{destructure_range, gen_binop_expr},
@ -14,17 +27,6 @@ use crate::{
        typedef::{iter_type_vars, FunSignature, Type, TypeEnum},
    },
 };
-use inkwell::{
-    attributes::{Attribute, AttributeLoc},
-    basic_block::BasicBlock,
-    types::{BasicType, BasicTypeEnum},
-    values::{BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue},
-    IntPredicate,
-};
-use itertools::{izip, Itertools};
-use nac3parser::ast::{
-    Constant, ExcepthandlerKind, Expr, ExprKind, Location, Stmt, StmtKind, StrRef,
-};

 /// See [`CodeGenerator::gen_var_alloc`].
 pub fn gen_var<'ctx>(
@ -1826,6 +1828,37 @@ pub fn gen_stmt<G: CodeGenerator>(
                stmt.location,
            );
        }
+        StmtKind::Global { names, .. } => {
+            let registered_globals = ctx
+                .top_level
+                .definitions
+                .read()
+                .iter()
+                .filter_map(|def| {
+                    if let TopLevelDef::Variable { simple_name, ty, .. } = &*def.read() {
+                        Some((*simple_name, *ty))
+                    } else {
+                        None
+                    }
+                })
+                .collect_vec();
+
+            for id in names {
+                let Some((_, ty)) = registered_globals.iter().find(|(name, _)| name == id) else {
+                    return Err(format!("{id} is not a global at {}", stmt.location));
+                };
+
+                let resolver = ctx.resolver.clone();
+                let ptr = resolver
+                    .get_symbol_value(*id, ctx, generator)
+                    .map(|val| val.to_basic_value_enum(ctx, generator, *ty))
+                    .transpose()?
+                    .map(BasicValueEnum::into_pointer_value)
+                    .unwrap();
+
+                ctx.var_assignment.insert(*id, (ptr, None, 0));
+            }
+        }
        _ => unimplemented!(),
    };
    Ok(())
--- a/nac3core/src/codegen/test.rs
+++ b/nac3core/src/codegen/test.rs
@ -1,3 +1,20 @@
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+
+use indexmap::IndexMap;
+use indoc::indoc;
+use inkwell::{
+    targets::{InitializationConfig, Target},
+    OptimizationLevel,
+};
+use nac3parser::{
+    ast::{fold::Fold, FileName, StrRef},
+    parser::parse_program,
+};
+use parking_lot::RwLock;
+
 use crate::{
    codegen::{
        classes::{ListType, NDArrayType, ProxyType, RangeType},
@ -11,24 +28,10 @@ use crate::{
        DefinitionId, FunInstance, TopLevelContext, TopLevelDef,
    },
    typecheck::{
-        type_inferencer::{FunctionData, Inferencer, PrimitiveStore},
+        type_inferencer::{FunctionData, IdentifierInfo, Inferencer, PrimitiveStore},
        typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
    },
 };
-use indexmap::IndexMap;
-use indoc::indoc;
-use inkwell::{
-    targets::{InitializationConfig, Target},
-    OptimizationLevel,
-};
-use nac3parser::ast::FileName;
-use nac3parser::{
-    ast::{fold::Fold, StrRef},
-    parser::parse_program,
-};
-use parking_lot::RwLock;
-use std::collections::{HashMap, HashSet};
-use std::sync::Arc;

 struct Resolver {
    id_to_type: HashMap<StrRef, Type>,
@ -64,6 +67,7 @@ impl SymbolResolver for Resolver {
        &self,
        _: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
+        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        unimplemented!()
    }
@ -138,7 +142,8 @@ fn test_primitives() {
    };
    let mut virtual_checks = Vec::new();
    let mut calls = HashMap::new();
-    let mut identifiers: HashSet<_> = ["a".into(), "b".into()].into();
+    let mut identifiers: HashMap<_, _> =
+        ["a".into(), "b".into()].map(|id| (id, IdentifierInfo::default())).into();
    let mut inferencer = Inferencer {
        top_level: &top_level,
        function_data: &mut function_data,
@ -317,7 +322,8 @@ fn test_simple_call() {
    };
    let mut virtual_checks = Vec::new();
    let mut calls = HashMap::new();
-    let mut identifiers: HashSet<_> = ["a".into(), "foo".into()].into();
+    let mut identifiers: HashMap<_, _> =
+        ["a".into(), "foo".into()].map(|id| (id, IdentifierInfo::default())).into();
    let mut inferencer = Inferencer {
        top_level: &top_level,
        function_data: &mut function_data,
--- a/nac3core/src/lib.rs
+++ b/nac3core/src/lib.rs
@ -19,6 +19,10 @@
    clippy::wildcard_imports
 )]

+// users of nac3core need to use the same version of these dependencies, so expose them as nac3core::*
+pub use inkwell;
+pub use nac3parser;
+
 pub mod codegen;
 pub mod symbol_resolver;
 pub mod toplevel;
--- a/nac3core/src/symbol_resolver.rs
+++ b/nac3core/src/symbol_resolver.rs
@ -1,7 +1,15 @@
-use std::fmt::Debug;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::{collections::HashMap, collections::HashSet, fmt::Display};
+use std::{
+    collections::{HashMap, HashSet},
+    fmt::{Debug, Display},
+    rc::Rc,
+    sync::Arc,
+};
+
+use inkwell::values::{BasicValueEnum, FloatValue, IntValue, PointerValue, StructValue};
+use itertools::{chain, izip, Itertools};
+use parking_lot::RwLock;
+
+use nac3parser::ast::{Constant, Expr, Location, StrRef};

 use crate::{
    codegen::{CodeGenContext, CodeGenerator},
@ -11,10 +19,6 @@ use crate::{
        typedef::{Type, TypeEnum, Unifier, VarMap},
    },
 };
-use inkwell::values::{BasicValueEnum, FloatValue, IntValue, PointerValue, StructValue};
-use itertools::{chain, izip, Itertools};
-use nac3parser::ast::{Constant, Expr, Location, StrRef};
-use parking_lot::RwLock;

 #[derive(Clone, PartialEq, Debug)]
 pub enum SymbolValue {
@ -365,6 +369,7 @@ pub trait SymbolResolver {
        &self,
        str: StrRef,
        ctx: &mut CodeGenContext<'ctx, '_>,
+        generator: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>>;

    fn get_default_param_value(&self, expr: &Expr) -> Option<SymbolValue>;
--- a/nac3core/src/toplevel/builtins.rs
+++ b/nac3core/src/toplevel/builtins.rs
@ -1,6 +1,5 @@
 use std::iter::once;

-use helper::{debug_assert_prim_is_allowed, make_exception_fields, PrimDefDetails};
 use indexmap::IndexMap;
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
@ -11,6 +10,10 @@ use inkwell::{
 use itertools::Either;
 use strum::IntoEnumIterator;

+use super::{
+    helper::{debug_assert_prim_is_allowed, make_exception_fields, PrimDefDetails},
+    *,
+};
 use crate::{
    codegen::{
        builtin_fns,
@ -23,8 +26,6 @@ use crate::{
    typecheck::typedef::{into_var_map, iter_type_vars, TypeVar, VarMap},
 };

-use super::*;
-
 type BuiltinInfo = Vec<(Arc<RwLock<TopLevelDef>>, Option<Stmt>)>;

 pub fn get_exn_constructor(
--- a/nac3core/src/toplevel/composer.rs
+++ b/nac3core/src/toplevel/composer.rs
@ -1,17 +1,17 @@
-use nac3parser::ast::fold::Fold;
 use std::rc::Rc;

+use nac3parser::ast::{fold::Fold, ExprKind};
+
+use super::*;
 use crate::{
    codegen::{expr::get_subst_key, stmt::exn_constructor},
    symbol_resolver::SymbolValue,
    typecheck::{
-        type_inferencer::{FunctionData, Inferencer},
+        type_inferencer::{FunctionData, IdentifierInfo, Inferencer},
        typedef::{TypeVar, VarMap},
    },
 };

-use super::*;
-
 pub struct ComposerConfig {
    pub kernel_ann: Option<&'static str>,
    pub kernel_invariant_ann: &'static str,
@ -101,7 +101,8 @@ impl TopLevelComposer {
            .iter()
            .map(|def_ast| match *def_ast.0.read() {
                TopLevelDef::Class { name, .. } => name.to_string(),
-                TopLevelDef::Function { simple_name, .. } => simple_name.to_string(),
+                TopLevelDef::Function { simple_name, .. }
+                | TopLevelDef::Variable { simple_name, .. } => simple_name.to_string(),
            })
            .collect_vec();

@ -381,8 +382,58 @@ impl TopLevelComposer {
                ))
            }

+            ast::StmtKind::AnnAssign { target, annotation, .. } => {
+                let ExprKind::Name { id: name, .. } = target.node else {
+                    return Err(format!(
+                        "global variable declaration must be an identifier (at {})",
+                        ast.location
+                    ));
+                };
+
+                if self.keyword_list.contains(&name) {
+                    return Err(format!(
+                        "cannot use keyword `{}` as a class name (at {})",
+                        name,
+                        ast.location
+                    ));
+                }
+
+                let global_var_name = if mod_path.is_empty() {
+                    name.to_string()
+                } else {
+                    format!("{mod_path}.{name}")
+                };
+                if !defined_names.insert(global_var_name.clone()) {
+                    return Err(format!(
+                        "global variable `{}` defined twice (at {})",
+                        global_var_name,
+                        ast.location
+                    ));
+                }
+
+                let ty_to_be_unified = self.unifier.get_dummy_var().ty;
+                self.definition_ast_list.push((
+                    RwLock::new(Self::make_top_level_variable_def(
+                        global_var_name,
+                        name,
+                        // dummy here, unify with correct type later,
+                        ty_to_be_unified,
+                        *(annotation.clone()),
+                        resolver,
+                        Some(ast.location),
+                    )).into(),
+                    None,
+                ));
+
+                Ok((
+                    name,
+                    DefinitionId(self.definition_ast_list.len() - 1),
+                    Some(ty_to_be_unified),
+                ))
+            }
+
            _ => Err(format!(
-                "registrations of constructs other than top level classes/functions are not supported (at {})",
+                "registrations of constructs other than top level classes/functions/variables are not supported (at {})",
                ast.location
            )),
        }
@ -396,6 +447,7 @@ impl TopLevelComposer {
        if inference {
            self.analyze_function_instance()?;
        }
+        self.analyze_top_level_variables()?;
        Ok(())
    }

@ -500,6 +552,7 @@ impl TopLevelComposer {
            }
            Ok(())
        };
+
        let mut errors = HashSet::new();
        for (class_def, class_ast) in def_list.iter().skip(self.builtin_num) {
            if class_ast.is_none() {
@ -853,7 +906,6 @@ impl TopLevelComposer {
        let unifier = self.unifier.borrow_mut();
        let primitives_store = &self.primitives_ty;

-        let mut errors = HashSet::new();
        let mut analyze = |function_def: &Arc<RwLock<TopLevelDef>>, function_ast: &Option<Stmt>| {
            let mut function_def = function_def.write();
            let function_def = &mut *function_def;
@ -1128,6 +1180,8 @@ impl TopLevelComposer {
            })?;
            Ok(())
        };
+
+        let mut errors = HashSet::new();
        for (function_def, function_ast) in def_list.iter().skip(self.builtin_num) {
            if function_ast.is_none() {
                continue;
@ -1702,7 +1756,6 @@ impl TopLevelComposer {
            }
        }

-        let mut errors = HashSet::new();
        let mut analyze = |i, def: &Arc<RwLock<TopLevelDef>>, ast: &Option<Stmt>| {
            let class_def = def.read();
            if let TopLevelDef::Class {
@ -1845,6 +1898,8 @@ impl TopLevelComposer {
            }
            Ok(())
        };
+
+        let mut errors = HashSet::new();
        for (i, (def, ast)) in definition_ast_list.iter().enumerate().skip(self.builtin_num) {
            if ast.is_none() {
                continue;
@ -1894,7 +1949,8 @@ impl TopLevelComposer {
            } = &mut *function_def
            {
                let signature_ty_enum = unifier.get_ty(*signature);
-                let TypeEnum::TFunc(FunSignature { args, ret, vars }) = signature_ty_enum.as_ref()
+                let TypeEnum::TFunc(FunSignature { args, ret, vars, .. }) =
+                    signature_ty_enum.as_ref()
                else {
                    unreachable!("must be typeenum::tfunc")
                };
@ -2002,11 +2058,12 @@ impl TopLevelComposer {
                        })
                    };
                    let mut identifiers = {
-                        let mut result: HashSet<_> = HashSet::new();
+                        let mut result = HashMap::new();
                        if self_type.is_some() {
-                            result.insert("self".into());
+                            result.insert("self".into(), IdentifierInfo::default());
                        }
-                        result.extend(inst_args.iter().map(|x| x.name));
+                        result
+                            .extend(inst_args.iter().map(|x| (x.name, IdentifierInfo::default())));
                        result
                    };
                    let mut calls: HashMap<CodeLocation, CallId> = HashMap::new();
@ -2057,6 +2114,16 @@ impl TopLevelComposer {
                        instance_to_symbol.insert(String::new(), simple_name.to_string());
                        continue;
                    }
+                    if !decorator_list.is_empty() {
+                        if let ast::ExprKind::Call { func, .. } = &decorator_list[0].node {
+                            if matches!(&func.node,
+                                ast::ExprKind::Name{ id, .. } if id == &"rpc".into())
+                            {
+                                instance_to_symbol.insert(String::new(), simple_name.to_string());
+                                continue;
+                            }
+                        }
+                    }

                    let fun_body = body
                        .into_iter()
@ -2161,4 +2228,57 @@ impl TopLevelComposer {
        }
        Ok(())
    }
+
+    /// Step 6. Analyze and populate the types of global variables.
+    fn analyze_top_level_variables(&mut self) -> Result<(), HashSet<String>> {
+        let def_list = &self.definition_ast_list;
+        let temp_def_list = self.extract_def_list();
+        let unifier = &mut self.unifier;
+        let primitives_store = &self.primitives_ty;
+
+        let mut analyze = |variable_def: &Arc<RwLock<TopLevelDef>>| -> Result<_, HashSet<String>> {
+            let variable_def = &mut *variable_def.write();
+
+            let TopLevelDef::Variable { ty: dummy_ty, ty_decl, resolver, loc, .. } = variable_def
+            else {
+                // not top level variable def, skip
+                return Ok(());
+            };
+
+            let resolver = &**resolver.as_ref().unwrap();
+
+            let ty_annotation = parse_ast_to_type_annotation_kinds(
+                resolver,
+                &temp_def_list,
+                unifier,
+                primitives_store,
+                ty_decl,
+                HashMap::new(),
+            )?;
+            let ty_from_ty_annotation = get_type_from_type_annotation_kinds(
+                &temp_def_list,
+                unifier,
+                primitives_store,
+                &ty_annotation,
+                &mut None,
+            )?;
+
+            unifier.unify(*dummy_ty, ty_from_ty_annotation).map_err(|e| {
+                HashSet::from([e.at(Some(loc.unwrap())).to_display(unifier).to_string()])
+            })?;
+            Ok(())
+        };
+
+        let mut errors = HashSet::new();
+        for (variable_def, _) in def_list.iter().skip(self.builtin_num) {
+            if let Err(e) = analyze(variable_def) {
+                errors.extend(e);
+            }
+        }
+        if !errors.is_empty() {
+            return Err(errors);
+        }
+
+        Ok(())
+    }
 }
--- a/nac3core/src/toplevel/helper.rs
+++ b/nac3core/src/toplevel/helper.rs
@ -1,14 +1,17 @@
 use std::convert::TryInto;

-use crate::symbol_resolver::SymbolValue;
-use crate::toplevel::numpy::unpack_ndarray_var_tys;
-use crate::typecheck::typedef::{into_var_map, iter_type_vars, Mapping, TypeVarId, VarMap};
-use ast::ExprKind;
-use nac3parser::ast::{Constant, Location};
 use strum::IntoEnumIterator;
 use strum_macros::EnumIter;

+use ast::ExprKind;
+use nac3parser::ast::{Constant, Location};
+
 use super::*;
+use crate::{
+    symbol_resolver::SymbolValue,
+    toplevel::numpy::unpack_ndarray_var_tys,
+    typecheck::typedef::{into_var_map, iter_type_vars, Mapping, TypeVarId, VarMap},
+};

 /// All primitive types and functions in nac3core.
 #[derive(Clone, Copy, Debug, EnumIter, PartialEq, Eq)]
@ -388,6 +391,9 @@ impl TopLevelDef {
                    r
                }
            ),
+            TopLevelDef::Variable { name, ty, .. } => {
+                format!("Variable {{ name: {name:?}, ty: {:?} }}", unifier.stringify(*ty),)
+            }
        }
    }
 }
@ -589,6 +595,18 @@ impl TopLevelComposer {
        }
    }

+    #[must_use]
+    pub fn make_top_level_variable_def(
+        name: String,
+        simple_name: StrRef,
+        ty: Type,
+        ty_decl: Expr,
+        resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
+        loc: Option<Location>,
+    ) -> TopLevelDef {
+        TopLevelDef::Variable { name, simple_name, ty, ty_decl, resolver, loc }
+    }
+
    #[must_use]
    pub fn make_class_method_name(mut class_name: String, method_name: &str) -> String {
        class_name.push('.');
@ -1118,3 +1136,23 @@ pub fn arraylike_get_ndims(unifier: &mut Unifier, ty: Type) -> u64 {
        _ => 0,
    }
 }
+
+/// Extract an ndarray's `ndims` [type][`Type`] in `u64`. Panic if not possible.
+/// The `ndims` must only contain 1 value.
+#[must_use]
+pub fn extract_ndims(unifier: &Unifier, ndims_ty: Type) -> u64 {
+    let ndims_ty_enum = unifier.get_ty_immutable(ndims_ty);
+    let TypeEnum::TLiteral { values, .. } = &*ndims_ty_enum else {
+        panic!("ndims_ty should be a TLiteral");
+    };
+
+    assert_eq!(values.len(), 1, "ndims_ty TLiteral should only contain 1 value");
+
+    let ndims = values[0].clone();
+    u64::try_from(ndims).unwrap()
+}
+
+/// Return an ndarray's `ndims` as a typechecker [`Type`] from its `u64` value.
+pub fn create_ndims(unifier: &mut Unifier, ndims: u64) -> Type {
+    unifier.get_fresh_literal(vec![SymbolValue::U64(ndims)], None)
+}
--- a/nac3core/src/toplevel/mod.rs
+++ b/nac3core/src/toplevel/mod.rs
@ -6,24 +6,24 @@ use std::{
    sync::Arc,
 };

-use super::codegen::CodeGenContext;
-use super::typecheck::type_inferencer::PrimitiveStore;
-use super::typecheck::typedef::{
-    FunSignature, FuncArg, SharedUnifier, Type, TypeEnum, Unifier, VarMap,
-};
-use crate::{
-    codegen::CodeGenerator,
-    symbol_resolver::{SymbolResolver, ValueEnum},
-    typecheck::{
-        type_inferencer::CodeLocation,
-        typedef::{CallId, TypeVarId},
-    },
-};
 use inkwell::values::BasicValueEnum;
 use itertools::Itertools;
-use nac3parser::ast::{self, Location, Stmt, StrRef};
 use parking_lot::RwLock;

+use nac3parser::ast::{self, Expr, Location, Stmt, StrRef};
+
+use crate::{
+    codegen::{CodeGenContext, CodeGenerator},
+    symbol_resolver::{SymbolResolver, ValueEnum},
+    typecheck::{
+        type_inferencer::{CodeLocation, PrimitiveStore},
+        typedef::{
+            CallId, FunSignature, FuncArg, SharedUnifier, Type, TypeEnum, TypeVarId, Unifier,
+            VarMap,
+        },
+    },
+};
+
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash, Debug)]
 pub struct DefinitionId(pub usize);

@ -148,6 +148,25 @@ pub enum TopLevelDef {
        /// Definition location.
        loc: Option<Location>,
    },
+    Variable {
+        /// Qualified name of the global variable, should be unique globally.
+        name: String,
+
+        /// Simple name, the same as in method/function definition.
+        simple_name: StrRef,
+
+        /// Type of the global variable.
+        ty: Type,
+
+        /// The declared type of the global variable.
+        ty_decl: Expr,
+
+        /// Symbol resolver of the module defined the class.
+        resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
+
+        /// Definition location.
+        loc: Option<Location>,
+    },
 }

 pub struct TopLevelContext {
--- a/nac3core/src/toplevel/numpy.rs
+++ b/nac3core/src/toplevel/numpy.rs
@ -1,3 +1,5 @@
+use itertools::Itertools;
+
 use crate::{
    toplevel::helper::PrimDef,
    typecheck::{
@ -5,7 +7,6 @@ use crate::{
        typedef::{Type, TypeEnum, TypeVarId, Unifier, VarMap},
    },
 };
-use itertools::Itertools;

 /// Creates a `ndarray` [`Type`] with the given type arguments.
 ///
--- a/nac3core/src/toplevel/test.rs
+++ b/nac3core/src/toplevel/test.rs
@ -1,21 +1,24 @@
+use std::{collections::HashMap, sync::Arc};
+
+use indoc::indoc;
+use parking_lot::Mutex;
+use test_case::test_case;
+
+use nac3parser::{
+    ast::{fold::Fold, FileName},
+    parser::parse_program,
+};
+
 use super::*;
-use crate::toplevel::helper::PrimDef;
-use crate::typecheck::typedef::into_var_map;
 use crate::{
    codegen::CodeGenContext,
    symbol_resolver::{SymbolResolver, ValueEnum},
-    toplevel::DefinitionId,
+    toplevel::{helper::PrimDef, DefinitionId},
    typecheck::{
        type_inferencer::PrimitiveStore,
-        typedef::{Type, Unifier},
+        typedef::{into_var_map, Type, Unifier},
    },
 };
-use indoc::indoc;
-use nac3parser::ast::FileName;
-use nac3parser::{ast::fold::Fold, parser::parse_program};
-use parking_lot::Mutex;
-use std::{collections::HashMap, sync::Arc};
-use test_case::test_case;

 struct ResolverInternal {
    id_to_type: Mutex<HashMap<StrRef, Type>>,
@ -62,6 +65,7 @@ impl SymbolResolver for Resolver {
        &self,
        _: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
+        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        unimplemented!()
    }
--- a/nac3core/src/toplevel/type_annotation.rs
+++ b/nac3core/src/toplevel/type_annotation.rs
@ -1,10 +1,14 @@
-use super::*;
-use crate::symbol_resolver::SymbolValue;
-use crate::toplevel::helper::{PrimDef, PrimDefDetails};
-use crate::typecheck::typedef::VarMap;
-use nac3parser::ast::Constant;
 use strum::IntoEnumIterator;

+use nac3parser::ast::Constant;
+
+use super::*;
+use crate::{
+    symbol_resolver::SymbolValue,
+    toplevel::helper::{PrimDef, PrimDefDetails},
+    typecheck::typedef::VarMap,
+};
+
 #[derive(Clone, Debug)]
 pub enum TypeAnnotation {
    Primitive(Type),
--- a/nac3core/src/typecheck/function_check.rs
+++ b/nac3core/src/typecheck/function_check.rs
@ -1,13 +1,19 @@
-use crate::toplevel::helper::PrimDef;
+use std::{
+    collections::{HashMap, HashSet},
+    iter::once,
+};

-use super::type_inferencer::Inferencer;
-use super::typedef::{Type, TypeEnum};
 use nac3parser::ast::{
    self, Constant, Expr, ExprKind,
    Operator::{LShift, RShift},
    Stmt, StmtKind, StrRef,
 };
-use std::{collections::HashSet, iter::once};
+
+use super::{
+    type_inferencer::{IdentifierInfo, Inferencer},
+    typedef::{Type, TypeEnum},
+};
+use crate::toplevel::helper::PrimDef;

 impl<'a> Inferencer<'a> {
    fn should_have_value(&mut self, expr: &Expr<Option<Type>>) -> Result<(), HashSet<String>> {
@ -21,15 +27,15 @@ impl<'a> Inferencer<'a> {
    fn check_pattern(
        &mut self,
        pattern: &Expr<Option<Type>>,
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<(), HashSet<String>> {
        match &pattern.node {
            ExprKind::Name { id, .. } if id == &"none".into() => {
                Err(HashSet::from([format!("cannot assign to a `none` (at {})", pattern.location)]))
            }
            ExprKind::Name { id, .. } => {
-                if !defined_identifiers.contains(id) {
-                    defined_identifiers.insert(*id);
+                if !defined_identifiers.contains_key(id) {
+                    defined_identifiers.insert(*id, IdentifierInfo::default());
                }
                self.should_have_value(pattern)?;
                Ok(())
@ -69,7 +75,7 @@ impl<'a> Inferencer<'a> {
    fn check_expr(
        &mut self,
        expr: &Expr<Option<Type>>,
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<(), HashSet<String>> {
        // there are some cases where the custom field is None
        if let Some(ty) = &expr.custom {
@ -90,7 +96,7 @@ impl<'a> Inferencer<'a> {
                    return Ok(());
                }
                self.should_have_value(expr)?;
-                if !defined_identifiers.contains(id) {
+                if !defined_identifiers.contains_key(id) {
                    match self.function_data.resolver.get_symbol_type(
                        self.unifier,
                        &self.top_level.definitions.read(),
@ -98,7 +104,7 @@ impl<'a> Inferencer<'a> {
                        *id,
                    ) {
                        Ok(_) => {
-                            self.defined_identifiers.insert(*id);
+                            self.defined_identifiers.insert(*id, IdentifierInfo::default());
                        }
                        Err(e) => {
                            return Err(HashSet::from([format!(
@ -171,9 +177,7 @@ impl<'a> Inferencer<'a> {
                let mut defined_identifiers = defined_identifiers.clone();
                for arg in &args.args {
                    // TODO: should we check the types here?
-                    if !defined_identifiers.contains(&arg.node.arg) {
-                        defined_identifiers.insert(arg.node.arg);
-                    }
+                    defined_identifiers.entry(arg.node.arg).or_default();
                }
                self.check_expr(body, &mut defined_identifiers)?;
            }
@ -236,7 +240,7 @@ impl<'a> Inferencer<'a> {
    fn check_stmt(
        &mut self,
        stmt: &Stmt<Option<Type>>,
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<bool, HashSet<String>> {
        match &stmt.node {
            StmtKind::For { target, iter, body, orelse, .. } => {
@ -262,9 +266,11 @@ impl<'a> Inferencer<'a> {
                let body_returned = self.check_block(body, &mut body_identifiers)?;
                let orelse_returned = self.check_block(orelse, &mut orelse_identifiers)?;

-                for ident in &body_identifiers {
-                    if !defined_identifiers.contains(ident) && orelse_identifiers.contains(ident) {
-                        defined_identifiers.insert(*ident);
+                for ident in body_identifiers.keys() {
+                    if !defined_identifiers.contains_key(ident)
+                        && orelse_identifiers.contains_key(ident)
+                    {
+                        defined_identifiers.insert(*ident, IdentifierInfo::default());
                    }
                }
                Ok(body_returned && orelse_returned)
@ -295,7 +301,7 @@ impl<'a> Inferencer<'a> {
                    let mut defined_identifiers = defined_identifiers.clone();
                    let ast::ExcepthandlerKind::ExceptHandler { name, body, .. } = &handler.node;
                    if let Some(name) = name {
-                        defined_identifiers.insert(*name);
+                        defined_identifiers.insert(*name, IdentifierInfo::default());
                    }
                    self.check_block(body, &mut defined_identifiers)?;
                }
@ -359,6 +365,40 @@ impl<'a> Inferencer<'a> {
                }
                Ok(true)
            }
+            StmtKind::Global { names, .. } => {
+                for id in names {
+                    if let Some(id_info) = defined_identifiers.get(id) {
+                        if !id_info.is_global {
+                            return Err(HashSet::from([format!(
+                                "name '{id}' is assigned to before global declaration at {}",
+                                stmt.location,
+                            )]));
+                        }
+
+                        continue;
+                    }
+
+                    match self.function_data.resolver.get_symbol_type(
+                        self.unifier,
+                        &self.top_level.definitions.read(),
+                        self.primitives,
+                        *id,
+                    ) {
+                        Ok(_) => {
+                            self.defined_identifiers
+                                .insert(*id, IdentifierInfo { is_global: true });
+                        }
+                        Err(e) => {
+                            return Err(HashSet::from([format!(
+                                "type error at identifier `{}` ({}) at {}",
+                                id, e, stmt.location
+                            )]))
+                        }
+                    }
+                }
+
+                Ok(false)
+            }
            // break, raise, etc.
            _ => Ok(false),
        }
@ -367,7 +407,7 @@ impl<'a> Inferencer<'a> {
    pub fn check_block(
        &mut self,
        block: &[Stmt<Option<Type>>],
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<bool, HashSet<String>> {
        let mut ret = false;
        for stmt in block {
--- a/nac3core/src/typecheck/magic_methods.rs
+++ b/nac3core/src/typecheck/magic_methods.rs
@ -1,17 +1,21 @@
-use crate::symbol_resolver::SymbolValue;
-use crate::toplevel::helper::PrimDef;
-use crate::toplevel::numpy::{make_ndarray_ty, unpack_ndarray_var_tys};
-use crate::typecheck::{
+use std::{cmp::max, collections::HashMap, rc::Rc};
+
+use itertools::{iproduct, Itertools};
+use strum::IntoEnumIterator;
+
+use nac3parser::ast::{Cmpop, Operator, StrRef, Unaryop};
+
+use crate::{
+    symbol_resolver::SymbolValue,
+    toplevel::{
+        helper::PrimDef,
+        numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
+    },
+    typecheck::{
        type_inferencer::*,
        typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
+    },
 };
-use itertools::{iproduct, Itertools};
-use nac3parser::ast::StrRef;
-use nac3parser::ast::{Cmpop, Operator, Unaryop};
-use std::cmp::max;
-use std::collections::HashMap;
-use std::rc::Rc;
-use strum::IntoEnumIterator;

 /// The variant of a binary operator.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
--- a/nac3core/src/typecheck/type_error.rs
+++ b/nac3core/src/typecheck/type_error.rs
@ -1,14 +1,14 @@
-use std::collections::HashMap;
-use std::fmt::Display;
+use std::{collections::HashMap, fmt::Display};

-use crate::typecheck::{magic_methods::HasOpInfo, typedef::TypeEnum};
+use itertools::Itertools;
+
+use nac3parser::ast::{Cmpop, Location, StrRef};

 use super::{
    magic_methods::Binop,
    typedef::{RecordKey, Type, Unifier},
 };
-use itertools::Itertools;
-use nac3parser::ast::{Cmpop, Location, StrRef};
+use crate::typecheck::{magic_methods::HasOpInfo, typedef::TypeEnum};

 #[derive(Debug, Clone)]
 pub enum TypeErrorKind {
--- a/nac3core/src/typecheck/type_inferencer/mod.rs
+++ b/nac3core/src/typecheck/type_inferencer/mod.rs
@ -1,32 +1,36 @@
-use std::cmp::max;
-use std::collections::{HashMap, HashSet};
-use std::convert::{From, TryInto};
-use std::iter::once;
-use std::{cell::RefCell, sync::Arc};
+use std::{
+    cell::RefCell,
+    cmp::max,
+    collections::{HashMap, HashSet},
+    convert::{From, TryInto},
+    iter::once,
+    sync::Arc,
+};
+
+use itertools::{izip, Itertools};
+
+use nac3parser::ast::{
+    self,
+    fold::{self, Fold},
+    Arguments, Comprehension, ExprContext, ExprKind, Located, Location, StrRef,
+};

 use super::{
    magic_methods::*,
    type_error::{TypeError, TypeErrorKind},
    typedef::{
-        into_var_map, iter_type_vars, Call, CallId, FunSignature, FuncArg, OperatorInfo,
+        into_var_map, iter_type_vars, Call, CallId, FunSignature, FuncArg, Mapping, OperatorInfo,
        RecordField, RecordKey, Type, TypeEnum, TypeVar, Unifier, VarMap,
    },
 };
-use crate::toplevel::type_annotation::TypeAnnotation;
 use crate::{
    symbol_resolver::{SymbolResolver, SymbolValue},
    toplevel::{
        helper::{arraylike_flatten_element_type, arraylike_get_ndims, PrimDef},
        numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
+        type_annotation::TypeAnnotation,
        TopLevelContext, TopLevelDef,
    },
-    typecheck::typedef::Mapping,
-};
-use itertools::{izip, Itertools};
-use nac3parser::ast::{
-    self,
-    fold::{self, Fold},
-    Arguments, Comprehension, ExprContext, ExprKind, Located, Location, StrRef,
 };

 #[cfg(test)]
@ -84,6 +88,20 @@ impl PrimitiveStore {
    }
 }

+/// Information regarding a defined identifier.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct IdentifierInfo {
+    /// Whether this identifier refers to a global variable.
+    pub is_global: bool,
+}
+
+impl IdentifierInfo {
+    #[must_use]
+    pub fn new() -> IdentifierInfo {
+        IdentifierInfo::default()
+    }
+}
+
 pub struct FunctionData {
    pub resolver: Arc<dyn SymbolResolver + Send + Sync>,
    pub return_type: Option<Type>,
@ -92,7 +110,7 @@ pub struct FunctionData {

 pub struct Inferencer<'a> {
    pub top_level: &'a TopLevelContext,
-    pub defined_identifiers: HashSet<StrRef>,
+    pub defined_identifiers: HashMap<StrRef, IdentifierInfo>,
    pub function_data: &'a mut FunctionData,
    pub unifier: &'a mut Unifier,
    pub primitives: &'a PrimitiveStore,
@ -224,9 +242,7 @@ impl<'a> Fold<()> for Inferencer<'a> {
                                handler.location,
                            ));
                            if let Some(name) = name {
-                                if !self.defined_identifiers.contains(&name) {
-                                    self.defined_identifiers.insert(name);
-                                }
+                                self.defined_identifiers.entry(name).or_default();
                                if let Some(old_typ) = self.variable_mapping.insert(name, typ) {
                                    let loc = handler.location;
                                    self.unifier.unify(old_typ, typ).map_err(|e| {
@ -378,6 +394,7 @@ impl<'a> Fold<()> for Inferencer<'a> {
            | ast::StmtKind::Continue { .. }
            | ast::StmtKind::Expr { .. }
            | ast::StmtKind::For { .. }
+            | ast::StmtKind::Global { .. }
            | ast::StmtKind::Pass { .. }
            | ast::StmtKind::Try { .. } => {}
            ast::StmtKind::If { test, .. } | ast::StmtKind::While { test, .. } => {
@ -549,7 +566,7 @@ impl<'a> Fold<()> for Inferencer<'a> {
                        unreachable!("must be tobj")
                    }
                } else {
-                    if !self.defined_identifiers.contains(id) {
+                    if !self.defined_identifiers.contains_key(id) {
                        match self.function_data.resolver.get_symbol_type(
                            self.unifier,
                            &self.top_level.definitions.read(),
@ -557,7 +574,7 @@ impl<'a> Fold<()> for Inferencer<'a> {
                            *id,
                        ) {
                            Ok(_) => {
-                                self.defined_identifiers.insert(*id);
+                                self.defined_identifiers.insert(*id, IdentifierInfo::default());
                            }
                            Err(e) => {
                                return report_error(
@ -622,8 +639,8 @@ impl<'a> Inferencer<'a> {
    fn infer_pattern<T>(&mut self, pattern: &ast::Expr<T>) -> Result<(), InferenceError> {
        match &pattern.node {
            ExprKind::Name { id, .. } => {
-                if !self.defined_identifiers.contains(id) {
-                    self.defined_identifiers.insert(*id);
+                if !self.defined_identifiers.contains_key(id) {
+                    self.defined_identifiers.insert(*id, IdentifierInfo::default());
                }
                Ok(())
            }
@ -732,8 +749,8 @@ impl<'a> Inferencer<'a> {
        let mut defined_identifiers = self.defined_identifiers.clone();
        for arg in &args.args {
            let name = &arg.node.arg;
-            if !defined_identifiers.contains(name) {
-                defined_identifiers.insert(*name);
+            if !defined_identifiers.contains_key(name) {
+                defined_identifiers.insert(*name, IdentifierInfo::default());
            }
        }
        let fn_args: Vec<_> = args
@ -1550,36 +1567,29 @@ impl<'a> Inferencer<'a> {
        }
        // 2-argument ndarray n-dimensional creation functions
        if id == &"np_full".into() && args.len() == 2 {
-            let ExprKind::List { elts, .. } = &args[0].node else {
-                return report_error(
-                    format!(
-                        "Expected List literal for first argument of {id}, got {}",
-                        args[0].node.name()
-                    )
-                    .as_str(),
-                    args[0].location,
-                );
-            };
+            // Parse arguments
+            let shape_expr = args.remove(0);
+            let (ndims, shape) =
+                self.fold_numpy_function_call_shape_argument(*id, 0, shape_expr)?; // Special handling for `shape`

-            let ndims = elts.len() as u64;
+            let fill_value = self.fold_expr(args.remove(0))?;

-            let arg0 = self.fold_expr(args.remove(0))?;
-            let arg1 = self.fold_expr(args.remove(0))?;
-
-            let ty = arg1.custom.unwrap();
+            // Build the return type
+            let dtype = fill_value.custom.unwrap();
            let ndims = self.unifier.get_fresh_literal(vec![SymbolValue::U64(ndims)], None);
-            let ret = make_ndarray_ty(self.unifier, self.primitives, Some(ty), Some(ndims));
+            let ret = make_ndarray_ty(self.unifier, self.primitives, Some(dtype), Some(ndims));
+
            let custom = self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                args: vec![
                    FuncArg {
                        name: "shape".into(),
-                        ty: arg0.custom.unwrap(),
+                        ty: shape.custom.unwrap(),
                        default_value: None,
                        is_vararg: false,
                    },
                    FuncArg {
                        name: "fill_value".into(),
-                        ty: arg1.custom.unwrap(),
+                        ty: fill_value.custom.unwrap(),
                        default_value: None,
                        is_vararg: false,
                    },
@ -1597,7 +1607,7 @@ impl<'a> Inferencer<'a> {
                        location: func.location,
                        node: ExprKind::Name { id: *id, ctx: *ctx },
                    }),
-                    args: vec![arg0, arg1],
+                    args: vec![shape, fill_value],
                    keywords: vec![],
                },
            }));
--- a/nac3core/src/typecheck/type_inferencer/test.rs
+++ b/nac3core/src/typecheck/type_inferencer/test.rs
@ -1,18 +1,20 @@
-use super::super::{magic_methods::with_fields, typedef::*};
-use super::*;
-use crate::{
-    codegen::CodeGenContext,
-    symbol_resolver::ValueEnum,
-    toplevel::{helper::PrimDef, DefinitionId, TopLevelDef},
-};
+use std::iter::zip;
+
 use indexmap::IndexMap;
 use indoc::indoc;
-use nac3parser::ast::FileName;
-use nac3parser::parser::parse_program;
 use parking_lot::RwLock;
-use std::iter::zip;
 use test_case::test_case;

+use nac3parser::{ast::FileName, parser::parse_program};
+
+use super::*;
+use crate::{
+    codegen::{CodeGenContext, CodeGenerator},
+    symbol_resolver::ValueEnum,
+    toplevel::{helper::PrimDef, DefinitionId, TopLevelDef},
+    typecheck::{magic_methods::with_fields, typedef::*},
+};
+
 struct Resolver {
    id_to_type: HashMap<StrRef, Type>,
    id_to_def: HashMap<StrRef, DefinitionId>,
@ -41,6 +43,7 @@ impl SymbolResolver for Resolver {
        &self,
        _: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
+        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        unimplemented!()
    }
@ -517,7 +520,7 @@ impl TestEnvironment {
            primitives: &mut self.primitives,
            virtual_checks: &mut self.virtual_checks,
            calls: &mut self.calls,
-            defined_identifiers: HashSet::default(),
+            defined_identifiers: HashMap::default(),
            in_handler: false,
        }
    }
@ -593,8 +596,9 @@ fn test_basic(source: &str, mapping: &HashMap<&str, &str>, virtuals: &[(&str, &s
    println!("source:\n{source}");
    let mut env = TestEnvironment::new();
    let id_to_name = std::mem::take(&mut env.id_to_name);
-    let mut defined_identifiers: HashSet<_> = env.identifier_mapping.keys().copied().collect();
-    defined_identifiers.insert("virtual".into());
+    let mut defined_identifiers: HashMap<_, _> =
+        env.identifier_mapping.keys().copied().map(|id| (id, IdentifierInfo::default())).collect();
+    defined_identifiers.insert("virtual".into(), IdentifierInfo::default());
    let mut inferencer = env.get_inferencer();
    inferencer.defined_identifiers.clone_from(&defined_identifiers);
    let statements = parse_program(source, FileName::default()).unwrap();
@ -739,8 +743,9 @@ fn test_primitive_magic_methods(source: &str, mapping: &HashMap<&str, &str>) {
    println!("source:\n{source}");
    let mut env = TestEnvironment::basic_test_env();
    let id_to_name = std::mem::take(&mut env.id_to_name);
-    let mut defined_identifiers: HashSet<_> = env.identifier_mapping.keys().copied().collect();
-    defined_identifiers.insert("virtual".into());
+    let mut defined_identifiers: HashMap<_, _> =
+        env.identifier_mapping.keys().copied().map(|id| (id, IdentifierInfo::default())).collect();
+    defined_identifiers.insert("virtual".into(), IdentifierInfo::default());
    let mut inferencer = env.get_inferencer();
    inferencer.defined_identifiers.clone_from(&defined_identifiers);
    let statements = parse_program(source, FileName::default()).unwrap();
--- a/nac3core/src/typecheck/typedef/mod.rs
+++ b/nac3core/src/typecheck/typedef/mod.rs
@ -1,21 +1,28 @@
-use super::magic_methods::{Binop, HasOpInfo};
-use super::type_error::{TypeError, TypeErrorKind};
-use super::unification_table::{UnificationKey, UnificationTable};
-use crate::symbol_resolver::SymbolValue;
-use crate::toplevel::helper::PrimDef;
-use crate::toplevel::{DefinitionId, TopLevelContext, TopLevelDef};
-use crate::typecheck::magic_methods::OpInfo;
-use crate::typecheck::type_inferencer::PrimitiveStore;
+use std::{
+    borrow::Cow,
+    cell::RefCell,
+    collections::{HashMap, HashSet},
+    fmt::{self, Display},
+    iter::{repeat, zip},
+    rc::Rc,
+    sync::{Arc, Mutex},
+};
+
 use indexmap::IndexMap;
 use itertools::{repeat_n, Itertools};
+
 use nac3parser::ast::{Cmpop, Location, StrRef, Unaryop};
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::fmt::{self, Display};
-use std::iter::{repeat, zip};
-use std::rc::Rc;
-use std::sync::{Arc, Mutex};
-use std::{borrow::Cow, collections::HashSet};
+
+use super::{
+    magic_methods::{Binop, HasOpInfo},
+    type_error::{TypeError, TypeErrorKind},
+    unification_table::{UnificationKey, UnificationTable},
+};
+use crate::{
+    symbol_resolver::SymbolValue,
+    toplevel::{helper::PrimDef, DefinitionId, TopLevelContext, TopLevelDef},
+    typecheck::{magic_methods::OpInfo, type_inferencer::PrimitiveStore},
+};

 #[cfg(test)]
 mod test;
@ -670,8 +677,8 @@ impl Unifier {
        let num_args = posargs.len() + kwargs.len();

        // Now we check the arguments against the parameters,
-        // and depending on what `call_info` is, we might change how the behavior `unify_call()`
-        // in hopes to improve user error messages when type checking fails.
+        // and depending on what `call_info` is, we might change how `unify_call()` behaves
+        // to improve user error messages when type checking fails.
        match operator_info {
            Some(OperatorInfo::IsBinaryOp { self_type, operator }) => {
                // The call is written in the form of (say) `a + b`.
--- a/nac3core/src/typecheck/typedef/test.rs
+++ b/nac3core/src/typecheck/typedef/test.rs
@ -1,10 +1,12 @@
-use super::super::magic_methods::with_fields;
-use super::*;
+use std::collections::HashMap;
+
 use indoc::indoc;
 use itertools::Itertools;
-use std::collections::HashMap;
 use test_case::test_case;

+use super::*;
+use crate::typecheck::magic_methods::with_fields;
+
 impl Unifier {
    /// Check whether two types are equal.
    fn eq(&mut self, a: Type, b: Type) -> bool {
--- a/nac3ld/src/lib.rs
+++ b/nac3ld/src/lib.rs
@ -21,13 +21,12 @@
    clippy::wildcard_imports
 )]

+use std::{collections::HashMap, mem, ptr, slice, str};
+
+use byteorder::{ByteOrder, LittleEndian};
+
 use dwarf::*;
 use elf::*;
-use std::collections::HashMap;
-use std::{mem, ptr, slice, str};
-
-extern crate byteorder;
-use byteorder::{ByteOrder, LittleEndian};

 mod dwarf;
 mod elf;
--- a/nac3parser/Cargo.toml
+++ b/nac3parser/Cargo.toml
@ -8,15 +8,15 @@ license = "MIT"
 edition = "2021"

 [build-dependencies]
-lalrpop = "0.20"
+lalrpop = "0.22"

 [dependencies]
 nac3ast = { path = "../nac3ast" }
-lalrpop-util = "0.20"
+lalrpop-util = "0.22"
 log = "0.4"
 unic-emoji-char = "0.9"
 unic-ucd-ident  = "0.9"
-unicode_names2 = "1.2"
+unicode_names2 = "1.3"
 phf = { version = "0.11", features = ["macros"] }
 ahash = "0.8"

--- a/nac3parser/src/config_comment_helper.rs
+++ b/nac3parser/src/config_comment_helper.rs
@ -1,8 +1,10 @@
-use crate::ast::Ident;
-use crate::ast::Location;
-use crate::error::*;
-use crate::token::Tok;
+use crate::{
+    ast::{Ident, Location},
+    error::*,
+    token::Tok,
+};
 use lalrpop_util::ParseError;
+
 use nac3ast::*;

 pub fn make_config_comment(
--- a/nac3parser/src/error.rs
+++ b/nac3parser/src/error.rs
@ -1,13 +1,12 @@
 //! Define internal parse error types
 //! The goal is to provide a matching and a safe error API, maksing errors from LALR
-use lalrpop_util::ParseError as LalrpopError;
-
-use crate::ast::Location;
-use crate::token::Tok;
-
 use std::error::Error;
 use std::fmt;

+use lalrpop_util::ParseError as LalrpopError;
+
+use crate::{ast::Location, token::Tok};
+
 /// Represents an error during lexical scanning.
 #[derive(Debug, PartialEq)]
 pub struct LexicalError {
--- a/nac3parser/src/fstring.rs
+++ b/nac3parser/src/fstring.rs
@ -1,12 +1,11 @@
-use std::iter;
-use std::mem;
-use std::str;
-
-use crate::ast::{Constant, ConversionFlag, Expr, ExprKind, Location};
-use crate::error::{FStringError, FStringErrorType, ParseError};
-use crate::parser::parse_expression;
+use std::{iter, mem, str};

 use self::FStringErrorType::*;
+use crate::{
+    ast::{Constant, ConversionFlag, Expr, ExprKind, Location},
+    error::{FStringError, FStringErrorType, ParseError},
+    parser::parse_expression,
+};

 struct FStringParser<'a> {
    chars: iter::Peekable<str::Chars<'a>>,
--- a/nac3parser/src/function.rs
+++ b/nac3parser/src/function.rs
@ -1,8 +1,11 @@
-use ahash::RandomState;
 use std::collections::HashSet;

-use crate::ast;
-use crate::error::{LexicalError, LexicalErrorType};
+use ahash::RandomState;
+
+use crate::{
+    ast,
+    error::{LexicalError, LexicalErrorType},
+};

 pub struct ArgumentList {
    pub args: Vec<ast::Expr>,
--- a/nac3parser/src/lexer.rs
+++ b/nac3parser/src/lexer.rs
@ -1,17 +1,17 @@
 //! This module takes care of lexing python source text.
 //!
 //! This means source code is translated into separate tokens.
+use std::{char, cmp::Ordering, num::IntErrorKind, str::FromStr};

-pub use super::token::Tok;
-use crate::ast::{FileName, Location};
-use crate::error::{LexicalError, LexicalErrorType};
-use std::char;
-use std::cmp::Ordering;
-use std::num::IntErrorKind;
-use std::str::FromStr;
 use unic_emoji_char::is_emoji_presentation;
 use unic_ucd_ident::{is_xid_continue, is_xid_start};

+pub use super::token::Tok;
+use crate::{
+    ast::{FileName, Location},
+    error::{LexicalError, LexicalErrorType},
+};
+
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 struct IndentationLevel {
    tabs: usize,
--- a/nac3parser/src/parser.rs
+++ b/nac3parser/src/parser.rs
@ -5,14 +5,16 @@
 //! parse a whole program, a single statement, or a single
 //! expression.

-use nac3ast::Location;
 use std::iter;

-use crate::ast::{self, FileName};
-use crate::error::ParseError;
-use crate::lexer;
+use nac3ast::Location;
+
 pub use crate::mode::Mode;
-use crate::python;
+use crate::{
+    ast::{self, FileName},
+    error::ParseError,
+    lexer, python,
+};

 /*
 * Parse python code.
--- a/nac3parser/src/token.rs
+++ b/nac3parser/src/token.rs
@ -1,8 +1,9 @@
 //! Different token definitions.
 //! Loosely based on token.h from CPython source:
-use crate::ast;
 use std::fmt::{self, Write};

+use crate::ast;
+
 /// Python source code can be tokenized in a sequence of these tokens.
 #[derive(Clone, Debug, PartialEq)]
 pub enum Tok {
--- a/nac3standalone/Cargo.toml
+++ b/nac3standalone/Cargo.toml
@ -9,14 +9,8 @@ no-escape-analysis = ["nac3core/no-escape-analysis"]

 [dependencies]
 parking_lot = "0.12"
-nac3parser = { path = "../nac3parser" }
 nac3core = { path = "../nac3core" }

 [dependencies.clap]
 version = "4.5"
 features = ["derive"]
-
-[dependencies.inkwell]
-version = "0.4"
-default-features = false
-features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
--- a/nac3standalone/demo/src/globals.py
+++ b/nac3standalone/demo/src/globals.py
@ -0,0 +1,31 @@
+@extern
+def output_int32(x: int32):
+    ...
+
+@extern
+def output_int64(x: int64):
+    ...
+
+X: int32 = 0
+Y: int64 = int64(1)
+
+def f():
+    global X, Y
+    X = 1
+    Y = int64(2)
+
+def run() -> int32:
+    global X, Y
+
+    output_int32(X)
+    output_int64(Y)
+    f()
+    output_int32(X)
+    output_int64(Y)
+
+    X = 0
+    Y = int64(0)
+    output_int32(X)
+    output_int64(Y)
+
+    return 0
--- a/nac3standalone/demo/src/ndarray.py
+++ b/nac3standalone/demo/src/ndarray.py
@ -114,12 +114,22 @@ def test_ndarray_ones():
    n: ndarray[float, 1] = np_ones([1])
    output_ndarray_float_1(n)

+    dim = (1,)
+    n_tup: ndarray[float, 1] = np_ones(dim)
+    output_ndarray_float_1(n_tup)
+
 def test_ndarray_full():
    n_float: ndarray[float, 1] = np_full([1], 2.0)
    output_ndarray_float_1(n_float)
    n_i32: ndarray[int32, 1] = np_full([1], 2)
    output_ndarray_int32_1(n_i32)

+    dim = (1,)
+    n_float_tup: ndarray[float, 1] = np_full(dim, 2.0)
+    output_ndarray_float_1(n_float_tup)
+    n_i32_tup: ndarray[int32, 1] = np_full(dim, 2)
+    output_ndarray_int32_1(n_i32_tup)
+
 def test_ndarray_eye():
    n: ndarray[float, 2] = np_eye(2)
    output_ndarray_float_2(n)
--- a/nac3standalone/src/basic_symbol_resolver.rs
+++ b/nac3standalone/src/basic_symbol_resolver.rs
@ -1,5 +1,14 @@
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+
+use parking_lot::{Mutex, RwLock};
+
 use nac3core::{
-    codegen::CodeGenContext,
+    codegen::{CodeGenContext, CodeGenerator},
+    inkwell::{module::Linkage, values::BasicValue},
+    nac3parser::ast::{self, StrRef},
    symbol_resolver::{SymbolResolver, SymbolValue, ValueEnum},
    toplevel::{DefinitionId, TopLevelDef},
    typecheck::{
@ -7,10 +16,6 @@ use nac3core::{
        typedef::{Type, Unifier},
    },
 };
-use nac3parser::ast::{self, StrRef};
-use parking_lot::{Mutex, RwLock};
-use std::collections::HashSet;
-use std::{collections::HashMap, sync::Arc};

 pub struct ResolverInternal {
    pub id_to_type: Mutex<HashMap<StrRef, Type>>,
@ -45,20 +50,51 @@ impl SymbolResolver for Resolver {

    fn get_symbol_type(
        &self,
-        _: &mut Unifier,
+        unifier: &mut Unifier,
        _: &[Arc<RwLock<TopLevelDef>>],
-        _: &PrimitiveStore,
+        primitives: &PrimitiveStore,
        str: StrRef,
    ) -> Result<Type, String> {
-        self.0.id_to_type.lock().get(&str).copied().ok_or(format!("cannot get type of {str}"))
+        self.0
+            .id_to_type
+            .lock()
+            .get(&str)
+            .copied()
+            .or_else(|| {
+                self.0
+                    .module_globals
+                    .lock()
+                    .get(&str)
+                    .cloned()
+                    .map(|v| v.get_type(primitives, unifier))
+            })
+            .ok_or(format!("cannot get type of {str}"))
    }

    fn get_symbol_value<'ctx>(
        &self,
-        _: StrRef,
-        _: &mut CodeGenContext<'ctx, '_>,
+        str: StrRef,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        generator: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
-        unimplemented!()
+        self.0.module_globals.lock().get(&str).cloned().map(|v| {
+            ctx.module
+                .get_global(&str.to_string())
+                .unwrap_or_else(|| {
+                    let ty = v.get_type(&ctx.primitives, &mut ctx.unifier);
+
+                    let init_val = ctx.gen_symbol_val(generator, &v, ty);
+                    let llvm_ty = init_val.get_type();
+
+                    let global = ctx.module.add_global(llvm_ty, None, &str.to_string());
+                    global.set_linkage(Linkage::LinkOnceAny);
+                    global.set_initializer(&init_val);
+
+                    global
+                })
+                .as_basic_value_enum()
+                .into()
+        })
    }

    fn get_identifier_def(&self, id: StrRef) -> Result<DefinitionId, HashSet<String>> {
--- a/nac3standalone/src/main.rs
+++ b/nac3standalone/src/main.rs
@ -8,17 +8,30 @@
 #![warn(clippy::pedantic)]
 #![allow(clippy::too_many_lines, clippy::wildcard_imports)]

-use clap::Parser;
-use inkwell::context::Context;
-use inkwell::{
-    memory_buffer::MemoryBuffer, passes::PassBuilderOptions, support::is_multithreaded, targets::*,
-    OptimizationLevel,
+use std::{
+    collections::{HashMap, HashSet},
+    fs,
+    num::NonZeroUsize,
+    path::Path,
+    sync::Arc,
 };
+
+use clap::Parser;
+use parking_lot::{Mutex, RwLock};
+
 use nac3core::{
    codegen::{
        concrete_type::ConcreteTypeStore, irrt::load_irrt, CodeGenLLVMOptions,
        CodeGenTargetMachineOptions, CodeGenTask, DefaultCodeGenerator, WithCall, WorkerRegistry,
    },
+    inkwell::{
+        memory_buffer::MemoryBuffer, module::Linkage, passes::PassBuilderOptions,
+        support::is_multithreaded, targets::*, OptimizationLevel,
+    },
+    nac3parser::{
+        ast::{Constant, Expr, ExprKind, StmtKind, StrRef},
+        parser,
+    },
    symbol_resolver::SymbolResolver,
    toplevel::{
        composer::{ComposerConfig, TopLevelComposer},
@ -31,14 +44,6 @@ use nac3core::{
        typedef::{FunSignature, Type, Unifier, VarMap},
    },
 };
-use nac3parser::{
-    ast::{Constant, Expr, ExprKind, StmtKind, StrRef},
-    parser,
-};
-use parking_lot::{Mutex, RwLock};
-use std::collections::HashSet;
-use std::num::NonZeroUsize;
-use std::{collections::HashMap, fs, path::Path, sync::Arc};

 mod basic_symbol_resolver;
 use basic_symbol_resolver::*;
@ -240,6 +245,34 @@ fn handle_assignment_pattern(
    }
 }

+fn handle_global_var(
+    target: &Expr,
+    value: Option<&Expr>,
+    resolver: &(dyn SymbolResolver + Send + Sync),
+    internal_resolver: &ResolverInternal,
+) -> Result<(), String> {
+    let ExprKind::Name { id, .. } = target.node else {
+        return Err(format!(
+            "global variable declaration must be an identifier (at {})",
+            target.location,
+        ));
+    };
+
+    let Some(value) = value else {
+        return Err(format!("global variable `{id}` must be initialized in its definition"));
+    };
+
+    if let Ok(val) = parse_parameter_default_value(value, resolver) {
+        internal_resolver.add_module_global(id, val);
+        Ok(())
+    } else {
+        Err(format!(
+            "failed to evaluate this expression `{:?}` as a constant at {}",
+            target.node, target.location,
+        ))
+    }
+}
+
 fn main() {
    let cli = CommandLineArgs::parse();
    let CommandLineArgs { file_name, threads, opt_level, emit_llvm, triple, mcpu, target_features } =
@ -280,22 +313,19 @@ fn main() {
        reloc_mode: RelocMode::PIC,
        ..host_target_machine
    };
-
-    let size_t = Context::create()
-        .ptr_sized_int_type(
-            &target_machine_options
+    let target_machine = target_machine_options
        .create_target_machine(opt_level)
-                .map(|tm| tm.get_target_data())
-                .unwrap(),
-            None,
-        )
-        .get_bit_width();
+        .expect("couldn't create target machine");
+
+    let context = nac3core::inkwell::context::Context::create();
+
+    let size_t =
+        context.ptr_sized_int_type(&target_machine.get_target_data(), None).get_bit_width();

    let program = match fs::read_to_string(file_name.clone()) {
        Ok(program) => program,
        Err(err) => {
-            println!("Cannot open input file: {err}");
-            return;
+            panic!("Cannot open input file: {err}");
        }
    };

@ -313,8 +343,6 @@ fn main() {
    let resolver =
        Arc::new(Resolver(internal_resolver.clone())) as Arc<dyn SymbolResolver + Send + Sync>;

-    let context = inkwell::context::Context::create();
-
    // Process IRRT
    let irrt = load_irrt(&context, resolver.as_ref());
    if emit_llvm {
@ -339,10 +367,26 @@ fn main() {
                    unifier,
                    primitives,
                ) {
-                    eprintln!("{err}");
-                    return;
+                    panic!("{err}");
                }
            }
+
+            StmtKind::AnnAssign { target, value, .. } => {
+                if let Err(err) = handle_global_var(
+                    target,
+                    value.as_ref().map(Box::as_ref),
+                    resolver.as_ref(),
+                    internal_resolver.as_ref(),
+                ) {
+                    panic!("{err}");
+                }
+
+                let (name, def_id, _) = composer
+                    .register_top_level(stmt, Some(resolver.clone()), "__main__", true)
+                    .unwrap();
+                internal_resolver.add_id_def(name, def_id);
+            }
+
            // allow (and ignore) "from __future__ import annotations"
            StmtKind::ImportFrom { module, names, .. }
                if module == &Some("__future__".into())
@ -453,17 +497,12 @@ fn main() {
    let mut function_iter = main.get_first_function();
    while let Some(func) = function_iter {
        if func.count_basic_blocks() > 0 && func.get_name().to_str().unwrap() != "run" {
-            func.set_linkage(inkwell::module::Linkage::Private);
+            func.set_linkage(Linkage::Private);
        }
        function_iter = func.get_next_function();
    }

    // Optimize `main`
-    let target_machine = llvm_options
-        .target
-        .create_target_machine(llvm_options.opt_level)
-        .expect("couldn't create target machine");
-
    let pass_options = PassBuilderOptions::create();
    pass_options.set_merge_functions(true);
    let passes = format!("default<O{}>", opt_level as u32);
--- a/nix/windows/PKGBUILD
+++ b/nix/windows/PKGBUILD
@ -21,6 +21,6 @@ build() {
 }

 package() {
-  mkdir -p $pkgdir/clang64/lib/python3.11/site-packages
-  cp ${srcdir}/nac3artiq.pyd $pkgdir/clang64/lib/python3.11/site-packages
+  mkdir -p $pkgdir/clang64/lib/python3.12/site-packages
+  cp ${srcdir}/nac3artiq.pyd $pkgdir/clang64/lib/python3.12/site-packages
 }
--- a/nix/windows/default.nix
+++ b/nix/windows/default.nix
@ -21,10 +21,10 @@ let
    text =
      ''
      implementation=CPython
-      version=3.11
+      version=3.12
      shared=true
      abi3=false
-      lib_name=python3.11
+      lib_name=python3.12
      lib_dir=${msys2-env}/clang64/lib
      pointer_width=64
      build_flags=WITH_THREAD
--- a/nix/windows/make_msys2_packages.sh
+++ b/nix/windows/make_msys2_packages.sh
@ -6,11 +6,11 @@ cd $(dirname $0)
 MSYS2DIR=`pwd`/msys2
 mkdir -p $MSYS2DIR/var/lib/pacman $MSYS2DIR/msys/etc

-curl -L https://mirror.msys2.org/msys/x86_64/pacman-mirrors-20220205-1-any.pkg.tar.zst | tar xvf - -C $MSYS2DIR --zstd
+curl -L https://repo.msys2.org/msys/x86_64/pacman-mirrors-20240523-1-any.pkg.tar.zst | tar xvf - -C $MSYS2DIR --zstd
 curl -L https://raw.githubusercontent.com/msys2/MSYS2-packages/master/pacman/pacman.conf | sed "s|SigLevel    = Required|SigLevel    = Never|g" | sed "s|/etc/pacman.d|$MSYS2DIR/etc/pacman.d|g" > $MSYS2DIR/etc/pacman.conf

 fakeroot pacman --root $MSYS2DIR --config $MSYS2DIR/etc/pacman.conf -Syy
-pacman --root $MSYS2DIR --config $MSYS2DIR/etc/pacman.conf --cachedir $MSYS2DIR/msys/cache -Sp mingw-w64-clang-x86_64-rust mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-ninja mingw-w64-clang-x86_64-python3.11 mingw-w64-clang-x86_64-python-numpy mingw-w64-clang-x86_64-python-setuptools > $MSYS2DIR/packages.txt
+pacman --root $MSYS2DIR --config $MSYS2DIR/etc/pacman.conf --cachedir $MSYS2DIR/msys/cache -Sp mingw-w64-clang-x86_64-rust mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-ninja mingw-w64-clang-x86_64-python-numpy mingw-w64-clang-x86_64-python-setuptools > $MSYS2DIR/packages.txt

 echo "{ pkgs } : [" > msys2_packages.nix
 while read package; do
--- a/nix/windows/msys2_packages.nix
+++ b/nix/windows/msys2_packages.nix
@ -1,15 +1,15 @@
 { pkgs } : [

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libunwind-18.1.8-1-any.pkg.tar.zst";
-  sha256 = "1v8zkfcbf1ga2ndpd1j0dwv5s1rassxs2b5pjhcsmqwjcvczba1m";
-  name = "mingw-w64-clang-x86_64-libunwind-18.1.8-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libunwind-18.1.8-2-any.pkg.tar.zst";
+  sha256 = "0f9m76dx40iy794nfks0360gvjhdg6yngb2lyhwp4xd76rn5081m";
+  name = "mingw-w64-clang-x86_64-libunwind-18.1.8-2-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libc++-18.1.8-1-any.pkg.tar.zst";
-  sha256 = "0mfd8wrmgx12j5gf354j7pk1l3lg9ykxvq75xdk3jipsr6hbn846";
-  name = "mingw-w64-clang-x86_64-libc++-18.1.8-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libc++-18.1.8-2-any.pkg.tar.zst";
+  sha256 = "17savj9wys9my2ji7vyba7wwqkvzdjwnkb3k4858wxrjbzbfa6lk";
+  name = "mingw-w64-clang-x86_64-libc++-18.1.8-2-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -43,9 +43,9 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libxml2-2.12.8-1-any.pkg.tar.zst";
-  sha256 = "1imipb0dz4w6x4n9arn22imyzzcwdlf2cqxvn7irqq7w9by6fy0b";
-  name = "mingw-w64-clang-x86_64-libxml2-2.12.8-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libxml2-2.12.9-1-any.pkg.tar.zst";
+  sha256 = "0cjz2vj9yz6k5xj601cp0yk631rrr0z94ciamwqrvclb0yhakf25";
+  name = "mingw-w64-clang-x86_64-libxml2-2.12.9-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -79,15 +79,15 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-headers-git-12.0.0.r81.g90abf784a-1-any.pkg.tar.zst";
-  sha256 = "1h3cdcajz29iq7vja908kkijz1vb9xn0f7w1lw1ima0q0zhinv4q";
-  name = "mingw-w64-clang-x86_64-headers-git-12.0.0.r81.g90abf784a-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-headers-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
+  sha256 = "0163jzjlvq7inpafy3h48pkwag3ysk6x56xm84yfcz5q52fnfzq5";
+  name = "mingw-w64-clang-x86_64-headers-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-crt-git-12.0.0.r81.g90abf784a-1-any.pkg.tar.zst";
-  sha256 = "15kamyi3b0j6f5zxin4i2jgzjc7lzvwl4z5cz3dx0i8hg91aq0n7";
-  name = "mingw-w64-clang-x86_64-crt-git-12.0.0.r81.g90abf784a-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-crt-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
+  sha256 = "00cn1mi29mfys7qy4hvgnjd0smqvnkdn3ibnrr6a3wy1h2vaykgq";
+  name = "mingw-w64-clang-x86_64-crt-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -97,15 +97,15 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libwinpthread-git-12.0.0.r81.g90abf784a-1-any.pkg.tar.zst";
-  sha256 = "0qdvgs1rmjjhn9klf9kpw7l0ydz36rr5fasn4q9gpby2lgl11bkb";
-  name = "mingw-w64-clang-x86_64-libwinpthread-git-12.0.0.r81.g90abf784a-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libwinpthread-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
+  sha256 = "1zkzqqd31xpkv817wja3qssjjx891bsdxw07037hv2sk0qr4ffn9";
+  name = "mingw-w64-clang-x86_64-libwinpthread-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-winpthreads-git-12.0.0.r81.g90abf784a-1-any.pkg.tar.zst";
-  sha256 = "0rh2mn078cifcmr4as4k57jxjln5lbnsmpx47h9d0s5d2i8sf2rc";
-  name = "mingw-w64-clang-x86_64-winpthreads-git-12.0.0.r81.g90abf784a-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-winpthreads-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
+  sha256 = "02ynia88ad3l03r08nyldmnajwqkyxcjd191lyamkbj4d6zck323";
+  name = "mingw-w64-clang-x86_64-winpthreads-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -115,15 +115,15 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-c-ares-1.29.0-1-any.pkg.tar.zst";
-  sha256 = "01xg1h1a8kda0kq2921w25ybvm1ms7lfdzday0hv93f3myq7briq";
-  name = "mingw-w64-clang-x86_64-c-ares-1.29.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-c-ares-1.33.1-1-any.pkg.tar.zst";
+  sha256 = "14r6jjsvfbapbkv2zqp2yglva4vz4srzkgk7f186ri3kcafjspgq";
+  name = "mingw-w64-clang-x86_64-c-ares-1.33.1-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-brotli-1.1.0-1-any.pkg.tar.zst";
-  sha256 = "113mha41q53cx0hw13cq1xdf7zbsd58sh8cl1cd7xzg1q69n60w2";
-  name = "mingw-w64-clang-x86_64-brotli-1.1.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-brotli-1.1.0-2-any.pkg.tar.zst";
+  sha256 = "1q01lz9lcyrjmkhv9rddgjazmk7warlcmwhc4qkq9y6h0yfsb71n";
+  name = "mingw-w64-clang-x86_64-brotli-1.1.0-2-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -163,9 +163,9 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openssl-3.3.1-1-any.pkg.tar.zst";
-  sha256 = "0ywhwm4kw3qjzv0872qwabnsq2rzbmqjb9m69q3fykjl0m9gigsa";
-  name = "mingw-w64-clang-x86_64-openssl-3.3.1-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openssl-3.3.2-1-any.pkg.tar.zst";
+  sha256 = "1djgpcz447yvhdy1yq5wh8l5d0821izxklx9afyszbw0pbr7f24y";
+  name = "mingw-w64-clang-x86_64-openssl-3.3.2-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -175,39 +175,39 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-nghttp2-1.61.0-2-any.pkg.tar.zst";
-  sha256 = "07bkk98126gy4k6lb9rrqqnzjfz9j2rsr5dzr2djmzdkw0h4dr95";
-  name = "mingw-w64-clang-x86_64-nghttp2-1.61.0-2-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-nghttp2-1.63.0-1-any.pkg.tar.zst";
+  sha256 = "0lfqrlmapsc7ilxjmhr7hxi578vclqlhpqimbvzq0c70c0iwk864";
+  name = "mingw-w64-clang-x86_64-nghttp2-1.63.0-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-nghttp3-1.4.0-1-any.pkg.tar.zst";
-  sha256 = "007w2252nzn274j4wjc1vf56xyzzh5vg3blj1hil7mlmffgvc923";
-  name = "mingw-w64-clang-x86_64-nghttp3-1.4.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-nghttp3-1.5.0-1-any.pkg.tar.zst";
+  sha256 = "1ljl9kdasf91bxkqcmbbjchp5g00ahv8jn2zab38899z6j3x43nz";
+  name = "mingw-w64-clang-x86_64-nghttp3-1.5.0-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-curl-8.8.0-10-any.pkg.tar.zst";
-  sha256 = "024z5b1achkf448gxqy1i3gcw371x54kfl6igv08b5wb3rrw35a4";
-  name = "mingw-w64-clang-x86_64-curl-8.8.0-10-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-curl-8.9.1-2-any.pkg.tar.zst";
+  sha256 = "1zr6kgqp9i4qqrfckh3kfmz4x1cwv4xis9sfqsx7xji88priax64";
+  name = "mingw-w64-clang-x86_64-curl-8.9.1-2-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-rust-1.79.0-1-any.pkg.tar.zst";
-  sha256 = "0i7s88hj8m4920xifkj7i4b4sq8cqq7p5cypp3jqx3dc44pwm19a";
-  name = "mingw-w64-clang-x86_64-rust-1.79.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-rust-1.80.1-1-any.pkg.tar.zst";
+  sha256 = "1dm4vlrfi9m6xl09zpn0yjr7qcjjr4x738z1rjfwysfnc0awq4x8";
+  name = "mingw-w64-clang-x86_64-rust-1.80.1-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-pkgconf-1~2.2.0-1-any.pkg.tar.zst";
-  sha256 = "1y44ijg3y8p80f1yn9972nshrnyrd06a9sh984ajhxg8bi8s5xyl";
-  name = "mingw-w64-clang-x86_64-pkgconf-12.2.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-cppdap-1.65-1-any.pkg.tar.zst";
+  sha256 = "0phhwkcqp30dsyj5vr6w99sgm1jfm5rzg0w5x5mv9md4x7lm9lmh";
+  name = "mingw-w64-clang-x86_64-cppdap-1.65-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-expat-2.6.2-1-any.pkg.tar.zst";
-  sha256 = "0kj1vzjh3qh7d2g47avlgk7a6j4nc62111hy1m63jwq0alc01k38";
-  name = "mingw-w64-clang-x86_64-expat-2.6.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-expat-2.6.3-1-any.pkg.tar.zst";
+  sha256 = "19xfl1q78q1k8j0lr5aspcf668pmfg01fgib73zq7ff7y5y5fcyi";
+  name = "mingw-w64-clang-x86_64-expat-2.6.3-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -229,9 +229,9 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-lz4-1.9.4-1-any.pkg.tar.zst";
-  sha256 = "0nn7cy25j53q5ckkx4n4f77w00xdwwf5wjswm374shvvs58nlln0";
-  name = "mingw-w64-clang-x86_64-lz4-1.9.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-lz4-1.10.0-1-any.pkg.tar.zst";
+  sha256 = "0kznnw9z9zqxkmn8qbypm2rpsfaapbgls1ks3zzpfnfjz9cpw8py";
+  name = "mingw-w64-clang-x86_64-lz4-1.10.0-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -264,6 +264,12 @@
  name = "mingw-w64-clang-x86_64-ninja-1.12.1-1-any.pkg.tar.zst";
 })

+(pkgs.fetchurl {
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-pkgconf-1~2.3.0-1-any.pkg.tar.zst";
+  sha256 = "15i7x6akkgs7aa7aa804k93p2iipnvygsy7z8hsafskka3h150fa";
+  name = "mingw-w64-clang-x86_64-pkgconf-12.3.0-1-any.pkg.tar.zst";
+})
+
 (pkgs.fetchurl {
  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-rhash-1.4.4-3-any.pkg.tar.zst";
  sha256 = "1ysbxirpfr0yf7pvyps75lnwc897w2a2kcid3nb4j6ilw6n64jmc";
@ -271,9 +277,9 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-cmake-3.30.0-1-any.pkg.tar.zst";
-  sha256 = "07b7132hwhiqrf0l2lgw3g4zw9i2lln3kqc9kg2qijvkapbkmwqb";
-  name = "mingw-w64-clang-x86_64-cmake-3.30.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-cmake-3.30.3-1-any.pkg.tar.zst";
+  sha256 = "0fjwf6xxzli6rcsbzr1razldmm538ibkyf5kw132lpaz5wma9bj8";
+  name = "mingw-w64-clang-x86_64-cmake-3.30.3-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -295,9 +301,9 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-readline-8.2.010-1-any.pkg.tar.zst";
-  sha256 = "1s47pd5iz8y3hspsxn4pnp0v3m05ccia40v5nfvx0rmwgvcaz82v";
-  name = "mingw-w64-clang-x86_64-readline-8.2.010-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-readline-8.2.013-1-any.pkg.tar.zst";
+  sha256 = "0pv1ypqfgm4mimzr0amq9anr1ysqmzrwv6gfk7rrlzhihadknsvr";
+  name = "mingw-w64-clang-x86_64-readline-8.2.013-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -307,9 +313,9 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-sqlite3-3.46.0-1-any.pkg.tar.zst";
-  sha256 = "0q676i2z5nr4c71jnd4z5qz9xa1xryl0cpi84w74yvd0p4qiz7y2";
-  name = "mingw-w64-clang-x86_64-sqlite3-3.46.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-sqlite3-3.46.1-1-any.pkg.tar.zst";
+  sha256 = "1axplxyjnaz411qzjjqwbj55fbrh4akq3plm2p1sx64jp844xpyq";
+  name = "mingw-w64-clang-x86_64-sqlite3-3.46.1-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
@ -324,6 +330,12 @@
  name = "mingw-w64-clang-x86_64-tzdata-2024a-1-any.pkg.tar.zst";
 })

+(pkgs.fetchurl {
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python3.12-3.12.1-2-any.pkg.tar.zst";
+  sha256 = "0wmd39wl9z237w093a7c6hl5pclca9yvwxn0kiw6i2njk3sjv51a";
+  name = "mingw-w64-clang-x86_64-python3.12-3.12.1-2-any.pkg.tar.zst";
+})
+
 (pkgs.fetchurl {
  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-3.11.9-1-any.pkg.tar.zst";
  sha256 = "0ah1idjqxg7jc07a1gz9z766rjjd0f0c6ri4hpcsimsrbj1zjd3c";
@ -337,20 +349,20 @@
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openblas-0.3.27-1-any.pkg.tar.zst";
-  sha256 = "06ygz1wa488wqvmxbn74b0fyan4wf3lb6kbwfampgikd1gijww2k";
-  name = "mingw-w64-clang-x86_64-openblas-0.3.27-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openblas-0.3.28-1-any.pkg.tar.zst";
+  sha256 = "1pskcqc1lg9p8m8rk7bw3mz7mn7vw5fpl7zxa23bhjn02p5b79qq";
+  name = "mingw-w64-clang-x86_64-openblas-0.3.28-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-numpy-1.26.4-1-any.pkg.tar.zst";
-  sha256 = "00h0ap954cjwlsc3p01fjwy7s3nlzs90v0kmnrzxm0rljmvn4jkf";
-  name = "mingw-w64-clang-x86_64-python-numpy-1.26.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-numpy-2.0.1-1-any.pkg.tar.zst";
+  sha256 = "0ks6q8v58h4wmr2pzsjl2xm4f63g0psvfm0jwlz24mqfxp8gqfcc";
+  name = "mingw-w64-clang-x86_64-python-numpy-2.0.1-1-any.pkg.tar.zst";
 })

 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-setuptools-70.2.0-1-any.pkg.tar.zst";
-  sha256 = "1q4r9bg2hn3jmshvq81xm5zvy9wn35yf0z2ayksrkwph1zzdkvkm";
-  name = "mingw-w64-clang-x86_64-python-setuptools-70.2.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-setuptools-74.0.0-1-any.pkg.tar.zst";
+  sha256 = "0xc95z5jzzjf5lw35bs4yn5rlwkrkmrh78yi5rranqpz5nn0wsa0";
+  name = "mingw-w64-clang-x86_64-python-setuptools-74.0.0-1-any.pkg.tar.zst";
 })
 ]
Author	SHA1	Message	Date
lyken	59bea2cd4d	core/ndstrides: implement len(ndarray) & refactor len()	2024-10-04 15:47:55 +08:00
lyken	c1913f11c6	core/ndstrides: implement np_{zeros,ones,full,empty}	2024-10-04 15:46:56 +08:00
lyken	7f4b4597c5	core/model: add util::gen_for_model	2024-10-04 15:45:47 +08:00
lyken	1a61a000b2	core/object: add ListObject and TupleObject Needed for implementing other ndarray utils.	2024-10-04 15:44:42 +08:00
lyken	ec61b50486	core/ndstrides: implement ndarray iterator NDIter A necessary utility to iterate through all elements in a possibly strided ndarray.	2024-10-04 15:42:52 +08:00
lyken	b523a3e227	core/ndstrides: introduce NDArray NDArray with strides.	2024-10-04 15:39:17 +08:00
lyken	e4b050a64b	core/irrt: fix exception.hpp C++ castings	2024-10-04 15:26:08 +08:00
lyken	897c26bcfa	core/toplevel/helper: add {extract,create}_ndims	2024-10-04 15:26:08 +08:00
lyken	1ce76bcfc9	core/object: introduce object A small abstraction to simplify implementations.	2024-10-04 15:26:08 +08:00
lyken	0bc98c447d	[core] introduce models	2024-10-04 15:21:43 +08:00
David Mak	581b2f7bb2	[standalone] Add demo for global variables	2024-10-04 13:24:30 +08:00
David Mak	746329ec5d	[standalone] Implement symbol resolution for globals	2024-10-04 13:24:30 +08:00
David Mak	e60e8e837f	[core] Add support for global statements	2024-10-04 13:24:27 +08:00
David Mak	9fdbe9695d	[core] Add generator to SymbolResolver::get_symbol_value Needed in a future commit.	2024-10-04 13:20:29 +08:00
David Mak	8065e73598	[core] toplevel/composer: Add type analysis for global variables	2024-10-04 13:20:29 +08:00
David Mak	192290889b	[core] Add IdentifierInfo Keeps track of whether an identifier refers to a global or local variable.	2024-10-04 13:20:24 +08:00
David Mak	1407553a2f	[core] Implement parsing of global variables Globals are now parsed into symbol resolver and top level definitions.	2024-10-04 13:18:29 +08:00
David Mak	c7697606e1	[core] Add TopLevelDef::Variable	2024-10-04 13:09:25 +08:00
David Mak	88d0ccbf69	[standalone] Explicit panic when encountering a compilation error Otherwise scripts will continue to execute.	2024-10-04 13:00:16 +08:00
David Mak	a43b59539c	[meta] Move variables declarations closer to where they are first used	2024-10-04 13:00:16 +08:00
David Mak	fe06b2806f	[meta] Reorganize order of use declarations Use declarations are now grouped into 4 groups: - Declarations from the standard library - Declarations from external crates - Declarations from other crates in this project - Declarations from within this module Furthermore, all use declarations are grouped together to enhance readability. super::super is also replaced by an equivalent crate:: declaration.	2024-10-04 12:52:01 +08:00
David Mak	7f6c9a25ac	[meta] Update Cargo dependencies	2024-10-04 12:52:01 +08:00
Sébastien Bourdeauducq	6c8382219f	msys2: get python via numpy dependencies	2024-09-30 14:27:30 +08:00
Sebastien Bourdeauducq	9274a7b96b	flake: update nixpkgs	2024-09-30 14:22:40 +08:00
Sébastien Bourdeauducq	d1c0fe2900	cargo: update dependencies	2024-09-30 14:14:43 +08:00
mwojcik	f2c047ba57	artiq: support async rpcs Co-authored-by: mwojcik <mw@m-labs.hk> Co-committed-by: mwojcik <mw@m-labs.hk>	2024-09-13 12:12:13 +08:00
David Mak	5e2e77a500	[meta] Bump inkwell to v0.5	2024-09-13 11:11:14 +08:00
David Mak	f3cc4702b9	[meta] Update dependencies	2024-09-13 11:11:14 +08:00
David Mak	3e92c491f5	[standalone] Add tests creating ndarrays with tuple dims	2024-09-11 15:52:43 +08:00
lyken	7f629f1579	core: fix comment in unify_call	2024-09-11 15:46:19 +08:00
lyken	5640a793e2	core: allow np_full to take tuple shapes	2024-09-11 15:46:19 +08:00
David Mak	abbaa506ad	[standalone] Remove redundant recreation of TargetMachine	2024-09-09 14:27:10 +08:00
David Mak	f3dc02d646	[meta] Apply cargo fmt	2024-09-09 14:24:52 +08:00
David Mak	ea217eaea1	[meta] Update pre-commit config Directly invoke cargo using nix develop to avoid using the system cargo.	2024-09-09 14:24:38 +08:00
Sébastien Bourdeauducq	5a34551905	allow the use of the LLVM shared library Which in turns allows working around the incompatibility of the LLVM static library with Rust link-args=-rdynamic, which produces binaries that either fail to link (OpenBSD) or segfault on startup (Linux). The year is 2024 and compiler toolchains are still a trash fire like this.	2024-09-09 11:17:31 +08:00
Sebastien Bourdeauducq	6098b1b853	fix previous commit	2024-09-06 11:32:08 +08:00
Sebastien Bourdeauducq	668ccb1c95	nac3core: expose inkwell and nac3parser	2024-09-06 11:06:26 +08:00
Sebastien Bourdeauducq	a3c624d69d	update all dependencies	2024-09-06 10:21:58 +08:00
Sébastien Bourdeauducq	bd06155f34	irrt: compatibility with pre-C23 compilers	2024-09-05 18:54:55 +08:00
David Mak	9c33c4209c	[core] Fix type of ndarray.element_type Should be the element type of the NDArray itself, not the pointer to its type.	2024-08-30 22:47:38 +08:00
Sebastien Bourdeauducq	122983f11c	flake: update dependencies	2024-08-30 14:45:38 +08:00