diff --git a/Cargo.lock b/Cargo.lock
index 079c2c3e18..cc5d7a31eb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -132,30 +132,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "bindgen"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1c85344eb535a31b62f0af37be84441ba9e7f0f4111eb0530f43d15e513fe57"
-dependencies = [
- "bitflags",
- "cexpr",
- "cfg-if 0.1.10",
- "clang-sys",
- "clap",
- "env_logger",
- "lazy_static 1.4.0",
- "lazycell",
- "log",
- "peeking_take_while",
- "proc-macro2",
- "quote",
- "regex",
- "rustc-hash",
- "shlex",
- "which",
-]
-
 [[package]]
 name = "bit-set"
 version = "0.5.2"
@@ -273,15 +249,6 @@ version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed67cbde08356238e75fc4656be4749481eeffb09e19f320a25237d5221c985d"
 
-[[package]]
-name = "cexpr"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fce5b5fb86b0c57c20c834c1b412fd09c77c8a59b9473f86272709e78874cd1d"
-dependencies = [
- "nom",
-]
-
 [[package]]
 name = "cfg-if"
 version = "0.1.10"
@@ -309,17 +276,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "clang-sys"
-version = "0.28.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81de550971c976f176130da4b2978d3b524eaa0fd9ac31f3ceb5ae1231fb4853"
-dependencies = [
- "glob",
- "libc",
- "libloading",
-]
-
 [[package]]
 name = "clap"
 version = "2.33.3"
@@ -378,9 +334,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift"
-version = "0.66.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fc21c925da7fbb64597c86521b59726426fb660ad30f898a01b957f39d15558"
+checksum = "60686f89c5145bc9a961dabbb83954baa429bde4c5977a0a5d3f8552f2990273"
 dependencies = [
  "cranelift-codegen",
  "cranelift-frontend",
@@ -388,18 +344,18 @@ dependencies = [
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.66.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8dcc286b052ee24a1e5a222e7c1125e6010ad35b0f248709b9b3737a8fedcfdf"
+checksum = "9221545c0507dc08a62b2d8b5ffe8e17ac580b0a74d1813b496b8d70b070fbd0"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.66.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d9badfe36176cb653506091693bc2bb1970c9bddfcd6ec7fac404f7eaec6f38"
+checksum = "7e9936ea608b6cd176f107037f6adbb4deac933466fc7231154f96598b2d3ab1"
 dependencies = [
  "byteorder",
  "cranelift-bforest",
@@ -415,9 +371,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.66.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c3f460031861e4f4ad510be62b2ae50bba6cc886b598a36f9c0a970feab9598"
+checksum = "4ef2b2768568306540f4c8db3acce9105534d34c4a1e440529c1e702d7f8c8d7"
 dependencies = [
  "cranelift-codegen-shared",
  "cranelift-entity",
@@ -425,21 +381,21 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.66.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76ad12409e922e7697cd0bdc7dc26992f64a77c31880dfe5e3c7722f4710206d"
+checksum = "6759012d6d19c4caec95793f052613e9d4113e925e7f14154defbac0f1d4c938"
 
 [[package]]
 name = "cranelift-entity"
-version = "0.66.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d97cdc58972ea065d107872cfb9079f4c92ade78a8af85aaff519a65b5d13f71"
+checksum = "86badbce14e15f52a45b666b38abe47b204969dd7f8fb7488cb55dd46b361fa6"
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.66.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ef419efb4f94ecc02e5d9fbcc910d2bb7f0040e2de570e63a454f883bc891d6"
+checksum = "b608bb7656c554d0a4cf8f50c7a10b857e80306f6ff829ad6d468a7e2323c8d8"
 dependencies = [
  "cranelift-codegen",
  "log",
@@ -449,9 +405,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-module"
-version = "0.66.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "001d9b320ce30999c618db554ae9b23ec16d410493a502be674e2ef146bbdf0d"
+checksum = "fdaf0b5c93a610ff988fe5e2adbb7f6afa89cf702ca41acc3479dc35638d3a8d"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -462,9 +418,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-native"
-version = "0.66.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e69d44d59826eef6794066ac2c0f4ad3975f02d97030c60dbc04e3886adf36e"
+checksum = "5246a1af14b7812ee4d94a3f0c4b295ec02c370c08b0ecc3dec512890fdad175"
 dependencies = [
  "cranelift-codegen",
  "raw-cpuid",
@@ -473,15 +429,17 @@ dependencies = [
 
 [[package]]
 name = "cranelift-simplejit"
-version = "0.66.0"
+version = "0.68.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7506acda1b0df5419e8de5f1706cfcd8779d3d40d70c179f361e647fe9b18f0"
+checksum = "b2522ebdff6ba637c0b5e75bc3d40cc990ac1128e13547b740f10fc7b16d3991"
 dependencies = [
  "cranelift-codegen",
+ "cranelift-entity",
  "cranelift-module",
  "cranelift-native",
  "errno",
  "libc",
+ "log",
  "region",
  "target-lexicon",
  "winapi",
@@ -853,12 +811,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "glob"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
-
 [[package]]
 name = "hashbrown"
 version = "0.9.1"
@@ -1017,12 +969,6 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
-[[package]]
-name = "lazycell"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
-
 [[package]]
 name = "lexical-core"
 version = "0.7.4"
@@ -1044,9 +990,9 @@ checksum = "2448f6066e80e3bfc792e9c98bf705b4b0fc6e8ef5b43e5889aff0eaa9c58743"
 
 [[package]]
 name = "libffi"
-version = "0.9.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c18efe55925cc7f83bf60a61394696a734ae90e668d1f2bbd954354416fec6f2"
+checksum = "bafef83ee22d51c27348aaf6b2da007a32b9f5004809d09271432e5ea2a795dd"
 dependencies = [
  "abort_on_panic",
  "libc",
@@ -1055,24 +1001,12 @@ dependencies = [
 
 [[package]]
 name = "libffi-sys"
-version = "0.9.1"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f00e48ce437c5741a4da3b51738498343b5158c37bfa02bcb969efcc44e4e06"
+checksum = "3b6d65142f1c3b06ca3f4216da4d32b3124d14d932cef8dfd8792037acd2160b"
 dependencies = [
- "bindgen",
  "cc",
  "make-cmd",
- "pkg-config",
-]
-
-[[package]]
-name = "libloading"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b111a074963af1d37a139918ac6d49ad1d0d5e47f72fd55388619691a7d753"
-dependencies = [
- "cc",
- "winapi",
 ]
 
 [[package]]
@@ -1206,16 +1140,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "nom"
-version = "4.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ad2a91a8e869eeb30b9cb3119ae87773a8f4ae617f41b1eb9c154b2905f7bd6"
-dependencies = [
- "memchr",
- "version_check",
-]
-
 [[package]]
 name = "num-bigint"
 version = "0.3.0"
@@ -1412,12 +1336,6 @@ dependencies = [
  "proc-macro-hack",
 ]
 
-[[package]]
-name = "peeking_take_while"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
-
 [[package]]
 name = "petgraph"
 version = "0.5.1"
@@ -1586,9 +1504,9 @@ dependencies = [
 
 [[package]]
 name = "regalloc"
-version = "0.0.27"
+version = "0.0.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9ba8aaf5fe7cf307c6dbdaeed85478961d29e25e3bee5169e11b92fa9f027a8"
+checksum = "571f7f397d61c4755285cd37853fe8e03271c243424a907415909379659381c5"
 dependencies = [
  "log",
  "rustc-hash",
@@ -2078,12 +1996,6 @@ dependencies = [
  "opaque-debug",
 ]
 
-[[package]]
-name = "shlex"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fdf1b9db47230893d76faad238fd6097fd6d6a9245cd7a4d90dbd639536bbd2"
-
 [[package]]
 name = "siphasher"
 version = "0.3.3"
@@ -2176,9 +2088,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.10.0"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab0e7238dcc7b40a7be719a25365910f6807bd864f4cce6b2e6b873658e2b19d"
+checksum = "4ee5a98e506fb7231a304c3a1bd7c132a55016cf65001e0282480665870dfcb9"
 
 [[package]]
 name = "term"
@@ -2517,12 +2429,6 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
 
-[[package]]
-name = "version_check"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
-
 [[package]]
 name = "volatile"
 version = "0.3.0"
@@ -2617,15 +2523,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "which"
-version = "3.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d011071ae14a2f6671d0b74080ae0cd8ebf3a6f8c9589a2cd45f23126fe29724"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "winapi"
 version = "0.3.9"
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 0ad09cb230..a8f0aa7f35 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -562,8 +562,6 @@ def keys(self):
                 return 1 # used to be 'a' but that's no longer an error
         self.assertRaises(TypeError, eval, 'dir()', globals(), C())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exec(self):
         g = {}
         exec('z = 1', g)
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index 29137b1b52..258e501882 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -1067,8 +1067,6 @@ def g2(x):
         self.assertEqual(g2(False), 0)
         self.assertEqual(g2(True), ('end', 1))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_yield(self):
         # Allowed as standalone statement
         def g(): yield 1
diff --git a/Lib/test/test_importlib/test_api.py b/Lib/test/test_importlib/test_api.py
index 7b41376520..edb745c2cd 100644
--- a/Lib/test/test_importlib/test_api.py
+++ b/Lib/test/test_importlib/test_api.py
@@ -242,8 +242,6 @@ def test_reload_loader_replaced(self):
             self.assertIs(reloaded, types)
             self.assertIs(sys.modules['types'], types)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_reload_location_changed(self):
         name = 'spam'
         with support.temp_cwd(None) as cwd:
@@ -295,8 +293,6 @@ def test_reload_location_changed(self):
                     self.maxDiff = None
                     self.assertEqual(ns, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_reload_namespace_changed(self):
         name = 'spam'
         with support.temp_cwd(None) as cwd:
diff --git a/Lib/test/test_named_expression.py b/Lib/test/test_named_expression.py
index 3b946865c7..acdfe67fa3 100644
--- a/Lib/test/test_named_expression.py
+++ b/Lib/test/test_named_expression.py
@@ -336,9 +336,6 @@ def spam(a):
         self.assertEqual(res, [(1, 1, 1.0), (2, 2, 1.0), (3, 3, 1.0)])
         self.assertEqual(y, 3)
 
-    # TODO RustPython, added test_named_expression_scope_06_rp_modified as 
-    # minimaly modified variant of this test.
-    @unittest.expectedFailure 
     def test_named_expression_scope_06(self):
         res = [[spam := i for i in range(3)] for j in range(2)]
 
@@ -385,8 +382,6 @@ def eggs(b):
         self.assertEqual(res, [0, 2])
         self.assertEqual(a, 2)
 
-    # TODO RustPython, added test_named_expression_scope_10_rp_modified 
-    @unittest.expectedFailure 
     def test_named_expression_scope_10(self):
         res = [b := [a := 1 for i in range(2)] for j in range(2)]
 
@@ -522,7 +517,6 @@ def test_named_expression_variable_reuse_in_comprehensions(self):
                 self.assertEqual(ns["x"], 2)
                 self.assertEqual(ns["result"], [0, 1, 2])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_named_expression_global_scope(self):
         sentinel = object()
         global GLOBAL_VAR
diff --git a/Lib/test/test_opcodes.py b/Lib/test/test_opcodes.py
index 4a56e858e2..1f821e629b 100644
--- a/Lib/test/test_opcodes.py
+++ b/Lib/test/test_opcodes.py
@@ -38,8 +38,6 @@ class C: pass
         with self.assertRaises(AttributeError):
             C.__annotations__
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_use_existing_annotations(self):
         ns = {'__annotations__': {1: 2}}
         exec('x: int', ns)
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index 43d93f58b5..95db6f15ed 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -1888,6 +1888,12 @@ def get_single(f):
         def helper(self):
             if  hasattr(os, f):
                 self.check(getattr(os, f))
+
+        # TODO: RUSTPYTHON; io.FileIO(fd) should check if the fd passed is valid
+        if f == "fdopen":
+            # this is test_fdopen
+            helper = unittest.expectedFailure(helper)
+
         return helper
     for f in singles:
         locals()["test_"+f] = get_single(f)
diff --git a/Lib/test/test_scope.py b/Lib/test/test_scope.py
index 0cb5ec572a..be868e50e2 100644
--- a/Lib/test/test_scope.py
+++ b/Lib/test/test_scope.py
@@ -136,7 +136,6 @@ def h():
         h = g(2, 4, 6)
         self.assertEqual(h(), 39)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testFreeVarInMethod(self):
 
         def test():
@@ -202,7 +201,6 @@ def fact(n):
 
         self.assertEqual(f(6), 720)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testUnoptimizedNamespaces(self):
 
         check_syntax_error(self, """if 1:
@@ -262,7 +260,6 @@ def testLambdas(self):
         h = g(2, 4, 6)
         self.assertEqual(h(), 18)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testUnboundLocal(self):
 
         def errorInOuter():
@@ -280,7 +277,6 @@ def inner():
         self.assertRaises(UnboundLocalError, errorInOuter)
         self.assertRaises(NameError, errorInInner)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testUnboundLocal_AfterDel(self):
         # #4617: It is now legal to delete a cell variable.
         # The following functions must obviously compile,
@@ -302,7 +298,6 @@ def inner():
         self.assertRaises(UnboundLocalError, errorInOuter)
         self.assertRaises(NameError, errorInInner)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testUnboundLocal_AugAssign(self):
         # test for bug #1501934: incorrect LOAD/STORE_GLOBAL generation
         exec("""if 1:
@@ -335,7 +330,6 @@ def returner():
 
         self.assertEqual(makeReturner2(a=11)()['a'], 11)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testScopeOfGlobalStmt(self):
         # Examples posted by Samuele Pedroni to python-dev on 3/1/2001
 
@@ -414,7 +408,6 @@ def get(self):
             self.assertEqual(g.get(), 13)
             """)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testLeaks(self):
 
         class Foo:
@@ -437,7 +430,6 @@ def f2():
 
         self.assertEqual(Foo.count, 0)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testClassAndGlobal(self):
 
         exec("""if 1:
@@ -460,7 +452,6 @@ class X:
             self.assertTrue(X.passed)
             """)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testLocalsFunction(self):
 
         def f(x):
@@ -568,7 +559,6 @@ class TestClass:
 
         self.assertRaises(TypeError, sys.settrace)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testEvalExecFreeVars(self):
 
         def f(x):
@@ -603,7 +593,6 @@ def x():
         except NameError:
             pass
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testEvalFreeVars(self):
 
         def f(x):
@@ -661,7 +650,10 @@ def dec(self):
         self.assertEqual(c.dec(), 1)
         self.assertEqual(c.dec(), 0)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON, figure out how to communicate that `y = 9` should be
+    #                   stored as a global rather than a STORE_NAME, even when
+    #                   the `global y` is in a nested subscope
+    @unittest.expectedFailure
     def testGlobalInParallelNestedFunctions(self):
         # A symbol table bug leaked the global statement from one
         # function to other nested functions in the same block.
@@ -741,7 +733,6 @@ def top(a):
         def b():
             global a
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testClassNamespaceOverridesClosure(self):
         # See #17853.
         x = 42
diff --git a/Lib/test/test_symtable.py b/Lib/test/test_symtable.py
index 65c081681e..d853e0d66a 100644
--- a/Lib/test/test_symtable.py
+++ b/Lib/test/test_symtable.py
@@ -121,6 +121,8 @@ def test_nonlocal(self):
         expected = ("some_var",)
         self.assertEqual(self.other_internal.get_nonlocals(), expected)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_local(self):
         self.assertTrue(self.spam.lookup("x").is_local())
         self.assertFalse(self.spam.lookup("bar").is_local())
diff --git a/Lib/unittest/test/test_runner.py b/Lib/unittest/test/test_runner.py
index c00d6e5327..3759696043 100644
--- a/Lib/unittest/test/test_runner.py
+++ b/Lib/unittest/test/test_runner.py
@@ -277,8 +277,6 @@ def MockResultClass(*args):
         self.assertEqual(runner._makeResult(), expectedresult)
 
 
-    # TODO: RUSTPYTHON; -W arg for warning control
-    @unittest.expectedFailure
     def test_warnings(self):
         """
         Check that warnings argument of TextTestRunner correctly affects the
diff --git a/bytecode/src/bytecode.rs b/bytecode/src/bytecode.rs
index 74a74af506..778455581f 100644
--- a/bytecode/src/bytecode.rs
+++ b/bytecode/src/bytecode.rs
@@ -93,8 +93,8 @@ impl ConstantBag for BasicBag {
 /// a codeobject. Also a module has a codeobject.
 #[derive(Clone, PartialEq, Serialize, Deserialize)]
 pub struct CodeObject<C: Constant = ConstantData> {
-    pub instructions: Vec<Instruction>,
-    pub locations: Vec<Location>,
+    pub instructions: Box<[Instruction]>,
+    pub locations: Box<[Location]>,
     pub flags: CodeFlags,
     pub posonlyarg_count: usize, // Number of positional-only arguments
     pub arg_count: usize,
@@ -102,12 +102,16 @@ pub struct CodeObject<C: Constant = ConstantData> {
     pub source_path: String,
     pub first_line_number: usize,
     pub obj_name: String, // Name of the object that created this code object
-    pub constants: Vec<C>,
+    pub cell2arg: Option<Box<[isize]>>,
+    pub constants: Box<[C]>,
     #[serde(bound(
         deserialize = "C::Name: serde::Deserialize<'de>",
         serialize = "C::Name: serde::Serialize"
     ))]
-    pub names: Vec<C::Name>,
+    pub names: Box<[C::Name]>,
+    pub varnames: Box<[C::Name]>,
+    pub cellvars: Box<[C::Name]>,
+    pub freevars: Box<[C::Name]>,
 }
 
 bitflags! {
@@ -121,12 +125,7 @@ bitflags! {
         const IS_COROUTINE = 0x20;
         const HAS_VARARGS = 0x40;
         const HAS_VARKEYWORDS = 0x80;
-    }
-}
-
-impl Default for CodeFlags {
-    fn default() -> Self {
-        Self::NEW_LOCALS
+        const IS_OPTIMIZED = 0x0100;
     }
 }
 
@@ -154,22 +153,6 @@ impl fmt::Display for Label {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
-/// An indication where the name must be accessed.
-pub enum NameScope {
-    /// The name will be in the local scope.
-    Local,
-
-    /// The name will be located in scope surrounding the current scope.
-    NonLocal,
-
-    /// The name will be in global scope.
-    Global,
-
-    /// The name will be located in any scope between the current scope and the top scope.
-    Free,
-}
-
 /// Transforms a value prior to formatting it.
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum ConversionFlag {
@@ -195,17 +178,20 @@ pub enum Instruction {
     ImportFrom {
         idx: NameIdx,
     },
-    LoadName {
-        idx: NameIdx,
-        scope: NameScope,
-    },
-    StoreName {
-        idx: NameIdx,
-        scope: NameScope,
-    },
-    DeleteName {
-        idx: NameIdx,
-    },
+    LoadFast(NameIdx),
+    LoadNameAny(NameIdx),
+    LoadGlobal(NameIdx),
+    LoadDeref(NameIdx),
+    LoadClassDeref(NameIdx),
+    StoreFast(NameIdx),
+    StoreLocal(NameIdx),
+    StoreGlobal(NameIdx),
+    StoreDeref(NameIdx),
+    DeleteFast(NameIdx),
+    DeleteLocal(NameIdx),
+    DeleteGlobal(NameIdx),
+    DeleteDeref(NameIdx),
+    LoadClosure(NameIdx),
     Subscript,
     StoreSubscript,
     DeleteSubscript,
@@ -550,8 +536,8 @@ impl<C: Constant> CodeObject<C> {
         obj_name: String,
     ) -> Self {
         CodeObject {
-            instructions: Vec::new(),
-            locations: Vec::new(),
+            instructions: Box::new([]),
+            locations: Box::new([]),
             flags,
             posonlyarg_count,
             arg_count,
@@ -559,8 +545,12 @@ impl<C: Constant> CodeObject<C> {
             source_path,
             first_line_number,
             obj_name,
-            constants: Vec::new(),
-            names: Vec::new(),
+            cell2arg: None,
+            constants: Box::new([]),
+            names: Box::new([]),
+            varnames: Box::new([]),
+            cellvars: Box::new([]),
+            freevars: Box::new([]),
         }
     }
 
@@ -569,19 +559,19 @@ impl<C: Constant> CodeObject<C> {
         let nargs = self.arg_count;
         let nkwargs = self.kwonlyarg_count;
         let mut varargspos = nargs + nkwargs;
-        let posonlyargs = &self.names[..self.posonlyarg_count];
-        let args = &self.names[..nargs];
-        let kwonlyargs = &self.names[nargs..varargspos];
+        let posonlyargs = &self.varnames[..self.posonlyarg_count];
+        let args = &self.varnames[..nargs];
+        let kwonlyargs = &self.varnames[nargs..varargspos];
 
         let vararg = if self.flags.contains(CodeFlags::HAS_VARARGS) {
-            let vararg = &self.names[varargspos];
+            let vararg = &self.varnames[varargspos];
             varargspos += 1;
             Some(vararg)
         } else {
             None
         };
         let varkwarg = if self.flags.contains(CodeFlags::HAS_VARKEYWORDS) {
-            Some(&self.names[varargspos])
+            Some(&self.varnames[varargspos])
         } else {
             None
         };
@@ -597,7 +587,7 @@ impl<C: Constant> CodeObject<C> {
 
     pub fn label_targets(&self) -> BTreeSet<Label> {
         let mut label_targets = BTreeSet::new();
-        for instruction in &self.instructions {
+        for instruction in &*self.instructions {
             match instruction {
                 Jump { target: l }
                 | JumpIfTrue { target: l }
@@ -617,8 +607,10 @@ impl<C: Constant> CodeObject<C> {
                 }
 
                 #[rustfmt::skip]
-                Import { .. } | ImportStar | ImportFrom { .. } | LoadName { .. } | StoreName { .. }
-                | DeleteName { .. } | Subscript | StoreSubscript | DeleteSubscript
+                Import { .. } | ImportStar | ImportFrom { .. } | LoadFast(_) | LoadNameAny(_)
+                | LoadGlobal(_) | LoadDeref(_) | LoadClassDeref(_) | StoreFast(_) | StoreLocal(_)
+                | StoreGlobal(_) | StoreDeref(_) | DeleteFast(_) | DeleteLocal(_) | DeleteGlobal(_)
+                | DeleteDeref(_) | LoadClosure(_) | Subscript | StoreSubscript | DeleteSubscript
                 | StoreAttr { .. } | DeleteAttr { .. } | LoadConst { .. } | UnaryOperation { .. }
                 | BinaryOperation { .. } | LoadAttr { .. } | CompareOperation { .. } | Pop
                 | Rotate { .. } | Duplicate | GetIter | Continue | Break | MakeFunction
@@ -652,7 +644,16 @@ impl<C: Constant> CodeObject<C> {
                 write!(f, "          ")?;
             }
             write!(f, "{} {:5} ", arrow, offset)?;
-            instruction.fmt_dis(f, &self.constants, &self.names, expand_codeobjects, level)?;
+            instruction.fmt_dis(
+                f,
+                &self.constants,
+                &self.names,
+                &self.varnames,
+                &self.cellvars,
+                &self.freevars,
+                expand_codeobjects,
+                level,
+            )?;
         }
         Ok(())
     }
@@ -668,17 +669,24 @@ impl<C: Constant> CodeObject<C> {
     }
 
     pub fn map_bag<Bag: ConstantBag>(self, bag: &Bag) -> CodeObject<Bag::Constant> {
+        let map_names = |names: Box<[C::Name]>| {
+            names
+                .into_vec()
+                .into_iter()
+                .map(|x| bag.make_name_ref(x.as_ref()))
+                .collect::<Box<[_]>>()
+        };
         CodeObject {
             constants: self
                 .constants
+                .into_vec()
                 .into_iter()
                 .map(|x| x.map_constant(bag))
                 .collect(),
-            names: self
-                .names
-                .into_iter()
-                .map(|x| bag.make_name_ref(x.as_ref()))
-                .collect(),
+            names: map_names(self.names),
+            varnames: map_names(self.varnames),
+            cellvars: map_names(self.cellvars),
+            freevars: map_names(self.freevars),
 
             instructions: self.instructions,
             locations: self.locations,
@@ -689,21 +697,27 @@ impl<C: Constant> CodeObject<C> {
             source_path: self.source_path,
             first_line_number: self.first_line_number,
             obj_name: self.obj_name,
+            cell2arg: self.cell2arg,
         }
     }
 
     pub fn map_clone_bag<Bag: ConstantBag>(&self, bag: &Bag) -> CodeObject<Bag::Constant> {
+        let map_names = |names: &[C::Name]| {
+            names
+                .iter()
+                .map(|x| bag.make_name_ref(x.as_ref()))
+                .collect()
+        };
         CodeObject {
             constants: self
                 .constants
                 .iter()
                 .map(|x| bag.make_constant_borrowed(x.borrow_constant()))
                 .collect(),
-            names: self
-                .names
-                .iter()
-                .map(|x| bag.make_name_ref(x.as_ref()))
-                .collect(),
+            names: map_names(&self.names),
+            varnames: map_names(&self.varnames),
+            cellvars: map_names(&self.cellvars),
+            freevars: map_names(&self.freevars),
 
             instructions: self.instructions.clone(),
             locations: self.locations.clone(),
@@ -714,6 +728,7 @@ impl<C: Constant> CodeObject<C> {
             source_path: self.source_path.clone(),
             first_line_number: self.first_line_number,
             obj_name: self.obj_name.clone(),
+            cell2arg: self.cell2arg.clone(),
         }
     }
 }
@@ -739,7 +754,7 @@ impl CodeObject<ConstantData> {
 impl<C: Constant> fmt::Display for CodeObject<C> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.display_inner(f, false, 1)?;
-        for constant in &self.constants {
+        for constant in &*self.constants {
             if let BorrowedConstant::Code { code } = constant.borrow_constant() {
                 write!(f, "\nDisassembly of {:?}\n", code)?;
                 code.fmt(f)?;
@@ -750,11 +765,15 @@ impl<C: Constant> fmt::Display for CodeObject<C> {
 }
 
 impl Instruction {
+    #[allow(clippy::too_many_arguments)]
     fn fmt_dis<C: Constant>(
         &self,
         f: &mut fmt::Formatter,
         constants: &[C],
         names: &[C::Name],
+        varnames: &[C::Name],
+        cellvars: &[C::Name],
+        freevars: &[C::Name],
         expand_codeobjects: bool,
         level: usize,
     ) -> fmt::Result {
@@ -780,6 +799,13 @@ impl Instruction {
             };
         }
 
+        let cellname = |i: usize| {
+            cellvars
+                .get(i)
+                .unwrap_or_else(|| &freevars[i - cellvars.len()])
+                .as_ref()
+        };
+
         match self {
             Import {
                 name_idx,
@@ -799,9 +825,20 @@ impl Instruction {
             ),
             ImportStar => w!(ImportStar),
             ImportFrom { idx } => w!(ImportFrom, names[*idx].as_ref()),
-            LoadName { idx, scope } => w!(LoadName, names[*idx].as_ref(), format!("{:?}", scope)),
-            StoreName { idx, scope } => w!(StoreName, names[*idx].as_ref(), format!("{:?}", scope)),
-            DeleteName { idx } => w!(DeleteName, names[*idx].as_ref()),
+            LoadFast(idx) => w!(LoadFast, *idx, varnames[*idx].as_ref()),
+            LoadNameAny(idx) => w!(LoadNameAny, *idx, names[*idx].as_ref()),
+            LoadGlobal(idx) => w!(LoadGlobal, *idx, names[*idx].as_ref()),
+            LoadDeref(idx) => w!(LoadDeref, *idx, cellname(*idx)),
+            LoadClassDeref(idx) => w!(LoadClassDeref, *idx, cellname(*idx)),
+            StoreFast(idx) => w!(StoreFast, *idx, varnames[*idx].as_ref()),
+            StoreLocal(idx) => w!(StoreLocal, *idx, names[*idx].as_ref()),
+            StoreGlobal(idx) => w!(StoreGlobal, *idx, names[*idx].as_ref()),
+            StoreDeref(idx) => w!(StoreDeref, *idx, cellname(*idx)),
+            DeleteFast(idx) => w!(DeleteFast, *idx, varnames[*idx].as_ref()),
+            DeleteLocal(idx) => w!(DeleteLocal, *idx, names[*idx].as_ref()),
+            DeleteGlobal(idx) => w!(DeleteGlobal, *idx, names[*idx].as_ref()),
+            DeleteDeref(idx) => w!(DeleteDeref, *idx, cellname(*idx)),
+            LoadClosure(i) => w!(LoadClosure, *i, cellname(*i)),
             Subscript => w!(Subscript),
             StoreSubscript => w!(StoreSubscript),
             DeleteSubscript => w!(DeleteSubscript),
diff --git a/compiler/src/compile.rs b/compiler/src/compile.rs
index d06188307e..da500a6043 100644
--- a/compiler/src/compile.rs
+++ b/compiler/src/compile.rs
@@ -7,9 +7,7 @@
 
 use crate::error::{CompileError, CompileErrorType};
 pub use crate::mode::Mode;
-use crate::symboltable::{
-    make_symbol_table, statements_to_symbol_table, Symbol, SymbolScope, SymbolTable,
-};
+use crate::symboltable::{make_symbol_table, statements_to_symbol_table, SymbolScope, SymbolTable};
 use indexmap::IndexSet;
 use itertools::Itertools;
 use num_complex::Complex64;
@@ -20,18 +18,60 @@ type CompileResult<T> = Result<T, CompileError>;
 
 struct CodeInfo {
     code: CodeObject,
+    instructions: Vec<Instruction>,
+    locations: Vec<bytecode::Location>,
+    constants: Vec<bytecode::ConstantData>,
     name_cache: IndexSet<String>,
+    varname_cache: IndexSet<String>,
+    cellvar_cache: IndexSet<String>,
+    freevar_cache: IndexSet<String>,
     label_map: Vec<Option<Label>>,
 }
 impl CodeInfo {
     fn finalize_code(self) -> CodeObject {
         let CodeInfo {
             mut code,
+            instructions,
+            locations,
+            constants,
             name_cache,
+            varname_cache,
+            cellvar_cache,
+            freevar_cache,
             label_map,
         } = self;
-        code.names.extend(name_cache);
-        for instruction in &mut code.instructions {
+
+        code.instructions = instructions.into();
+        code.locations = locations.into();
+        code.constants = constants.into();
+        code.names = name_cache.into_iter().collect();
+        code.varnames = varname_cache.into_iter().collect();
+        code.cellvars = cellvar_cache.into_iter().collect();
+        code.freevars = freevar_cache.into_iter().collect();
+
+        if !code.cellvars.is_empty() {
+            let total_args = code.arg_count
+                + code.kwonlyarg_count
+                + code.flags.contains(bytecode::CodeFlags::HAS_VARARGS) as usize
+                + code.flags.contains(bytecode::CodeFlags::HAS_VARKEYWORDS) as usize;
+            let all_args = &code.varnames[..total_args];
+            let mut found_cellarg = false;
+            let cell2arg = code
+                .cellvars
+                .iter()
+                .map(|var| {
+                    all_args.iter().position(|arg| var == arg).map_or(-1, |i| {
+                        found_cellarg = true;
+                        i as isize
+                    })
+                })
+                .collect::<Box<[_]>>();
+            if found_cellarg {
+                code.cell2arg = Some(cell2arg);
+            }
+        }
+
+        for instruction in &mut *code.instructions {
             use Instruction::*;
             // this is a little bit hacky, as until now the data stored inside Labels in
             // Instructions is just bookkeeping, but I think it's the best way to do this
@@ -55,8 +95,10 @@ impl CodeInfo {
                 }
 
                 #[rustfmt::skip]
-                Import { .. } | ImportStar | ImportFrom { .. } | LoadName { .. } | StoreName { .. }
-                | DeleteName { .. } | Subscript | StoreSubscript | DeleteSubscript
+                Import { .. } | ImportStar | ImportFrom { .. } | LoadFast(_) | LoadNameAny(_)
+                | LoadGlobal(_) | LoadDeref(_) | LoadClassDeref(_) | StoreFast(_) | StoreLocal(_)
+                | StoreGlobal(_) | StoreDeref(_) | DeleteFast(_) | DeleteLocal(_) | DeleteGlobal(_)
+                | DeleteDeref(_) | LoadClosure(_) | Subscript | StoreSubscript | DeleteSubscript
                 | StoreAttr { .. } | DeleteAttr { .. } | LoadConst { .. } | UnaryOperation { .. }
                 | BinaryOperation { .. } | LoadAttr { .. } | CompareOperation { .. } | Pop
                 | Rotate { .. } | Duplicate | GetIter | Continue | Break | MakeFunction
@@ -73,6 +115,12 @@ impl CodeInfo {
     }
 }
 
+enum NameUsage {
+    Load,
+    Store,
+    Delete,
+}
+
 /// Main structure holding the state of compilation.
 struct Compiler {
     code_stack: Vec<CodeInfo>,
@@ -97,13 +145,14 @@ impl Default for CompileOpts {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Debug, Clone, Copy)]
 struct CompileContext {
     in_loop: bool,
+    in_class: bool,
     func: FunctionContext,
 }
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 enum FunctionContext {
     NoFunction,
     Function,
@@ -112,7 +161,7 @@ enum FunctionContext {
 
 impl CompileContext {
     fn in_func(self) -> bool {
-        !matches!(self.func, FunctionContext::NoFunction)
+        self.func != FunctionContext::NoFunction
     }
 }
 
@@ -122,8 +171,7 @@ fn with_compiler(
     opts: CompileOpts,
     f: impl FnOnce(&mut Compiler) -> CompileResult<()>,
 ) -> CompileResult<CodeObject> {
-    let mut compiler = Compiler::new(opts, source_path);
-    compiler.push_new_code_object("<module>".to_owned());
+    let mut compiler = Compiler::new(opts, source_path, "<module>".to_owned());
     f(&mut compiler)?;
     let code = compiler.pop_code_object();
     trace!("Compilation completed: {:?}", code);
@@ -176,9 +224,28 @@ pub fn compile_program_single(
 }
 
 impl Compiler {
-    fn new(opts: CompileOpts, source_path: String) -> Self {
+    fn new(opts: CompileOpts, source_path: String, code_name: String) -> Self {
+        let module_code = CodeInfo {
+            code: CodeObject::new(
+                bytecode::CodeFlags::NEW_LOCALS,
+                0,
+                0,
+                0,
+                source_path.clone(),
+                0,
+                code_name,
+            ),
+            instructions: Vec::new(),
+            locations: Vec::new(),
+            constants: Vec::new(),
+            name_cache: IndexSet::new(),
+            varname_cache: IndexSet::new(),
+            cellvar_cache: IndexSet::new(),
+            freevar_cache: IndexSet::new(),
+            label_map: Vec::new(),
+        };
         Compiler {
-            code_stack: Vec::new(),
+            code_stack: vec![module_code],
             symbol_table_stack: Vec::new(),
             source_path,
             current_source_location: ast::Location::default(),
@@ -186,6 +253,7 @@ impl Compiler {
             done_with_future_stmts: false,
             ctx: CompileContext {
                 in_loop: false,
+                in_class: false,
                 func: FunctionContext::NoFunction,
             },
             opts,
@@ -204,43 +272,65 @@ impl Compiler {
     }
 
     fn push_output(&mut self, code: CodeObject) {
-        self.code_stack.push(CodeInfo {
+        let table = self
+            .symbol_table_stack
+            .last_mut()
+            .unwrap()
+            .sub_tables
+            .remove(0);
+
+        let cellvar_cache = table
+            .symbols
+            .iter()
+            .filter(|(_, s)| s.scope == SymbolScope::Cell)
+            .map(|(var, _)| var.clone())
+            .collect();
+        let freevar_cache = table
+            .symbols
+            .iter()
+            .filter(|(_, s)| s.scope == SymbolScope::Free || s.is_free_class)
+            .map(|(var, _)| var.clone())
+            .collect();
+
+        self.symbol_table_stack.push(table);
+
+        let info = CodeInfo {
             code,
+            instructions: Vec::new(),
+            locations: Vec::new(),
+            constants: Vec::new(),
             name_cache: IndexSet::new(),
+            varname_cache: IndexSet::new(),
+            cellvar_cache,
+            freevar_cache,
             label_map: Vec::new(),
-        });
-    }
-
-    fn push_new_code_object(&mut self, obj_name: String) {
-        let line_number = self.get_source_line_number();
-        self.push_output(CodeObject::new(
-            Default::default(),
-            0,
-            0,
-            0,
-            self.source_path.clone(),
-            line_number,
-            obj_name,
-        ));
+        };
+        self.code_stack.push(info);
     }
 
     fn pop_code_object(&mut self) -> CodeObject {
+        let table = self.symbol_table_stack.pop().unwrap();
+        assert!(table.sub_tables.is_empty());
         self.code_stack.pop().unwrap().finalize_code()
     }
 
     // could take impl Into<Cow<str>>, but everything is borrowed from ast structs; we never
     // actually have a `String` to pass
     fn name(&mut self, name: &str) -> bytecode::NameIdx {
-        let cache = &mut self
-            .code_stack
-            .last_mut()
-            .expect("nothing on stack")
-            .name_cache;
-        if let Some(x) = cache.get_index_of(name) {
-            x
-        } else {
-            cache.insert_full(name.to_owned()).0
-        }
+        self._name_inner(name, |i| &mut i.name_cache)
+    }
+    fn varname(&mut self, name: &str) -> bytecode::NameIdx {
+        self._name_inner(name, |i| &mut i.varname_cache)
+    }
+    fn _name_inner(
+        &mut self,
+        name: &str,
+        cache: impl FnOnce(&mut CodeInfo) -> &mut IndexSet<String>,
+    ) -> bytecode::NameIdx {
+        let cache = cache(self.current_codeinfo());
+        cache
+            .get_index_of(name)
+            .unwrap_or_else(|| cache.insert_full(name.to_owned()).0)
     }
 
     fn compile_program(
@@ -255,11 +345,13 @@ impl Compiler {
         if let Some(value) = doc {
             self.emit_constant(bytecode::ConstantData::Str { value });
             let doc = self.name("__doc__");
-            self.emit(Instruction::StoreName {
-                idx: doc,
-                scope: bytecode::NameScope::Global,
-            });
+            self.emit(Instruction::StoreGlobal(doc))
         }
+
+        if self.find_ann(statements) {
+            self.emit(Instruction::SetupAnnotation);
+        }
+
         self.compile_statements(statements)?;
 
         assert_eq!(self.code_stack.len(), size_before);
@@ -331,34 +423,81 @@ impl Compiler {
         Ok(())
     }
 
-    fn scope_for_name(&self, name: &str) -> bytecode::NameScope {
-        let symbol = self.lookup_name(name);
-        match symbol.scope {
-            SymbolScope::Global => bytecode::NameScope::Global,
-            SymbolScope::Nonlocal => bytecode::NameScope::NonLocal,
-            SymbolScope::Unknown => bytecode::NameScope::Free,
-            SymbolScope::Local => {
-                // Only in function block, we use load local
-                // https://github.com/python/cpython/blob/master/Python/compile.c#L3582
-                if self.ctx.in_func() {
-                    bytecode::NameScope::Local
-                } else {
-                    bytecode::NameScope::Free
-                }
-            }
-        }
-    }
-
     fn load_name(&mut self, name: &str) {
-        let scope = self.scope_for_name(name);
-        let idx = self.name(name);
-        self.emit(Instruction::LoadName { idx, scope });
+        self.compile_name(name, NameUsage::Load)
     }
 
     fn store_name(&mut self, name: &str) {
-        let scope = self.scope_for_name(name);
-        let idx = self.name(name);
-        self.emit(Instruction::StoreName { idx, scope });
+        self.compile_name(name, NameUsage::Store)
+    }
+
+    fn compile_name(&mut self, name: &str, usage: NameUsage) {
+        let symbol_table = self.symbol_table_stack.last().unwrap();
+        let symbol = symbol_table.lookup(name).expect(
+            "The symbol must be present in the symbol table, even when it is undefined in python.",
+        );
+        let info = self.code_stack.last_mut().unwrap();
+        let mut cache = &mut info.name_cache;
+        enum NameOpType {
+            Fast,
+            Global,
+            Deref,
+            Local,
+        }
+        let op_typ = match symbol.scope {
+            SymbolScope::Local if self.ctx.in_func() => {
+                cache = &mut info.varname_cache;
+                NameOpType::Fast
+            }
+            SymbolScope::GlobalExplicit => NameOpType::Global,
+            SymbolScope::GlobalImplicit | SymbolScope::Unknown if self.ctx.in_func() => {
+                NameOpType::Global
+            }
+            SymbolScope::GlobalImplicit | SymbolScope::Unknown => NameOpType::Local,
+            SymbolScope::Local => NameOpType::Local,
+            SymbolScope::Free => {
+                cache = &mut info.freevar_cache;
+                NameOpType::Deref
+            }
+            SymbolScope::Cell => {
+                cache = &mut info.cellvar_cache;
+                NameOpType::Deref
+            }
+            // // TODO: is this right?
+            // SymbolScope::Unknown => NameOpType::Global,
+        };
+        let mut idx = cache
+            .get_index_of(name)
+            .unwrap_or_else(|| cache.insert_full(name.to_owned()).0);
+        if let SymbolScope::Free = symbol.scope {
+            idx += info.cellvar_cache.len();
+        }
+        let op = match op_typ {
+            NameOpType::Fast => match usage {
+                NameUsage::Load => Instruction::LoadFast,
+                NameUsage::Store => Instruction::StoreFast,
+                NameUsage::Delete => Instruction::DeleteFast,
+            },
+            NameOpType::Global => match usage {
+                NameUsage::Load => Instruction::LoadGlobal,
+                NameUsage::Store => Instruction::StoreGlobal,
+                NameUsage::Delete => Instruction::DeleteGlobal,
+            },
+            NameOpType::Deref => match usage {
+                NameUsage::Load if !self.ctx.in_func() && self.ctx.in_class => {
+                    Instruction::LoadClassDeref
+                }
+                NameUsage::Load => Instruction::LoadDeref,
+                NameUsage::Store => Instruction::StoreDeref,
+                NameUsage::Delete => Instruction::DeleteDeref,
+            },
+            NameOpType::Local => match usage {
+                NameUsage::Load => Instruction::LoadNameAny,
+                NameUsage::Store => Instruction::StoreLocal,
+                NameUsage::Delete => Instruction::DeleteLocal,
+            },
+        };
+        self.emit(op(idx));
     }
 
     fn compile_statement(&mut self, statement: &ast::Statement) -> CompileResult<()> {
@@ -407,6 +546,10 @@ impl Compiler {
                 let module_idx = module.as_ref().map(|s| self.name(s));
 
                 if import_star {
+                    if self.ctx.in_func() {
+                        return Err(self
+                            .error_loc(CompileErrorType::FunctionImportStar, statement.location));
+                    }
                     let star = self.name("*");
                     // from .... import *
                     self.emit(Instruction::Import {
@@ -584,10 +727,7 @@ impl Compiler {
                     let end_label = self.new_label();
                     self.compile_jump_if(test, true, end_label)?;
                     let assertion_error = self.name("AssertionError");
-                    self.emit(Instruction::LoadName {
-                        idx: assertion_error,
-                        scope: bytecode::NameScope::Global,
-                    });
+                    self.emit(Instruction::LoadGlobal(assertion_error));
                     match msg {
                         Some(e) => {
                             self.compile_expression(e)?;
@@ -683,8 +823,7 @@ impl Compiler {
     fn compile_delete(&mut self, expression: &ast::Expression) -> CompileResult<()> {
         match &expression.node {
             ast::ExpressionType::Identifier { name } => {
-                let idx = self.name(name);
-                self.emit(Instruction::DeleteName { idx });
+                self.compile_name(name, NameUsage::Delete);
             }
             ast::ExpressionType::Attribute { value, name } => {
                 self.compile_expression(value)?;
@@ -738,7 +877,7 @@ impl Compiler {
             });
         }
 
-        let mut flags = bytecode::CodeFlags::default();
+        let mut flags = bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED;
         if have_defaults {
             flags |= bytecode::CodeFlags::HAS_DEFAULTS;
         }
@@ -758,25 +897,23 @@ impl Compiler {
         ));
 
         for name in &args.args {
-            self.name(&name.arg);
+            self.varname(&name.arg);
         }
         for name in &args.kwonlyargs {
-            self.name(&name.arg);
+            self.varname(&name.arg);
         }
 
         let mut compile_varargs = |va: &ast::Varargs, flag| match va {
             ast::Varargs::None | ast::Varargs::Unnamed => {}
             ast::Varargs::Named(name) => {
                 self.current_code().flags |= flag;
-                self.name(&name.arg);
+                self.varname(&name.arg);
             }
         };
 
         compile_varargs(&args.vararg, bytecode::CodeFlags::HAS_VARARGS);
         compile_varargs(&args.kwarg, bytecode::CodeFlags::HAS_VARKEYWORDS);
 
-        self.enter_scope();
-
         Ok(())
     }
 
@@ -918,11 +1055,16 @@ impl Compiler {
         is_async: bool,
     ) -> CompileResult<()> {
         // Create bytecode for this function:
+
+        self.prepare_decorators(decorator_list)?;
+        self.enter_function(name, args)?;
+
         // remember to restore self.ctx.in_loop to the original after the function is compiled
         let prev_ctx = self.ctx;
 
         self.ctx = CompileContext {
             in_loop: false,
+            in_class: prev_ctx.in_class,
             func: if is_async {
                 FunctionContext::AsyncFunction
             } else {
@@ -934,10 +1076,6 @@ impl Compiler {
         let old_qualified_path = self.current_qualified_path.take();
         self.current_qualified_path = Some(self.create_qualified_name(name, ".<locals>"));
 
-        self.prepare_decorators(decorator_list)?;
-
-        self.enter_function(name, args)?;
-
         let (body, doc_str) = get_doc(body);
 
         self.compile_statements(body)?;
@@ -954,7 +1092,8 @@ impl Compiler {
         }
 
         let mut code = self.pop_code_object();
-        self.leave_scope();
+        self.current_qualified_path = old_qualified_path;
+        self.ctx = prev_ctx;
 
         // Prepare type annotations:
         let mut num_annotations = 0;
@@ -1006,6 +1145,8 @@ impl Compiler {
             code.flags |= bytecode::CodeFlags::IS_COROUTINE;
         }
 
+        self.build_closure(&code);
+
         self.emit_constant(bytecode::ConstantData::Code {
             code: Box::new(code),
         });
@@ -1021,15 +1162,42 @@ impl Compiler {
         self.emit(Instruction::Rotate { amount: 2 });
         let doc = self.name("__doc__");
         self.emit(Instruction::StoreAttr { idx: doc });
+
         self.apply_decorators(decorator_list);
 
         self.store_name(name);
 
-        self.current_qualified_path = old_qualified_path;
-        self.ctx = prev_ctx;
         Ok(())
     }
 
+    fn build_closure(&mut self, code: &CodeObject) {
+        if !code.freevars.is_empty() {
+            for var in &*code.freevars {
+                let table = self.symbol_table_stack.last().unwrap();
+                let symbol = table.lookup(var).unwrap();
+                let parent_code = self.code_stack.last().unwrap();
+                let vars = match symbol.scope {
+                    SymbolScope::Free => &parent_code.freevar_cache,
+                    SymbolScope::Cell => &parent_code.cellvar_cache,
+                    _ if symbol.is_free_class => &parent_code.freevar_cache,
+                    x => unreachable!(
+                        "var {} in a {:?} should be free or cell but it's {:?}",
+                        var, table.typ, x
+                    ),
+                };
+                let mut idx = vars.get_index_of(var).unwrap();
+                if let SymbolScope::Free = symbol.scope {
+                    idx += parent_code.cellvar_cache.len();
+                }
+                self.emit(Instruction::LoadClosure(idx))
+            }
+            self.emit(Instruction::BuildTuple {
+                size: code.freevars.len(),
+                unpack: false,
+            })
+        }
+    }
+
     fn find_ann(&self, body: &[ast::Statement]) -> bool {
         use ast::StatementType::*;
         let option_stmt_to_bool = |suit: &Option<ast::Suite>| -> bool {
@@ -1095,9 +1263,12 @@ impl Compiler {
         keywords: &[ast::Keyword],
         decorator_list: &[ast::Expression],
     ) -> CompileResult<()> {
+        self.prepare_decorators(decorator_list)?;
+
         let prev_ctx = self.ctx;
         self.ctx = CompileContext {
             func: FunctionContext::NoFunction,
+            in_class: true,
             in_loop: false,
         };
 
@@ -1105,11 +1276,10 @@ impl Compiler {
         let old_qualified_path = self.current_qualified_path.take();
         self.current_qualified_path = Some(qualified_name.clone());
 
-        self.prepare_decorators(decorator_list)?;
         self.emit(Instruction::LoadBuildClass);
         let line_number = self.get_source_line_number();
         self.push_output(CodeObject::new(
-            Default::default(),
+            bytecode::CodeFlags::empty(),
             0,
             0,
             0,
@@ -1117,45 +1287,52 @@ impl Compiler {
             line_number,
             name.to_owned(),
         ));
-        self.enter_scope();
 
         let (new_body, doc_str) = get_doc(body);
 
         let dunder_name = self.name("__name__");
-        self.emit(Instruction::LoadName {
-            idx: dunder_name,
-            scope: bytecode::NameScope::Global,
-        });
+        self.emit(Instruction::LoadGlobal(dunder_name));
         let dunder_module = self.name("__module__");
-        self.emit(Instruction::StoreName {
-            idx: dunder_module,
-            scope: bytecode::NameScope::Free,
-        });
+        self.emit(Instruction::StoreLocal(dunder_module));
         self.emit_constant(bytecode::ConstantData::Str {
             value: qualified_name.clone(),
         });
         let qualname = self.name("__qualname__");
-        self.emit(Instruction::StoreName {
-            idx: qualname,
-            scope: bytecode::NameScope::Free,
-        });
+        self.emit(Instruction::StoreLocal(qualname));
         self.load_docstring(doc_str);
         let doc = self.name("__doc__");
-        self.emit(Instruction::StoreName {
-            idx: doc,
-            scope: bytecode::NameScope::Free,
-        });
+        self.emit(Instruction::StoreLocal(doc));
         // setup annotations
         if self.find_ann(body) {
             self.emit(Instruction::SetupAnnotation);
         }
         self.compile_statements(new_body)?;
-        self.emit_constant(bytecode::ConstantData::None);
+
+        let classcell_idx = self
+            .code_stack
+            .last_mut()
+            .unwrap()
+            .cellvar_cache
+            .iter()
+            .position(|var| *var == "__class__");
+
+        if let Some(classcell_idx) = classcell_idx {
+            self.emit(Instruction::LoadClosure(classcell_idx));
+            self.emit(Instruction::Duplicate);
+            let classcell = self.name("__classcell__");
+            self.emit(Instruction::StoreLocal(classcell));
+        } else {
+            self.emit_constant(bytecode::ConstantData::None);
+        }
+
         self.emit(Instruction::ReturnValue);
 
-        let mut code = self.pop_code_object();
-        code.flags.remove(bytecode::CodeFlags::NEW_LOCALS);
-        self.leave_scope();
+        let code = self.pop_code_object();
+
+        self.current_qualified_path = old_qualified_path;
+        self.ctx = prev_ctx;
+
+        self.build_closure(&code);
 
         self.emit_constant(bytecode::ConstantData::Code {
             code: Box::new(code),
@@ -1204,8 +1381,6 @@ impl Compiler {
         self.apply_decorators(decorator_list);
 
         self.store_name(name);
-        self.current_qualified_path = old_qualified_path;
-        self.ctx = prev_ctx;
         Ok(())
     }
 
@@ -1295,10 +1470,7 @@ impl Compiler {
             self.set_label(check_asynciter_label);
             self.emit(Instruction::Duplicate);
             let stopasynciter = self.name("StopAsyncIteration");
-            self.emit(Instruction::LoadName {
-                idx: stopasynciter,
-                scope: bytecode::NameScope::Global,
-            });
+            self.emit(Instruction::LoadGlobal(stopasynciter));
             self.emit(Instruction::CompareOperation {
                 op: bytecode::ComparisonOperator::ExceptionMatch,
             });
@@ -1437,10 +1609,7 @@ impl Compiler {
         if let ast::ExpressionType::Identifier { name } = &target.node {
             // Store as dict entry in __annotations__ dict:
             let annotations = self.name("__annotations__");
-            self.emit(Instruction::LoadName {
-                idx: annotations,
-                scope: bytecode::NameScope::Local,
-            });
+            self.emit(Instruction::LoadNameAny(annotations));
             self.emit_constant(bytecode::ConstantData::Str {
                 value: name.to_owned(),
             });
@@ -1449,6 +1618,7 @@ impl Compiler {
             // Drop annotation if not assigned to simple identifier.
             self.emit(Instruction::Pop);
         }
+
         Ok(())
     }
 
@@ -1846,6 +2016,7 @@ impl Compiler {
                 let prev_ctx = self.ctx;
                 self.ctx = CompileContext {
                     in_loop: false,
+                    in_class: prev_ctx.in_class,
                     func: FunctionContext::Function,
                 };
 
@@ -1854,7 +2025,7 @@ impl Compiler {
                 self.compile_expression(body)?;
                 self.emit(Instruction::ReturnValue);
                 let code = self.pop_code_object();
-                self.leave_scope();
+                self.build_closure(&code);
                 self.emit_constant(bytecode::ConstantData::Code {
                     code: Box::new(code),
                 });
@@ -2022,6 +2193,14 @@ impl Compiler {
         kind: &ast::ComprehensionKind,
         generators: &[ast::Comprehension],
     ) -> CompileResult<()> {
+        let prev_ctx = self.ctx;
+
+        self.ctx = CompileContext {
+            in_loop: false,
+            in_class: prev_ctx.in_class,
+            func: FunctionContext::Function,
+        };
+
         // We must have at least one generator:
         assert!(!generators.is_empty());
 
@@ -2036,7 +2215,7 @@ impl Compiler {
         let line_number = self.get_source_line_number();
         // Create magnificent function <listcomp>:
         self.push_output(CodeObject::new(
-            Default::default(),
+            bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED,
             1,
             1,
             0,
@@ -2044,8 +2223,7 @@ impl Compiler {
             line_number,
             name.clone(),
         ));
-        let arg0 = self.name(".0");
-        self.enter_scope();
+        let arg0 = self.varname(".0");
 
         // Create empty object of proper type:
         match kind {
@@ -2079,10 +2257,7 @@ impl Compiler {
 
             if loop_labels.is_empty() {
                 // Load iterator onto stack (passed as first argument):
-                self.emit(Instruction::LoadName {
-                    idx: arg0,
-                    scope: bytecode::NameScope::Local,
-                });
+                self.emit(Instruction::LoadFast(arg0));
             } else {
                 // Evaluate iterated item:
                 self.compile_expression(&generator.iter)?;
@@ -2169,8 +2344,9 @@ impl Compiler {
         // Fetch code for listcomp function:
         let code = self.pop_code_object();
 
-        // Pop scope
-        self.leave_scope();
+        self.ctx = prev_ctx;
+
+        self.build_closure(&code);
 
         // List comprehension code:
         self.emit_constant(bytecode::ConstantData::Code {
@@ -2255,60 +2431,33 @@ impl Compiler {
         Ok(())
     }
 
-    // Scope helpers:
-    fn enter_scope(&mut self) {
-        // println!("Enter scope {:?}", self.symbol_table_stack);
-        // Enter first subscope!
-        let table = self
-            .symbol_table_stack
-            .last_mut()
-            .unwrap()
-            .sub_tables
-            .remove(0);
-        self.symbol_table_stack.push(table);
-    }
-
-    fn leave_scope(&mut self) {
-        // println!("Leave scope {:?}", self.symbol_table_stack);
-        let table = self.symbol_table_stack.pop().unwrap();
-        assert!(table.sub_tables.is_empty());
-    }
-
-    fn lookup_name(&self, name: &str) -> &Symbol {
-        // println!("Looking up {:?}", name);
-        let symbol_table = self.symbol_table_stack.last().unwrap();
-        symbol_table.lookup(name).expect(
-            "The symbol must be present in the symbol table, even when it is undefined in python.",
-        )
-    }
-
     // Low level helper functions:
     fn emit(&mut self, instruction: Instruction) {
         let location = compile_location(&self.current_source_location);
         // TODO: insert source filename
-        let code = self.current_code();
-        code.instructions.push(instruction);
-        code.locations.push(location);
+        let info = self.current_codeinfo();
+        info.instructions.push(instruction);
+        info.locations.push(location);
     }
 
     fn emit_constant(&mut self, constant: bytecode::ConstantData) {
-        let code = self.current_code();
-        let idx = code.constants.len();
-        code.constants.push(constant);
+        let info = self.current_codeinfo();
+        let idx = info.constants.len();
+        info.constants.push(constant);
         self.emit(Instruction::LoadConst { idx })
     }
 
     fn current_code(&mut self) -> &mut CodeObject {
-        &mut self
-            .code_stack
-            .last_mut()
-            .expect("No OutputStream on stack")
-            .code
+        &mut self.current_codeinfo().code
+    }
+
+    fn current_codeinfo(&mut self) -> &mut CodeInfo {
+        self.code_stack.last_mut().expect("no code on stack")
     }
 
     // Generate a new label
     fn new_label(&mut self) -> Label {
-        let label_map = &mut self.code_stack.last_mut().unwrap().label_map;
+        let label_map = &mut self.current_codeinfo().label_map;
         let label = Label(label_map.len());
         label_map.push(None);
         label
@@ -2317,9 +2466,11 @@ impl Compiler {
     // Assign current position the given label
     fn set_label(&mut self, label: Label) {
         let CodeInfo {
-            code, label_map, ..
-        } = self.code_stack.last_mut().unwrap();
-        let actual_label = Label(code.instructions.len());
+            instructions,
+            label_map,
+            ..
+        } = self.current_codeinfo();
+        let actual_label = Label(instructions.len());
         let prev_val = std::mem::replace(&mut label_map[label.0], Some(actual_label));
         debug_assert!(
             prev_val.map_or(true, |x| x == actual_label),
@@ -2402,9 +2553,11 @@ mod tests {
     use rustpython_parser::parser;
 
     fn compile_exec(source: &str) -> CodeObject {
-        let mut compiler: Compiler =
-            Compiler::new(CompileOpts::default(), "source_path".to_owned());
-        compiler.push_new_code_object("<module>".to_owned());
+        let mut compiler: Compiler = Compiler::new(
+            CompileOpts::default(),
+            "source_path".to_owned(),
+            "<module>".to_owned(),
+        );
         let ast = parser::parse_program(source).unwrap();
         let symbol_scope = make_symbol_table(&ast).unwrap();
         compiler.compile_program(&ast, symbol_scope).unwrap();
diff --git a/compiler/src/error.rs b/compiler/src/error.rs
index 37881f5c2b..b5b1d866c9 100644
--- a/compiler/src/error.rs
+++ b/compiler/src/error.rs
@@ -36,6 +36,7 @@ pub enum CompileErrorType {
     AsyncReturnValue,
     InvalidFuturePlacement,
     InvalidFutureFeature(String),
+    FunctionImportStar,
 }
 
 impl fmt::Display for CompileErrorType {
@@ -66,6 +67,9 @@ impl fmt::Display for CompileErrorType {
             CompileErrorType::InvalidFutureFeature(feat) => {
                 write!(f, "future feature {} is not defined", feat)
             }
+            CompileErrorType::FunctionImportStar => {
+                write!(f, "import * only allowed at module level")
+            }
         }
     }
 }
diff --git a/compiler/src/snapshots/rustpython_compiler__compile__tests__if_ands.snap b/compiler/src/snapshots/rustpython_compiler_core__compile__tests__if_ands.snap
similarity index 100%
rename from compiler/src/snapshots/rustpython_compiler__compile__tests__if_ands.snap
rename to compiler/src/snapshots/rustpython_compiler_core__compile__tests__if_ands.snap
diff --git a/compiler/src/snapshots/rustpython_compiler__compile__tests__if_mixed.snap b/compiler/src/snapshots/rustpython_compiler_core__compile__tests__if_mixed.snap
similarity index 100%
rename from compiler/src/snapshots/rustpython_compiler__compile__tests__if_mixed.snap
rename to compiler/src/snapshots/rustpython_compiler_core__compile__tests__if_mixed.snap
diff --git a/compiler/src/snapshots/rustpython_compiler__compile__tests__if_ors.snap b/compiler/src/snapshots/rustpython_compiler_core__compile__tests__if_ors.snap
similarity index 100%
rename from compiler/src/snapshots/rustpython_compiler__compile__tests__if_ors.snap
rename to compiler/src/snapshots/rustpython_compiler_core__compile__tests__if_ors.snap
diff --git a/compiler/src/symboltable.rs b/compiler/src/symboltable.rs
index 276e55c49c..e5c238ea84 100644
--- a/compiler/src/symboltable.rs
+++ b/compiler/src/symboltable.rs
@@ -64,7 +64,7 @@ impl SymbolTable {
     }
 }
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum SymbolTableType {
     Module,
     Class,
@@ -85,12 +85,14 @@ impl fmt::Display for SymbolTableType {
 
 /// Indicator for a single symbol what the scope of this symbol is.
 /// The scope can be unknown, which is unfortunate, but not impossible.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum SymbolScope {
-    Global,
-    Nonlocal,
-    Local,
     Unknown,
+    Local,
+    GlobalExplicit,
+    GlobalImplicit,
+    Free,
+    Cell,
 }
 
 /// A single symbol in a table. Has various properties such as the scope
@@ -104,9 +106,9 @@ pub struct Symbol {
     pub is_referenced: bool,
     pub is_assigned: bool,
     pub is_parameter: bool,
-    pub is_free: bool,
     pub is_annotated: bool,
     pub is_imported: bool,
+    pub is_nonlocal: bool,
 
     // indicates if the symbol gets a value assigned by a named expression in a comprehension
     // this is required to correct the scope in the analysis.
@@ -115,6 +117,16 @@ pub struct Symbol {
     // inidicates that the symbol is used a bound iterator variable. We distinguish this case
     // from normal assignment to detect unallowed re-assignment to iterator variables.
     pub is_iter: bool,
+
+    /// indicates that the symbol is a free variable in a class method from the scope that the
+    /// class is defined in, e.g.:
+    /// ```python
+    /// def foo(x):
+    ///     class A:
+    ///         def method(self):
+    ///             return x // is_free_class
+    /// ```
+    pub is_free_class: bool,
 }
 
 impl Symbol {
@@ -126,20 +138,28 @@ impl Symbol {
             is_referenced: false,
             is_assigned: false,
             is_parameter: false,
-            is_free: false,
             is_annotated: false,
             is_imported: false,
+            is_nonlocal: false,
             is_assign_namedexpr_in_comprehension: false,
             is_iter: false,
+            is_free_class: false,
         }
     }
 
     pub fn is_global(&self) -> bool {
-        matches!(self.scope, SymbolScope::Global)
+        matches!(
+            self.scope,
+            SymbolScope::GlobalExplicit | SymbolScope::GlobalImplicit
+        )
     }
 
     pub fn is_local(&self) -> bool {
-        matches!(self.scope, SymbolScope::Local)
+        self.scope == SymbolScope::Local
+    }
+
+    pub fn is_bound(&self) -> bool {
+        self.is_assigned || self.is_parameter || self.is_imported || self.is_iter
     }
 }
 
@@ -186,29 +206,91 @@ fn analyze_symbol_table(symbol_table: &mut SymbolTable) -> SymbolTableResult {
     analyzer.analyze_symbol_table(symbol_table)
 }
 
+type SymbolMap = IndexMap<String, Symbol>;
+
+mod stack {
+    use std::panic;
+    use std::ptr::NonNull;
+    pub struct StackStack<T> {
+        v: Vec<NonNull<T>>,
+    }
+    impl<T> Default for StackStack<T> {
+        fn default() -> Self {
+            Self { v: Vec::new() }
+        }
+    }
+    impl<T> StackStack<T> {
+        /// Appends a reference to this stack for the duration of the function `f`. When `f`
+        /// returns, the reference will be popped off the stack.
+        pub fn with_append<F, R>(&mut self, x: &mut T, f: F) -> R
+        where
+            F: FnOnce(&mut Self) -> R,
+        {
+            self.v.push(x.into());
+            let res = panic::catch_unwind(panic::AssertUnwindSafe(|| f(self)));
+            self.v.pop();
+            res.unwrap_or_else(|x| panic::resume_unwind(x))
+        }
+
+        pub fn iter(&self) -> impl Iterator<Item = &T> + DoubleEndedIterator + '_ {
+            self.as_ref().iter().copied()
+        }
+        pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> + DoubleEndedIterator + '_ {
+            self.as_mut().iter_mut().map(|x| &mut **x)
+        }
+        // pub fn top(&self) -> Option<&T> {
+        //     self.as_ref().last().copied()
+        // }
+        // pub fn top_mut(&mut self) -> Option<&mut T> {
+        //     self.as_mut().last_mut().map(|x| &mut **x)
+        // }
+        pub fn len(&self) -> usize {
+            self.v.len()
+        }
+        pub fn is_empty(&self) -> bool {
+            self.len() == 0
+        }
+
+        pub fn as_ref(&self) -> &[&T] {
+            unsafe { &*(self.v.as_slice() as *const [NonNull<T>] as *const [&T]) }
+        }
+
+        pub fn as_mut(&mut self) -> &mut [&mut T] {
+            unsafe { &mut *(self.v.as_mut_slice() as *mut [NonNull<T>] as *mut [&mut T]) }
+        }
+    }
+}
+use stack::StackStack;
+
 /// Symbol table analysis. Can be used to analyze a fully
 /// build symbol table structure. It will mark variables
 /// as local variables for example.
 #[derive(Default)]
-struct SymbolTableAnalyzer<'a> {
-    tables: Vec<(&'a mut IndexMap<String, Symbol>, SymbolTableType)>,
+#[repr(transparent)]
+struct SymbolTableAnalyzer {
+    tables: StackStack<(SymbolMap, SymbolTableType)>,
 }
 
-impl<'a> SymbolTableAnalyzer<'a> {
-    fn analyze_symbol_table(&mut self, symbol_table: &'a mut SymbolTable) -> SymbolTableResult {
-        let symbols = &mut symbol_table.symbols;
-        let sub_tables = &mut symbol_table.sub_tables;
+impl SymbolTableAnalyzer {
+    fn analyze_symbol_table(&mut self, symbol_table: &mut SymbolTable) -> SymbolTableResult {
+        let symbols = std::mem::take(&mut symbol_table.symbols);
+        let sub_tables = &mut *symbol_table.sub_tables;
+
+        let mut info = (symbols, symbol_table.typ);
+        self.tables.with_append(&mut info, |list| {
+            let inner_scope = unsafe { &mut *(list as *mut _ as *mut SymbolTableAnalyzer) };
+            // Analyze sub scopes:
+            for sub_table in sub_tables.iter_mut() {
+                inner_scope.analyze_symbol_table(sub_table)?;
+            }
+            Ok(())
+        })?;
 
-        self.tables.push((symbols, symbol_table.typ));
-        // Analyze sub scopes:
-        for sub_table in sub_tables {
-            self.analyze_symbol_table(sub_table)?;
-        }
-        let (symbols, st_typ) = self.tables.pop().unwrap();
+        symbol_table.symbols = info.0;
 
         // Analyze symbols:
-        for symbol in symbols.values_mut() {
-            self.analyze_symbol(symbol, st_typ)?;
+        for symbol in symbol_table.symbols.values_mut() {
+            self.analyze_symbol(symbol, symbol_table.typ, sub_tables)?;
         }
         Ok(())
     }
@@ -216,11 +298,10 @@ impl<'a> SymbolTableAnalyzer<'a> {
     fn analyze_symbol(
         &mut self,
         symbol: &mut Symbol,
-        curr_st_typ: SymbolTableType,
+        st_typ: SymbolTableType,
+        sub_tables: &mut [SymbolTable],
     ) -> SymbolTableResult {
-        if symbol.is_assign_namedexpr_in_comprehension
-            && curr_st_typ == SymbolTableType::Comprehension
-        {
+        if symbol.is_assign_namedexpr_in_comprehension && st_typ == SymbolTableType::Comprehension {
             // propagate symbol to next higher level that can hold it,
             // i.e., function or module. Comprehension is skipped and
             // Class is not allowed and detected as error.
@@ -228,12 +309,14 @@ impl<'a> SymbolTableAnalyzer<'a> {
             self.analyze_symbol_comprehension(symbol, 0)?
         } else {
             match symbol.scope {
-                SymbolScope::Nonlocal => {
-                    let scope_depth = self.tables.len();
-                    if scope_depth > 0 {
+                SymbolScope::Free => {
+                    if !self.tables.as_ref().is_empty() {
+                        let scope_depth = self.tables.as_ref().len();
                         // check if the name is already defined in any outer scope
                         // therefore
-                        if scope_depth < 2 || !self.found_in_outer_scope(symbol) {
+                        if scope_depth < 2
+                            || self.found_in_outer_scope(&symbol.name) != Some(SymbolScope::Free)
+                        {
                             return Err(SymbolTableError {
                                 error: format!("no binding for nonlocal '{}' found", symbol.name),
                                 // TODO: accurate location info, somehow
@@ -251,43 +334,107 @@ impl<'a> SymbolTableAnalyzer<'a> {
                         });
                     }
                 }
-                SymbolScope::Global => {
+                SymbolScope::GlobalExplicit | SymbolScope::GlobalImplicit => {
                     // TODO: add more checks for globals?
                 }
-                SymbolScope::Local => {
+                SymbolScope::Local | SymbolScope::Cell => {
                     // all is well
                 }
                 SymbolScope::Unknown => {
                     // Try hard to figure out what the scope of this symbol is.
-                    self.analyze_unknown_symbol(symbol);
+                    let scope = if symbol.is_bound() {
+                        self.found_in_inner_scope(sub_tables, &symbol.name, st_typ)
+                            .unwrap_or(SymbolScope::Local)
+                    } else if let Some(scope) = self.found_in_outer_scope(&symbol.name) {
+                        scope
+                    } else if self.tables.is_empty() {
+                        // Don't make assumptions when we don't know.
+                        SymbolScope::Unknown
+                    } else {
+                        // If there are scopes above we assume global.
+                        SymbolScope::GlobalImplicit
+                    };
+                    symbol.scope = scope;
                 }
             }
         }
         Ok(())
     }
 
-    fn found_in_outer_scope(&self, symbol: &Symbol) -> bool {
+    fn found_in_outer_scope(&mut self, name: &str) -> Option<SymbolScope> {
         // Interesting stuff about the __class__ variable:
         // https://docs.python.org/3/reference/datamodel.html?highlight=__class__#creating-the-class-object
-        symbol.name == "__class__"
-            || self.tables.iter().skip(1).any(|(symbols, typ)| {
-                *typ != SymbolTableType::Class && symbols.contains_key(&symbol.name)
-            })
-    }
+        if name == "__class__" {
+            return Some(SymbolScope::Free);
+        }
 
-    fn analyze_unknown_symbol(&self, symbol: &mut Symbol) {
-        if symbol.is_assigned || symbol.is_parameter {
-            symbol.scope = SymbolScope::Local;
-        } else if self.found_in_outer_scope(symbol) {
-            // Symbol is in some outer scope.
-            symbol.is_free = true;
-        } else if self.tables.is_empty() {
-            // Don't make assumptions when we don't know.
-            symbol.scope = SymbolScope::Unknown;
-        } else {
-            // If there are scopes above we can assume global.
-            symbol.scope = SymbolScope::Global;
+        let mut decl_depth = None;
+        for (i, (symbols, typ)) in self.tables.iter().rev().enumerate() {
+            if let SymbolTableType::Class | SymbolTableType::Module = typ {
+                continue;
+            }
+            if let Some(sym) = symbols.get(name) {
+                match sym.scope {
+                    SymbolScope::GlobalExplicit => return Some(SymbolScope::GlobalExplicit),
+                    SymbolScope::GlobalImplicit => {}
+                    _ => {
+                        if sym.is_bound() {
+                            decl_depth = Some(i);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        if let Some(decl_depth) = decl_depth {
+            // decl_depth is the number of tables between the current one and
+            // the one that declared the cell var
+            for (table, typ) in self.tables.iter_mut().rev().take(decl_depth) {
+                if let SymbolTableType::Class = typ {
+                    if let Some(free_class) = table.get_mut(name) {
+                        free_class.is_free_class = true;
+                    } else {
+                        let mut symbol = Symbol::new(name);
+                        symbol.is_free_class = true;
+                        symbol.scope = SymbolScope::Free;
+                        table.insert(name.to_owned(), symbol);
+                    }
+                } else if !table.contains_key(name) {
+                    let mut symbol = Symbol::new(name);
+                    symbol.scope = SymbolScope::Free;
+                    // symbol.is_referenced = true;
+                    table.insert(name.to_owned(), symbol);
+                }
+            }
         }
+
+        decl_depth.map(|_| SymbolScope::Free)
+    }
+
+    fn found_in_inner_scope(
+        &self,
+        sub_tables: &[SymbolTable],
+        name: &str,
+        st_typ: SymbolTableType,
+    ) -> Option<SymbolScope> {
+        sub_tables.iter().find_map(|st| {
+            st.symbols.get(name).and_then(|sym| {
+                if sym.scope == SymbolScope::Free || sym.is_free_class {
+                    if st_typ == SymbolTableType::Class && name != "__class__" {
+                        None
+                    } else {
+                        Some(SymbolScope::Cell)
+                    }
+                } else if sym.scope == SymbolScope::GlobalExplicit && self.tables.is_empty() {
+                    // the symbol is defined on the module level, and an inner scope declares
+                    // a global that points to it
+                    Some(SymbolScope::GlobalExplicit)
+                } else {
+                    None
+                }
+            })
+        })
     }
 
     // Implements the symbol analysis and scope extension for names
@@ -298,10 +445,8 @@ impl<'a> SymbolTableAnalyzer<'a> {
         symbol: &mut Symbol,
         parent_offset: usize,
     ) -> SymbolTableResult {
-        // TODO: quite C-ish way to implement the iteration
         // when this is called, we expect to be in the direct parent scope of the scope that contains 'symbol'
-        let offs = self.tables.len() - 1 - parent_offset;
-        let last = self.tables.get_mut(offs).unwrap();
+        let last = self.tables.iter_mut().rev().nth(parent_offset).unwrap();
         let symbols = &mut last.0;
         let table_type = last.1;
 
@@ -319,7 +464,7 @@ impl<'a> SymbolTableAnalyzer<'a> {
 
         match table_type {
             SymbolTableType::Module => {
-                symbol.scope = SymbolScope::Global;
+                symbol.scope = SymbolScope::GlobalImplicit;
             }
             SymbolTableType::Class => {
                 // named expressions are forbidden in comprehensions on class scope
@@ -327,23 +472,20 @@ impl<'a> SymbolTableAnalyzer<'a> {
                     error: "assignment expression within a comprehension cannot be used in a class body".to_string(),
                     // TODO: accurate location info, somehow
                     location: Location::default(),
-                } );
+                });
             }
             SymbolTableType::Function => {
                 if let Some(parent_symbol) = symbols.get_mut(&symbol.name) {
                     if let SymbolScope::Unknown = parent_symbol.scope {
-                        parent_symbol.is_assigned = true; // this information is new, as the asignment is done in inner scope
-                                                          //self.analyze_unknown_symbol(symbol); // not needed, symbol is analyzed anyhow when its scope is analyzed
+                        // this information is new, as the asignment is done in inner scope
+                        parent_symbol.is_assigned = true;
                     }
 
-                    match symbol.scope {
-                        SymbolScope::Global => {
-                            symbol.scope = SymbolScope::Global;
-                        }
-                        _ => {
-                            symbol.scope = SymbolScope::Nonlocal;
-                        }
-                    }
+                    symbol.scope = if parent_symbol.is_global() {
+                        parent_symbol.scope
+                    } else {
+                        SymbolScope::Free
+                    };
                 } else {
                     let mut cloned_sym = symbol.clone();
                     cloned_sym.scope = SymbolScope::Local;
@@ -372,7 +514,7 @@ impl<'a> SymbolTableAnalyzer<'a> {
                         // ouside, too, and set it therefore to non-local scope. I.e., we expect to
                         // find a definition on a higher level
                         let mut cloned_sym = symbol.clone();
-                        cloned_sym.scope = SymbolScope::Nonlocal;
+                        cloned_sym.scope = SymbolScope::Free;
                         last.0.insert(cloned_sym.name.to_owned(), cloned_sym);
                     }
                 }
@@ -408,7 +550,7 @@ struct SymbolTableBuilder {
 /// was used.
 /// In cpython this is stored in the AST, but I think this
 /// is not logical, since it is not context free.
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq)]
 enum ExpressionContext {
     Load,
     Store,
@@ -529,6 +671,7 @@ impl SymbolTableBuilder {
                 self.register_name("__module__", SymbolUsage::Assigned, location)?;
                 self.register_name("__qualname__", SymbolUsage::Assigned, location)?;
                 self.register_name("__doc__", SymbolUsage::Assigned, location)?;
+                self.register_name("__class__", SymbolUsage::Assigned, location)?;
                 self.scan_statements(body)?;
                 self.leave_scope();
                 self.scan_expressions(bases, ExpressionContext::Load)?;
@@ -813,6 +956,7 @@ impl SymbolTableBuilder {
                 // Determine the contextual usage of this symbol:
                 match context {
                     ExpressionContext::Delete => {
+                        self.register_name(name, SymbolUsage::Assigned, location)?;
                         self.register_name(name, SymbolUsage::Used, location)?;
                     }
                     ExpressionContext::Load | ExpressionContext::IterDefinitionExp => {
@@ -825,6 +969,12 @@ impl SymbolTableBuilder {
                         self.register_name(name, SymbolUsage::Iter, location)?;
                     }
                 }
+                if context == ExpressionContext::Load
+                    && self.tables.last().unwrap().typ == SymbolTableType::Function
+                    && name == "super"
+                {
+                    self.register_name("__class__", SymbolUsage::Used, location)?;
+                }
             }
             Lambda { args, body } => {
                 self.enter_function("lambda", args, expression.location.row())?;
@@ -945,12 +1095,13 @@ impl SymbolTableBuilder {
         let table = self.tables.last_mut().unwrap();
 
         // Some checks for the symbol that present on this scope level:
-        if let Some(symbol) = table.symbols.get(name) {
+        let symbol = if let Some(symbol) = table.symbols.get_mut(name) {
             // Role already set..
             match role {
                 SymbolUsage::Global => {
-                    if let SymbolScope::Global = symbol.scope {
+                    if symbol.is_global() {
                         // Ok
+                        symbol.scope = SymbolScope::GlobalExplicit;
                     } else {
                         return Err(SymbolTableError {
                             error: format!("name '{}' is used prior to global declaration", name),
@@ -991,6 +1142,7 @@ impl SymbolTableBuilder {
                     // Ok?
                 }
             }
+            symbol
         } else {
             // The symbol does not present on this scope level.
             // Some checks to insert new symbol into symbol table:
@@ -1007,14 +1159,14 @@ impl SymbolTableBuilder {
             }
             // Insert symbol when required:
             let symbol = Symbol::new(name);
-            table.symbols.insert(name.to_owned(), symbol);
-        }
+            table.symbols.entry(name.to_owned()).or_insert(symbol)
+        };
 
         // Set proper flags on symbol:
-        let symbol = table.symbols.get_mut(name).unwrap();
         match role {
             SymbolUsage::Nonlocal => {
-                symbol.scope = SymbolScope::Nonlocal;
+                symbol.scope = SymbolScope::Free;
+                symbol.is_nonlocal = true;
             }
             SymbolUsage::Imported => {
                 symbol.is_assigned = true;
@@ -1040,9 +1192,9 @@ impl SymbolTableBuilder {
             }
             SymbolUsage::Global => {
                 if let SymbolScope::Unknown = symbol.scope {
-                    symbol.scope = SymbolScope::Global;
-                } else if let SymbolScope::Global = symbol.scope {
-                    // Global scope can be set to global
+                    symbol.scope = SymbolScope::GlobalExplicit;
+                } else if symbol.is_global() {
+                    symbol.scope = SymbolScope::GlobalExplicit;
                 } else {
                     return Err(SymbolTableError {
                         error: format!("Symbol {} scope cannot be set to global, since its scope was already determined otherwise.", name),
@@ -1055,7 +1207,6 @@ impl SymbolTableBuilder {
             }
             SymbolUsage::Iter => {
                 symbol.is_iter = true;
-                symbol.scope = SymbolScope::Local;
             }
         }
 
diff --git a/derive/src/pyclass.rs b/derive/src/pyclass.rs
index e8aa209bf6..91dafc5c2c 100644
--- a/derive/src/pyclass.rs
+++ b/derive/src/pyclass.rs
@@ -354,11 +354,10 @@ where
         let item_attr = args.attrs.remove(self.index());
         let item_meta = PropertyItemMeta::from_attr(ident.clone(), &item_attr)?;
 
-        let py_name = item_meta.property_name()?;
-        let setter = item_meta.setter()?;
+        let (py_name, kind) = item_meta.property_name()?;
         args.context
             .getset_items
-            .add_item(py_name, args.cfgs.to_vec(), setter, ident.clone())?;
+            .add_item(py_name, args.cfgs.to_vec(), kind, ident.clone())?;
         Ok(())
     }
 }
@@ -478,27 +477,37 @@ where
 #[derive(Default)]
 #[allow(clippy::type_complexity)]
 struct GetSetNursery {
-    map: HashMap<(String, Vec<Attribute>), (Option<Ident>, Option<Ident>)>,
+    map: HashMap<(String, Vec<Attribute>), (Option<Ident>, Option<Ident>, Option<Ident>)>,
     validated: bool,
 }
 
+enum GetSetItemKind {
+    Get,
+    Set,
+    Delete,
+}
+
 impl GetSetNursery {
     fn add_item(
         &mut self,
         name: String,
         cfgs: Vec<Attribute>,
-        setter: bool,
+        kind: GetSetItemKind,
         item_ident: Ident,
     ) -> Result<()> {
         assert!(!self.validated, "new item is not allowed after validation");
-        if setter && !cfgs.is_empty() {
+        if !matches!(kind, GetSetItemKind::Get) && !cfgs.is_empty() {
             return Err(syn::Error::new_spanned(
                 item_ident,
-                "Property setter does not allow #[cfg]",
+                "Only the getter can have #[cfg]",
             ));
         }
         let entry = self.map.entry((name.clone(), cfgs)).or_default();
-        let func = if setter { &mut entry.1 } else { &mut entry.0 };
+        let func = match kind {
+            GetSetItemKind::Get => &mut entry.0,
+            GetSetItemKind::Set => &mut entry.1,
+            GetSetItemKind::Delete => &mut entry.2,
+        };
         if func.is_some() {
             return Err(syn::Error::new_spanned(
                 item_ident,
@@ -511,10 +520,10 @@ impl GetSetNursery {
 
     fn validate(&mut self) -> Result<()> {
         let mut errors = Vec::new();
-        for ((name, _cfgs), (getter, setter)) in self.map.iter() {
+        for ((name, _cfgs), (getter, setter, deleter)) in self.map.iter() {
             if getter.is_none() {
                 errors.push(syn::Error::new_spanned(
-                    setter.as_ref().unwrap(),
+                    setter.as_ref().or_else(|| deleter.as_ref()).unwrap(),
                     format!("Property '{}' is missing a getter", name),
                 ));
             };
@@ -528,21 +537,33 @@ impl GetSetNursery {
 impl ToTokens for GetSetNursery {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         assert!(self.validated, "Call `validate()` before token generation");
-        tokens.extend(self.map.iter().map(|((name, cfgs), (getter, setter))| {
-            let (constructor, setter) = match setter {
-                Some(setter) => (quote! { with_get_set }, quote_spanned! { setter.span() => , &Self::#setter }),
-                None => (quote! { with_get }, quote! { }),
-            };
-            quote! {
-                #( #cfgs )*
-                class.set_str_attr(
-                    #name,
-                    ::rustpython_vm::pyobject::PyObject::new(
-                        ::rustpython_vm::builtins::PyGetSet::#constructor(#name.into(), &Self::#getter #setter),
-                        ctx.types.getset_type.clone(), None)
-                );
-            }
-        }));
+        let properties = self
+            .map
+            .iter()
+            .map(|((name, cfgs), (getter, setter, deleter))| {
+                let setter = match setter {
+                    Some(setter) => quote_spanned! { setter.span()=> .with_set(&Self::#setter)},
+                    None => quote! {},
+                };
+                let deleter = match deleter {
+                    Some(deleter) => {
+                        quote_spanned! { deleter.span()=> .with_delete(&Self::#deleter)}
+                    }
+                    None => quote! {},
+                };
+                quote! {
+                    #( #cfgs )*
+                    class.set_str_attr(
+                        #name,
+                        ::rustpython_vm::pyobject::PyObject::new(
+                            ::rustpython_vm::builtins::PyGetSet::new(#name.into())
+                                .with_get(&Self::#getter)
+                                #setter #deleter,
+                            ctx.types.getset_type.clone(), None)
+                    );
+                }
+            });
+        tokens.extend(properties);
     }
 }
 
@@ -580,7 +601,7 @@ impl MethodItemMeta {
 struct PropertyItemMeta(ItemMetaInner);
 
 impl ItemMeta for PropertyItemMeta {
-    const ALLOWED_NAMES: &'static [&'static str] = &["name", "magic", "setter"];
+    const ALLOWED_NAMES: &'static [&'static str] = &["name", "magic", "setter", "deleter"];
 
     fn from_inner(inner: ItemMetaInner) -> Self {
         Self(inner)
@@ -591,40 +612,59 @@ impl ItemMeta for PropertyItemMeta {
 }
 
 impl PropertyItemMeta {
-    fn property_name(&self) -> Result<String> {
+    fn property_name(&self) -> Result<(String, GetSetItemKind)> {
         let inner = self.inner();
         let magic = inner._bool("magic")?;
-        let setter = inner._bool("setter")?;
+        let kind = match (inner._bool("setter")?, inner._bool("deleter")?) {
+            (false, false) => GetSetItemKind::Get,
+            (true, false) => GetSetItemKind::Set,
+            (false, true) => GetSetItemKind::Delete,
+            (true, true) => {
+                return Err(syn::Error::new_spanned(
+                    &inner.meta_ident,
+                    format!(
+                        "can't have both setter and deleter on a #[{}] fn",
+                        inner.meta_name()
+                    ),
+                ))
+            }
+        };
         let name = inner._optional_str("name")?;
         let py_name = if let Some(name) = name {
             name
         } else {
             let sig_name = inner.item_name();
-            let name = if setter {
-                if let Some(name) = sig_name.strip_prefix("set_") {
+            let extract_prefix_name = |prefix, item_typ| {
+                if let Some(name) = sig_name.strip_prefix(prefix) {
                     if name.is_empty() {
-                        return Err(syn::Error::new_spanned(
+                        Err(syn::Error::new_spanned(
                             &inner.meta_ident,
                             format!(
-                                "A #[{}(setter)] fn with a set_* name must \
-                                 have something after \"set_\"",
-                                inner.meta_name()
+                                "A #[{}({typ})] fn with a {prefix}* name must \
+                                 have something after \"{prefix}\"",
+                                inner.meta_name(),
+                                typ = item_typ,
+                                prefix = prefix
                             ),
-                        ));
+                        ))
+                    } else {
+                        Ok(name.to_owned())
                     }
-                    name.to_string()
                 } else {
-                    return Err(syn::Error::new_spanned(
+                    Err(syn::Error::new_spanned(
                         &inner.meta_ident,
                         format!(
                             "A #[{}(setter)] fn must either have a `name` \
                              parameter or a fn name along the lines of \"set_*\"",
                             inner.meta_name()
                         ),
-                    ));
+                    ))
                 }
-            } else {
-                sig_name
+            };
+            let name = match kind {
+                GetSetItemKind::Get => sig_name,
+                GetSetItemKind::Set => extract_prefix_name("set_", "setter")?,
+                GetSetItemKind::Delete => extract_prefix_name("del_", "deleter")?,
             };
             if magic {
                 format!("__{}__", name)
@@ -632,11 +672,7 @@ impl PropertyItemMeta {
                 name
             }
         };
-        Ok(py_name)
-    }
-
-    fn setter(&self) -> Result<bool> {
-        self.inner()._bool("setter")
+        Ok((py_name, kind))
     }
 }
 
diff --git a/jit/Cargo.toml b/jit/Cargo.toml
index 7b32035bee..16b507d74c 100644
--- a/jit/Cargo.toml
+++ b/jit/Cargo.toml
@@ -10,11 +10,11 @@ edition = "2018"
 autotests = false
 
 [dependencies]
-cranelift = "0.66.0"
-cranelift-module = "0.66.0"
-cranelift-simplejit = "0.66.0"
+cranelift = "0.68.0"
+cranelift-module = "0.68.0"
+cranelift-simplejit = "0.68.0"
 num-traits = "0.2"
-libffi = "0.9.0"
+libffi = "1.0"
 rustpython-bytecode = { path = "../bytecode", version = "0.1.2" }
 thiserror = "1.0"
 
diff --git a/jit/src/instructions.rs b/jit/src/instructions.rs
index 2cb89fb4cc..9ff9228d4e 100644
--- a/jit/src/instructions.rs
+++ b/jit/src/instructions.rs
@@ -2,7 +2,7 @@ use cranelift::prelude::*;
 use num_traits::cast::ToPrimitive;
 use rustpython_bytecode::bytecode::{
     self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, Instruction, Label,
-    NameScope, UnaryOperator,
+    UnaryOperator,
 };
 use std::collections::HashMap;
 
@@ -14,6 +14,7 @@ struct Local {
     ty: JitType,
 }
 
+#[derive(Debug)]
 struct JitValue {
     val: Value,
     ty: JitType,
@@ -28,27 +29,22 @@ impl JitValue {
 pub struct FunctionCompiler<'a, 'b> {
     builder: &'a mut FunctionBuilder<'b>,
     stack: Vec<JitValue>,
-    variables: HashMap<String, Local>,
+    variables: Box<[Option<Local>]>,
     label_to_block: HashMap<Label, Block>,
     pub(crate) sig: JitSig,
 }
 
 impl<'a, 'b> FunctionCompiler<'a, 'b> {
-    pub fn new<I, S>(
+    pub fn new(
         builder: &'a mut FunctionBuilder<'b>,
-        arg_names: I,
+        num_variables: usize,
         arg_types: &[JitType],
         entry_block: Block,
-    ) -> FunctionCompiler<'a, 'b>
-    where
-        I: IntoIterator<Item = S>,
-        I::IntoIter: ExactSizeIterator,
-        S: AsRef<str>,
-    {
+    ) -> FunctionCompiler<'a, 'b> {
         let mut compiler = FunctionCompiler {
             builder,
             stack: Vec::new(),
-            variables: HashMap::new(),
+            variables: vec![None; num_variables].into_boxed_slice(),
             label_to_block: HashMap::new(),
             sig: JitSig {
                 args: arg_types.to_vec(),
@@ -56,22 +52,22 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             },
         };
         let params = compiler.builder.func.dfg.block_params(entry_block).to_vec();
-        let arg_names = arg_names.into_iter();
-        debug_assert_eq!(arg_names.len(), arg_types.len());
-        debug_assert_eq!(arg_names.len(), params.len());
-        for ((name, ty), val) in arg_names.zip(arg_types).zip(params) {
+        for (i, (ty, val)) in arg_types.iter().zip(params).enumerate() {
             compiler
-                .store_variable(name.as_ref().to_owned(), JitValue::new(val, ty.clone()))
+                .store_variable(i, JitValue::new(val, ty.clone()))
                 .unwrap();
         }
         compiler
     }
 
-    fn store_variable(&mut self, name: String, val: JitValue) -> Result<(), JitCompileError> {
-        let len = self.variables.len();
+    fn store_variable(
+        &mut self,
+        idx: bytecode::NameIdx,
+        val: JitValue,
+    ) -> Result<(), JitCompileError> {
         let builder = &mut self.builder;
-        let local = self.variables.entry(name).or_insert_with(|| {
-            let var = Variable::new(len);
+        let local = self.variables[idx].get_or_insert_with(|| {
+            let var = Variable::new(idx);
             let local = Local {
                 var,
                 ty: val.ty.clone(),
@@ -142,7 +138,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 continue;
             }
 
-            self.add_instruction(&instruction, &bytecode.constants, &bytecode.names)?;
+            self.add_instruction(&instruction, &bytecode.constants)?;
         }
 
         Ok(())
@@ -188,7 +184,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         &mut self,
         instruction: &Instruction,
         constants: &[C],
-        names: &[C::Name],
     ) -> Result<(), JitCompileError> {
         match instruction {
             Instruction::JumpIfFalse { target } => {
@@ -223,13 +218,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::LoadName {
-                idx,
-                scope: NameScope::Local,
-            } => {
-                let local = self
-                    .variables
-                    .get(names[*idx].as_ref())
+            Instruction::LoadFast(idx) => {
+                let local = self.variables[*idx]
+                    .as_ref()
                     .ok_or(JitCompileError::BadBytecode)?;
                 self.stack.push(JitValue {
                     val: self.builder.use_var(local.var),
@@ -237,12 +228,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 });
                 Ok(())
             }
-            Instruction::StoreName {
-                idx,
-                scope: NameScope::Local,
-            } => {
+            Instruction::StoreFast(idx) => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.store_variable(names[*idx].as_ref().to_owned(), val)
+                self.store_variable(*idx, val)
             }
             Instruction::LoadConst { idx } => self.load_const(constants[*idx].borrow_constant()),
             Instruction::ReturnValue => {
diff --git a/jit/src/lib.rs b/jit/src/lib.rs
index 31803223e2..dbb93936d7 100644
--- a/jit/src/lib.rs
+++ b/jit/src/lib.rs
@@ -1,8 +1,8 @@
 use std::fmt;
 
 use cranelift::prelude::*;
-use cranelift_module::{Backend, FuncId, Linkage, Module, ModuleError};
-use cranelift_simplejit::{SimpleJITBackend, SimpleJITBuilder};
+use cranelift_module::{FuncId, Linkage, Module, ModuleError};
+use cranelift_simplejit::{SimpleJITBuilder, SimpleJITModule, SimpleJITProduct};
 
 use rustpython_bytecode::bytecode;
 
@@ -32,13 +32,13 @@ pub enum JitArgumentError {
 struct Jit {
     builder_context: FunctionBuilderContext,
     ctx: codegen::Context,
-    module: Module<SimpleJITBackend>,
+    module: SimpleJITModule,
 }
 
 impl Jit {
     fn new() -> Self {
         let builder = SimpleJITBuilder::new(cranelift_module::default_libcall_names());
-        let module = Module::new(builder);
+        let module = SimpleJITModule::new(builder);
         Self {
             builder_context: FunctionBuilderContext::new(),
             ctx: module.make_context(),
@@ -65,8 +65,8 @@ impl Jit {
         builder.switch_to_block(entry_block);
 
         let sig = {
-            let arg_names = &bytecode.names[..bytecode.arg_count + bytecode.kwonlyarg_count];
-            let mut compiler = FunctionCompiler::new(&mut builder, arg_names, args, entry_block);
+            let mut compiler =
+                FunctionCompiler::new(&mut builder, bytecode.varnames.len(), args, entry_block);
 
             compiler.compile(bytecode)?;
 
@@ -112,7 +112,7 @@ pub fn compile<C: bytecode::Constant>(
 pub struct CompiledCode {
     sig: JitSig,
     code: *const u8,
-    memory: <SimpleJITBackend as Backend>::Product,
+    memory: SimpleJITProduct,
 }
 
 impl CompiledCode {
@@ -161,7 +161,7 @@ impl JitSig {
     }
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum JitType {
     Int,
     Float,
diff --git a/jit/tests/common.rs b/jit/tests/common.rs
index 13483c2622..7b5a434682 100644
--- a/jit/tests/common.rs
+++ b/jit/tests/common.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use rustpython_bytecode::bytecode::{CodeObject, ConstantData, Instruction, NameScope};
+use rustpython_bytecode::bytecode::{CodeObject, ConstantData, Instruction};
 use rustpython_jit::{CompiledCode, JitType};
 
 #[derive(Debug, Clone)]
@@ -64,7 +64,7 @@ impl StackMachine {
     }
 
     pub fn run(&mut self, code: CodeObject) {
-        for instruction in code.instructions {
+        for instruction in code.instructions.into_vec() {
             if self.process_instruction(instruction, &code.constants, &code.names) {
                 break;
             }
@@ -79,11 +79,10 @@ impl StackMachine {
     ) -> bool {
         match instruction {
             Instruction::LoadConst { idx } => self.stack.push(constants[idx].clone().into()),
-            Instruction::LoadName {
-                idx,
-                scope: NameScope::Free,
-            } => self.stack.push(StackValue::String(names[idx].clone())),
-            Instruction::StoreName { idx, .. } => {
+            Instruction::LoadNameAny(idx) => {
+                self.stack.push(StackValue::String(names[idx].clone()))
+            }
+            Instruction::StoreLocal(idx) => {
                 self.locals
                     .insert(names[idx].clone(), self.stack.pop().unwrap());
             }
diff --git a/src/lib.rs b/src/lib.rs
index 2ef1def6ba..dbfad98b37 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -260,6 +260,7 @@ fn parse_arguments<'a>(app: App<'a, '_>) -> ArgMatches<'a> {
                 .short("X")
                 .takes_value(true)
                 .multiple(true)
+                .number_of_values(1)
                 .help("set implementation-specific option"),
         )
         .arg(
@@ -267,6 +268,7 @@ fn parse_arguments<'a>(app: App<'a, '_>) -> ArgMatches<'a> {
                 .short("W")
                 .takes_value(true)
                 .multiple(true)
+                .number_of_values(1)
                 .help("warning control; arg is action:message:category:module:lineno"),
         )
         .arg(
diff --git a/src/shell.rs b/src/shell.rs
index e42fd39d94..1987e08344 100644
--- a/src/shell.rs
+++ b/src/shell.rs
@@ -35,7 +35,7 @@ fn shell_exec(vm: &VirtualMachine, source: &str, scope: Scope) -> ShellExecResul
 }
 
 pub fn run_shell(vm: &VirtualMachine, scope: Scope) -> PyResult<()> {
-    let mut repl = Readline::new(helper::ShellHelper::new(vm, scope.clone()));
+    let mut repl = Readline::new(helper::ShellHelper::new(vm, scope.globals.clone()));
     let mut full_input = String::new();
 
     // Retrieve a `history_path_str` dependent on the OS
diff --git a/src/shell/helper.rs b/src/shell/helper.rs
index c639a004de..e8d07967d1 100644
--- a/src/shell/helper.rs
+++ b/src/shell/helper.rs
@@ -1,11 +1,10 @@
-use rustpython_vm::builtins::PyStrRef;
+use rustpython_vm::builtins::{PyDictRef, PyStrRef};
 use rustpython_vm::pyobject::{BorrowValue, PyIterable, PyResult, TryFromObject};
-use rustpython_vm::scope::Scope;
 use rustpython_vm::VirtualMachine;
 
 pub struct ShellHelper<'vm> {
     vm: &'vm VirtualMachine,
-    scope: Scope,
+    globals: PyDictRef,
 }
 
 fn reverse_string(s: &mut String) {
@@ -51,8 +50,8 @@ fn split_idents_on_dot(line: &str) -> Option<(usize, Vec<String>)> {
 }
 
 impl<'vm> ShellHelper<'vm> {
-    pub fn new(vm: &'vm VirtualMachine, scope: Scope) -> Self {
-        ShellHelper { vm, scope }
+    pub fn new(vm: &'vm VirtualMachine, globals: PyDictRef) -> Self {
+        ShellHelper { vm, globals }
     }
 
     #[allow(clippy::type_complexity)]
@@ -74,7 +73,10 @@ impl<'vm> ShellHelper<'vm> {
             // last: the last word, could be empty if it ends with a dot
             // parents: the words before the dot
 
-            let mut current = self.scope.load_global(self.vm, first.as_str())?;
+            let mut current = self
+                .globals
+                .get_item_option(first.as_str(), self.vm)
+                .ok()??;
 
             for attr in parents {
                 current = self.vm.get_attribute(current.clone(), attr.as_str()).ok()?;
@@ -86,7 +88,7 @@ impl<'vm> ShellHelper<'vm> {
         } else {
             // we need to get a variable based off of globals/builtins
 
-            let globals = str_iter_method(self.scope.globals.as_object(), "keys").ok()?;
+            let globals = str_iter_method(self.globals.as_object(), "keys").ok()?;
             let builtins = str_iter_method(&self.vm.builtins, "__dir__").ok()?;
             Some((&first, Box::new(Iterator::chain(globals, builtins)) as _))
         }
diff --git a/vm/src/builtins/code.rs b/vm/src/builtins/code.rs
index c8af7f3892..7d4d10e48a 100644
--- a/vm/src/builtins/code.rs
+++ b/vm/src/builtins/code.rs
@@ -259,7 +259,7 @@ impl PyCodeRef {
     fn co_varnames(self, vm: &VirtualMachine) -> PyObjectRef {
         let varnames = self
             .code
-            .names
+            .varnames
             .iter()
             .map(|s| s.clone().into_object())
             .collect();
diff --git a/vm/src/builtins/dict.rs b/vm/src/builtins/dict.rs
index 04b6241ff7..7586c83c51 100644
--- a/vm/src/builtins/dict.rs
+++ b/vm/src/builtins/dict.rs
@@ -268,7 +268,7 @@ impl PyDict {
     #[pymethod(magic)]
     #[cfg_attr(feature = "flame-it", flame("PyDictRef"))]
     fn getitem(zelf: PyRef<Self>, key: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        if let Some(value) = zelf.inner_getitem_option(key.clone(), vm)? {
+        if let Some(value) = zelf.inner_getitem_option(key.clone(), zelf.exact_dict(vm), vm)? {
             Ok(value)
         } else {
             Err(vm.new_key_error(key))
@@ -422,23 +422,30 @@ impl Iterable for PyDict {
 }
 
 impl PyDictRef {
+    #[inline]
+    fn exact_dict(&self, vm: &VirtualMachine) -> bool {
+        self.class().is(&vm.ctx.types.dict_type)
+    }
+
     /// Return an optional inner item, or an error (can be key error as well)
     #[inline]
     fn inner_getitem_option<K: DictKey>(
         &self,
         key: K,
+        exact: bool,
         vm: &VirtualMachine,
     ) -> PyResult<Option<PyObjectRef>> {
         if let Some(value) = self.entries.get(vm, &key)? {
             return Ok(Some(value));
         }
 
-        if let Some(method_or_err) = vm.get_method(self.clone().into_object(), "__missing__") {
-            let method = method_or_err?;
-            Ok(Some(vm.invoke(&method, (key,))?))
-        } else {
-            Ok(None)
+        if !exact {
+            if let Some(method_or_err) = vm.get_method(self.clone().into_object(), "__missing__") {
+                let method = method_or_err?;
+                return vm.invoke(&method, (key,)).map(Some);
+            }
         }
+        Ok(None)
     }
 
     /// Take a python dictionary and convert it to attributes.
@@ -466,28 +473,52 @@ impl PyDictRef {
         // and prevent the creation of the KeyError exception.
         // Also note, that we prevent the creation of a full PyStr object
         // if we lookup local names (which happens all of the time).
-        if self.class().is(&vm.ctx.types.dict_type) {
+        self._get_item_option_inner(key, self.exact_dict(vm), vm)
+    }
+
+    #[inline]
+    fn _get_item_option_inner<K: IntoPyObject + DictKey>(
+        &self,
+        key: K,
+        exact: bool,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<PyObjectRef>> {
+        if exact {
             // We can take the short path here!
-            self.inner_getitem_option(key, vm).or_else(|exc| {
-                if exc.isinstance(&vm.ctx.exceptions.key_error) {
-                    Ok(None)
-                } else {
-                    Err(exc)
-                }
-            })
+            self.entries.get(vm, &key)
         } else {
             // Fall back to full get_item with KeyError checking
+            self._subcls_getitem_option(key.into_pyobject(vm), vm)
+        }
+    }
 
-            match self.get_item(key, vm) {
-                Ok(value) => Ok(Some(value)),
-                Err(exc) => {
-                    if exc.isinstance(&vm.ctx.exceptions.key_error) {
-                        Ok(None)
-                    } else {
-                        Err(exc)
-                    }
-                }
-            }
+    #[cold]
+    fn _subcls_getitem_option(
+        &self,
+        key: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<PyObjectRef>> {
+        match self.get_item(key, vm) {
+            Ok(value) => Ok(Some(value)),
+            Err(exc) if exc.isinstance(&vm.ctx.exceptions.key_error) => Ok(None),
+            Err(exc) => Err(exc),
+        }
+    }
+
+    pub fn get_chain<K: IntoPyObject + DictKey + Clone>(
+        &self,
+        other: &Self,
+        key: K,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<PyObjectRef>> {
+        let self_exact = self.class().is(&vm.ctx.types.dict_type);
+        let other_exact = self.class().is(&vm.ctx.types.dict_type);
+        if self_exact && other_exact {
+            self.entries.get_chain(&other.entries, vm, &key)
+        } else if let Some(value) = self._get_item_option_inner(key.clone(), self_exact, vm)? {
+            Ok(Some(value))
+        } else {
+            other._get_item_option_inner(key, other_exact, vm)
         }
     }
 }
@@ -500,19 +531,18 @@ where
         self.as_object().get_item(key, vm)
     }
 
-    fn set_item(&self, key: K, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    fn set_item(&self, key: K, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         if self.class().is(&vm.ctx.types.dict_type) {
             self.inner_setitem_fast(key, value, vm)
-                .map(|_| vm.ctx.none())
         } else {
             // Fall back to slow path if we are in a dict subclass:
             self.as_object().set_item(key, value, vm)
         }
     }
 
-    fn del_item(&self, key: K, vm: &VirtualMachine) -> PyResult {
+    fn del_item(&self, key: K, vm: &VirtualMachine) -> PyResult<()> {
         if self.class().is(&vm.ctx.types.dict_type) {
-            self.entries.delete(vm, key).map(|_| vm.ctx.none())
+            self.entries.delete(vm, key)
         } else {
             // Fall back to slow path if we are in a dict subclass:
             self.as_object().del_item(key, vm)
diff --git a/vm/src/builtins/frame.rs b/vm/src/builtins/frame.rs
index 947dd673a6..5248dac61d 100644
--- a/vm/src/builtins/frame.rs
+++ b/vm/src/builtins/frame.rs
@@ -44,12 +44,12 @@ impl FrameRef {
 
     #[pyproperty]
     fn f_globals(self) -> PyDictRef {
-        self.scope.globals.clone()
+        self.globals.clone()
     }
 
     #[pyproperty]
-    fn f_locals(self) -> PyDictRef {
-        self.scope.get_locals().clone()
+    fn f_locals(self, vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        self.locals(vm)
     }
 
     #[pyproperty]
diff --git a/vm/src/builtins/function.rs b/vm/src/builtins/function.rs
index 3c699ea1be..8aa8cdcdcb 100644
--- a/vm/src/builtins/function.rs
+++ b/vm/src/builtins/function.rs
@@ -5,13 +5,14 @@ use super::code::PyCodeRef;
 use super::dict::PyDictRef;
 use super::pystr::PyStrRef;
 use super::pytype::PyTypeRef;
-use super::tuple::PyTupleRef;
+use super::tuple::{PyTupleRef, PyTupleTyped};
 use crate::builtins::asyncgenerator::PyAsyncGen;
 use crate::builtins::coroutine::PyCoroutine;
 use crate::builtins::generator::PyGenerator;
 use crate::bytecode;
+use crate::common::lock::PyMutex;
 use crate::frame::Frame;
-use crate::function::FuncArgs;
+use crate::function::{FuncArgs, OptionalArg};
 #[cfg(feature = "jit")]
 use crate::pyobject::IntoPyObject;
 use crate::pyobject::{
@@ -35,15 +36,17 @@ pub struct PyFunction {
     code: PyCodeRef,
     #[cfg(feature = "jit")]
     jitted_code: OnceCell<CompiledCode>,
-    scope: Scope,
+    globals: PyDictRef,
+    closure: Option<PyTupleTyped<PyCellRef>>,
     defaults: Option<PyTupleRef>,
     kw_only_defaults: Option<PyDictRef>,
 }
 
 impl PyFunction {
-    pub fn new(
+    pub(crate) fn new(
         code: PyCodeRef,
-        scope: Scope,
+        globals: PyDictRef,
+        closure: Option<PyTupleTyped<PyCellRef>>,
         defaults: Option<PyTupleRef>,
         kw_only_defaults: Option<PyDictRef>,
     ) -> Self {
@@ -51,25 +54,24 @@ impl PyFunction {
             code,
             #[cfg(feature = "jit")]
             jitted_code: OnceCell::new(),
-            scope,
+            globals,
+            closure,
             defaults,
             kw_only_defaults,
         }
     }
 
-    pub fn scope(&self) -> &Scope {
-        &self.scope
-    }
-
     fn fill_locals_from_args(
         &self,
-        locals: &PyDictRef,
+        frame: &Frame,
         func_args: FuncArgs,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
+        let code = &*self.code;
         let nargs = func_args.args.len();
-        let nexpected_args = self.code.arg_count;
-        let arg_names = self.code.arg_names();
+        let nexpected_args = code.arg_count;
+        let total_args = code.arg_count + code.kwonlyarg_count;
+        // let arg_names = self.code.arg_names();
 
         // This parses the arguments from args and kwargs into
         // the proper variables keeping into account default values
@@ -77,23 +79,26 @@ impl PyFunction {
         // See also: PyEval_EvalCodeWithName in cpython:
         // https://github.com/python/cpython/blob/master/Python/ceval.c#L3681
 
-        let n = if nargs > nexpected_args {
-            nexpected_args
-        } else {
-            nargs
-        };
+        let mut fastlocals = frame.fastlocals.lock();
 
         let mut args_iter = func_args.args.into_iter();
 
         // Copy positional arguments into local variables
-        for (arg, arg_name) in args_iter.by_ref().take(n).zip(arg_names.args) {
-            locals.set_item(arg_name.clone(), arg, vm)?;
+        // zip short-circuits if either iterator returns None, which is the behavior we want --
+        // only fill as much as there is to fill with as much as we have
+        for (local, arg) in Iterator::zip(
+            fastlocals.iter_mut().take(nexpected_args),
+            args_iter.by_ref().take(nargs),
+        ) {
+            *local = Some(arg);
         }
 
+        let mut vararg_offset = total_args;
         // Pack other positional arguments in to *args:
-        if let Some(vararg_name) = arg_names.vararg {
+        if code.flags.contains(bytecode::CodeFlags::HAS_VARARGS) {
             let vararg_value = vm.ctx.new_tuple(args_iter.collect());
-            locals.set_item(vararg_name.clone(), vararg_value, vm)?;
+            fastlocals[vararg_offset] = Some(vararg_value);
+            vararg_offset += 1;
         } else {
             // Check the number of positional arguments
             if nargs > nexpected_args {
@@ -105,39 +110,45 @@ impl PyFunction {
         }
 
         // Do we support `**kwargs` ?
-        let kwargs = if let Some(varkwarg) = arg_names.varkwarg {
+        let kwargs = if code.flags.contains(bytecode::CodeFlags::HAS_VARKEYWORDS) {
             let d = vm.ctx.new_dict();
-            locals.set_item(varkwarg.clone(), d.as_object().clone(), vm)?;
+            fastlocals[vararg_offset] = Some(d.clone().into_object());
             Some(d)
         } else {
             None
         };
 
-        let contains_arg =
-            |names: &[PyStrRef], name: &str| names.iter().any(|s| s.borrow_value() == name);
+        let argpos = |range: std::ops::Range<_>, name: &str| {
+            code.varnames
+                .iter()
+                .enumerate()
+                .skip(range.start)
+                .take(range.end - range.start)
+                .find(|(_, s)| s.borrow_value() == name)
+                .map(|(p, _)| p)
+        };
 
         let mut posonly_passed_as_kwarg = Vec::new();
         // Handle keyword arguments
         for (name, value) in func_args.kwargs {
             // Check if we have a parameter with this name:
-            let dict = if contains_arg(arg_names.args, &name)
-                || contains_arg(arg_names.kwonlyargs, &name)
-            {
-                if contains_arg(arg_names.posonlyargs, &name) {
-                    posonly_passed_as_kwarg.push(name);
-                    continue;
-                } else if locals.contains_key(&name, vm) {
+            if let Some(pos) = argpos(code.posonlyarg_count..total_args, &name) {
+                let slot = &mut fastlocals[pos];
+                if slot.is_some() {
                     return Err(
                         vm.new_type_error(format!("Got multiple values for argument '{}'", name))
                     );
                 }
-                locals
+                *slot = Some(value);
+            } else if argpos(0..code.posonlyarg_count, &name).is_some() {
+                posonly_passed_as_kwarg.push(name);
+            } else if let Some(kwargs) = kwargs.as_ref() {
+                kwargs.set_item(name, value, vm)?;
             } else {
-                kwargs.as_ref().ok_or_else(|| {
+                return Err(
                     vm.new_type_error(format!("Got an unexpected keyword argument '{}'", name))
-                })?
-            };
-            dict.set_item(vm.intern_string(name).into_object(), value, vm)?;
+                );
+            }
         }
         if !posonly_passed_as_kwarg.is_empty() {
             return Err(vm.new_type_error(format!(
@@ -150,63 +161,86 @@ impl PyFunction {
         // Add missing positional arguments, if we have fewer positional arguments than the
         // function definition calls for
         if nargs < nexpected_args {
-            let num_defaults_available =
-                self.defaults.as_ref().map_or(0, |d| d.borrow_value().len());
+            let ndefs = self.defaults.as_ref().map_or(0, |d| d.borrow_value().len());
+
+            let nrequired = code.arg_count - ndefs;
 
             // Given the number of defaults available, check all the arguments for which we
             // _don't_ have defaults; if any are missing, raise an exception
-            let required_args = nexpected_args - num_defaults_available;
             let mut missing = vec![];
-            for i in 0..required_args {
-                let variable_name = &arg_names.args[i];
-                if !locals.contains_key(variable_name.clone(), vm) {
-                    missing.push(variable_name)
+            for i in nargs..nrequired {
+                if fastlocals[i].is_none() {
+                    missing.push(&code.varnames[i]);
                 }
             }
             if !missing.is_empty() {
                 return Err(vm.new_type_error(format!(
-                    "Missing {} required positional arguments: {:?}",
+                    "Missing {} required positional arguments: {}",
                     missing.len(),
-                    missing
+                    missing.iter().format(", ")
                 )));
             }
+
             if let Some(defaults) = &self.defaults {
                 let defaults = defaults.borrow_value();
+
+                let n = std::cmp::min(nargs, nexpected_args);
+                let i = n.saturating_sub(nrequired);
+
                 // We have sufficient defaults, so iterate over the corresponding names and use
                 // the default if we don't already have a value
-                for (default_index, i) in (required_args..nexpected_args).enumerate() {
-                    let arg_name = &arg_names.args[i];
-                    if !locals.contains_key(arg_name.clone(), vm) {
-                        locals.set_item(arg_name.clone(), defaults[default_index].clone(), vm)?;
+                for i in i..defaults.len() {
+                    let slot = &mut fastlocals[nrequired + i];
+                    if slot.is_none() {
+                        *slot = Some(defaults[i].clone());
                     }
                 }
             }
         };
 
-        // Check if kw only arguments are all present:
-        for arg_name in arg_names.kwonlyargs {
-            if !locals.contains_key(arg_name.clone(), vm) {
-                if let Some(kw_only_defaults) = &self.kw_only_defaults {
-                    if let Some(default) = kw_only_defaults.get_item_option(arg_name.clone(), vm)? {
-                        locals.set_item(arg_name.clone(), default, vm)?;
-                        continue;
+        if code.kwonlyarg_count > 0 {
+            // TODO: compile a list of missing arguments
+            // let mut missing = vec![];
+            // Check if kw only arguments are all present:
+            for (slot, kwarg) in fastlocals
+                .iter_mut()
+                .zip(&*code.varnames)
+                .skip(code.arg_count)
+                .take(code.kwonlyarg_count)
+            {
+                if slot.is_none() {
+                    if let Some(kw_only_defaults) = &self.kw_only_defaults {
+                        if let Some(default) =
+                            kw_only_defaults.get_item_option(kwarg.clone(), vm)?
+                        {
+                            *slot = Some(default);
+                            continue;
+                        }
                     }
+
+                    // No default value and not specified.
+                    return Err(vm.new_type_error(format!(
+                        "Missing required kw only argument: '{}'",
+                        kwarg
+                    )));
                 }
+            }
+        }
 
-                // No default value and not specified.
-                return Err(
-                    vm.new_type_error(format!("Missing required kw only argument: '{}'", arg_name))
-                );
+        if let Some(cell2arg) = code.cell2arg.as_deref() {
+            for (cell_idx, arg_idx) in cell2arg.iter().enumerate().filter(|(_, i)| **i != -1) {
+                let x = fastlocals[*arg_idx as usize].take();
+                frame.cells_frees[cell_idx].set(x);
             }
         }
 
         Ok(())
     }
 
-    pub fn invoke_with_scope(
+    pub fn invoke_with_locals(
         &self,
         func_args: FuncArgs,
-        scope: &Scope,
+        locals: Option<PyDictRef>,
         vm: &VirtualMachine,
     ) -> PyResult {
         #[cfg(feature = "jit")]
@@ -225,16 +259,23 @@ impl PyFunction {
 
         let code = &self.code;
 
-        let scope = if self.code.flags.contains(bytecode::CodeFlags::NEW_LOCALS) {
-            scope.new_child_scope(&vm.ctx)
+        let locals = if self.code.flags.contains(bytecode::CodeFlags::NEW_LOCALS) {
+            vm.ctx.new_dict()
         } else {
-            scope.clone()
+            locals.unwrap_or_else(|| self.globals.clone())
         };
 
-        self.fill_locals_from_args(&scope.get_locals(), func_args, vm)?;
-
         // Construct frame:
-        let frame = Frame::new(code.clone(), scope, vm).into_ref(vm);
+        let frame = Frame::new(
+            code.clone(),
+            Scope::new(Some(locals), self.globals.clone()),
+            vm.builtins.dict().unwrap(),
+            self.closure.as_ref().map_or(&[], |c| c.borrow_value()),
+            vm,
+        )
+        .into_ref(vm);
+
+        self.fill_locals_from_args(&frame, func_args, vm)?;
 
         // If we have a generator, create a new generator
         let is_gen = code.flags.contains(bytecode::CodeFlags::IS_GENERATOR);
@@ -248,7 +289,7 @@ impl PyFunction {
     }
 
     pub fn invoke(&self, func_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        self.invoke_with_scope(func_args, &self.scope, vm)
+        self.invoke_with_locals(func_args, None, vm)
     }
 }
 
@@ -277,7 +318,7 @@ impl PyFunction {
 
     #[pyproperty(magic)]
     fn globals(&self) -> PyDictRef {
-        self.scope.globals.clone()
+        self.globals.clone()
     }
 
     #[cfg(feature = "jit")]
@@ -391,10 +432,56 @@ impl PyValue for PyBoundMethod {
     }
 }
 
-pub fn init(context: &PyContext) {
-    let function_type = &context.types.function_type;
-    PyFunction::extend_class(context, function_type);
+#[pyclass(module = false, name = "cell")]
+#[derive(Debug, Default)]
+pub(crate) struct PyCell {
+    contents: PyMutex<Option<PyObjectRef>>,
+}
+pub(crate) type PyCellRef = PyRef<PyCell>;
+
+impl PyValue for PyCell {
+    fn class(vm: &VirtualMachine) -> &PyTypeRef {
+        &vm.ctx.types.cell_type
+    }
+}
+
+#[pyimpl]
+impl PyCell {
+    #[pyslot]
+    fn tp_new(cls: PyTypeRef, value: OptionalArg, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+        Self::new(value.into_option()).into_ref_with_type(vm, cls)
+    }
+
+    pub fn new(contents: Option<PyObjectRef>) -> Self {
+        Self {
+            contents: PyMutex::new(contents),
+        }
+    }
+
+    pub fn get(&self) -> Option<PyObjectRef> {
+        self.contents.lock().clone()
+    }
+    pub fn set(&self, x: Option<PyObjectRef>) {
+        *self.contents.lock() = x;
+    }
+
+    #[pyproperty]
+    fn cell_contents(&self, vm: &VirtualMachine) -> PyResult {
+        self.get()
+            .ok_or_else(|| vm.new_value_error("Cell is empty".to_owned()))
+    }
+    #[pyproperty(setter)]
+    fn set_cell_contents(&self, x: PyObjectRef) {
+        self.set(Some(x))
+    }
+    #[pyproperty(deleter)]
+    fn del_cell_contents(&self) {
+        self.set(None)
+    }
+}
 
-    let method_type = &context.types.bound_method_type;
-    PyBoundMethod::extend_class(context, method_type);
+pub fn init(context: &PyContext) {
+    PyFunction::extend_class(context, &context.types.function_type);
+    PyBoundMethod::extend_class(context, &context.types.bound_method_type);
+    PyCell::extend_class(context, &context.types.cell_type);
 }
diff --git a/vm/src/builtins/getset.rs b/vm/src/builtins/getset.rs
index 48204f613b..5a84c5724e 100644
--- a/vm/src/builtins/getset.rs
+++ b/vm/src/builtins/getset.rs
@@ -4,8 +4,8 @@
 use super::pytype::PyTypeRef;
 use crate::function::{OwnedParam, RefParam};
 use crate::pyobject::{
-    IntoPyResult, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
-    TypeProtocol,
+    IntoPyResult, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyThreadingConstraint,
+    PyValue, TryFromObject, TypeProtocol,
 };
 use crate::slots::SlotDescriptor;
 use crate::vm::VirtualMachine;
@@ -13,9 +13,13 @@ use crate::vm::VirtualMachine;
 pub type PyGetterFunc = Box<py_dyn_fn!(dyn Fn(&VirtualMachine, PyObjectRef) -> PyResult)>;
 pub type PySetterFunc =
     Box<py_dyn_fn!(dyn Fn(&VirtualMachine, PyObjectRef, PyObjectRef) -> PyResult<()>)>;
+pub type PyDeleterFunc = Box<py_dyn_fn!(dyn Fn(&VirtualMachine, PyObjectRef) -> PyResult<()>)>;
 
-pub trait IntoPyGetterFunc<T> {
-    fn into_getter(self) -> PyGetterFunc;
+pub trait IntoPyGetterFunc<T>: PyThreadingConstraint + Sized + 'static {
+    fn get(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult;
+    fn into_getter(self) -> PyGetterFunc {
+        Box::new(move |vm, obj| self.get(obj, vm))
+    }
 }
 
 impl<F, T, R> IntoPyGetterFunc<(OwnedParam<T>, R, VirtualMachine)> for F
@@ -24,11 +28,9 @@ where
     T: TryFromObject,
     R: IntoPyResult,
 {
-    fn into_getter(self) -> PyGetterFunc {
-        Box::new(move |vm: &VirtualMachine, obj| {
-            let obj = T::try_from_object(vm, obj)?;
-            (self)(obj, vm).into_pyresult(vm)
-        })
+    fn get(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let obj = T::try_from_object(vm, obj)?;
+        (self)(obj, vm).into_pyresult(vm)
     }
 }
 
@@ -38,11 +40,9 @@ where
     S: PyValue,
     R: IntoPyResult,
 {
-    fn into_getter(self) -> PyGetterFunc {
-        Box::new(move |vm: &VirtualMachine, obj| {
-            let zelf = PyRef::<S>::try_from_object(vm, obj)?;
-            (self)(&zelf, vm).into_pyresult(vm)
-        })
+    fn get(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let zelf = PyRef::<S>::try_from_object(vm, obj)?;
+        (self)(&zelf, vm).into_pyresult(vm)
     }
 }
 
@@ -52,8 +52,9 @@ where
     T: TryFromObject,
     R: IntoPyResult,
 {
-    fn into_getter(self) -> PyGetterFunc {
-        IntoPyGetterFunc::into_getter(move |obj, _vm: &VirtualMachine| (self)(obj))
+    fn get(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let obj = T::try_from_object(vm, obj)?;
+        (self)(obj).into_pyresult(vm)
     }
 }
 
@@ -63,8 +64,9 @@ where
     S: PyValue,
     R: IntoPyResult,
 {
-    fn into_getter(self) -> PyGetterFunc {
-        IntoPyGetterFunc::into_getter(move |zelf: &S, _vm: &VirtualMachine| (self)(zelf))
+    fn get(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let zelf = PyRef::<S>::try_from_object(vm, obj)?;
+        (self)(&zelf).into_pyresult(vm)
     }
 }
 
@@ -73,19 +75,24 @@ pub trait IntoPyNoResult {
 }
 
 impl IntoPyNoResult for () {
+    #[inline]
     fn into_noresult(self) -> PyResult<()> {
         Ok(())
     }
 }
 
 impl IntoPyNoResult for PyResult<()> {
+    #[inline]
     fn into_noresult(self) -> PyResult<()> {
         self
     }
 }
 
-pub trait IntoPySetterFunc<T> {
-    fn into_setter(self) -> PySetterFunc;
+pub trait IntoPySetterFunc<T>: PyThreadingConstraint + Sized + 'static {
+    fn set(&self, obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()>;
+    fn into_setter(self) -> PySetterFunc {
+        Box::new(move |vm, obj, value| self.set(obj, value, vm))
+    }
 }
 
 impl<F, T, V, R> IntoPySetterFunc<(OwnedParam<T>, V, R, VirtualMachine)> for F
@@ -95,12 +102,10 @@ where
     V: TryFromObject,
     R: IntoPyNoResult,
 {
-    fn into_setter(self) -> PySetterFunc {
-        Box::new(move |vm: &VirtualMachine, obj, value| {
-            let obj = T::try_from_object(vm, obj)?;
-            let value = V::try_from_object(vm, value)?;
-            (self)(obj, value, vm).into_noresult()
-        })
+    fn set(&self, obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let obj = T::try_from_object(vm, obj)?;
+        let value = V::try_from_object(vm, value)?;
+        (self)(obj, value, vm).into_noresult()
     }
 }
 
@@ -111,12 +116,10 @@ where
     V: TryFromObject,
     R: IntoPyNoResult,
 {
-    fn into_setter(self) -> PySetterFunc {
-        Box::new(move |vm: &VirtualMachine, obj, value| {
-            let zelf = PyRef::<S>::try_from_object(vm, obj)?;
-            let value = V::try_from_object(vm, value)?;
-            (self)(&zelf, value, vm).into_noresult()
-        })
+    fn set(&self, obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let zelf = PyRef::<S>::try_from_object(vm, obj)?;
+        let value = V::try_from_object(vm, value)?;
+        (self)(&zelf, value, vm).into_noresult()
     }
 }
 
@@ -127,8 +130,10 @@ where
     V: TryFromObject,
     R: IntoPyNoResult,
 {
-    fn into_setter(self) -> PySetterFunc {
-        IntoPySetterFunc::into_setter(move |obj, v, _vm: &VirtualMachine| (self)(obj, v))
+    fn set(&self, obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let obj = T::try_from_object(vm, obj)?;
+        let value = V::try_from_object(vm, value)?;
+        (self)(obj, value).into_noresult()
     }
 }
 
@@ -139,8 +144,65 @@ where
     V: TryFromObject,
     R: IntoPyNoResult,
 {
-    fn into_setter(self) -> PySetterFunc {
-        IntoPySetterFunc::into_setter(move |zelf: &S, v, _vm: &VirtualMachine| (self)(zelf, v))
+    fn set(&self, obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let zelf = PyRef::<S>::try_from_object(vm, obj)?;
+        let value = V::try_from_object(vm, value)?;
+        (self)(&zelf, value).into_noresult()
+    }
+}
+
+pub trait IntoPyDeleterFunc<T>: PyThreadingConstraint + Sized + 'static {
+    fn delete(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()>;
+    fn into_deleter(self) -> PyDeleterFunc {
+        Box::new(move |vm, obj| self.delete(obj, vm))
+    }
+}
+
+impl<F, T, R> IntoPyDeleterFunc<(OwnedParam<T>, R, VirtualMachine)> for F
+where
+    F: Fn(T, &VirtualMachine) -> R + 'static + Send + Sync,
+    T: TryFromObject,
+    R: IntoPyNoResult,
+{
+    fn delete(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let obj = T::try_from_object(vm, obj)?;
+        (self)(obj, vm).into_noresult()
+    }
+}
+
+impl<F, S, R> IntoPyDeleterFunc<(RefParam<S>, R, VirtualMachine)> for F
+where
+    F: Fn(&S, &VirtualMachine) -> R + 'static + Send + Sync,
+    S: PyValue,
+    R: IntoPyNoResult,
+{
+    fn delete(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let zelf = PyRef::<S>::try_from_object(vm, obj)?;
+        (self)(&zelf, vm).into_noresult()
+    }
+}
+
+impl<F, T, R> IntoPyDeleterFunc<(OwnedParam<T>, R)> for F
+where
+    F: Fn(T) -> R + 'static + Send + Sync,
+    T: TryFromObject,
+    R: IntoPyNoResult,
+{
+    fn delete(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let obj = T::try_from_object(vm, obj)?;
+        (self)(obj).into_noresult()
+    }
+}
+
+impl<F, S, R> IntoPyDeleterFunc<(RefParam<S>, R)> for F
+where
+    F: Fn(&S) -> R + 'static + Send + Sync,
+    S: PyValue,
+    R: IntoPyNoResult,
+{
+    fn delete(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let zelf = PyRef::<S>::try_from_object(vm, obj)?;
+        (self)(&zelf).into_noresult()
     }
 }
 
@@ -149,6 +211,7 @@ pub struct PyGetSet {
     name: String,
     getter: Option<PyGetterFunc>,
     setter: Option<PySetterFunc>,
+    deleter: Option<PyDeleterFunc>,
     // doc: Option<String>,
 }
 
@@ -202,27 +265,37 @@ impl SlotDescriptor for PyGetSet {
 }
 
 impl PyGetSet {
-    pub fn with_get<G, X>(name: String, getter: G) -> Self
-    where
-        G: IntoPyGetterFunc<X>,
-    {
+    pub fn new(name: String) -> Self {
         Self {
             name,
-            getter: Some(getter.into_getter()),
+            getter: None,
             setter: None,
+            deleter: None,
         }
     }
 
-    pub fn with_get_set<G, S, X, Y>(name: String, getter: G, setter: S) -> Self
+    pub fn with_get<G, X>(mut self, getter: G) -> Self
     where
         G: IntoPyGetterFunc<X>,
-        S: IntoPySetterFunc<Y>,
     {
-        Self {
-            name,
-            getter: Some(getter.into_getter()),
-            setter: Some(setter.into_setter()),
-        }
+        self.getter = Some(getter.into_getter());
+        self
+    }
+
+    pub fn with_set<S, X>(mut self, setter: S) -> Self
+    where
+        S: IntoPySetterFunc<X>,
+    {
+        self.setter = Some(setter.into_setter());
+        self
+    }
+
+    pub fn with_delete<S, X>(mut self, setter: S) -> Self
+    where
+        S: IntoPyDeleterFunc<X>,
+    {
+        self.deleter = Some(setter.into_deleter());
+        self
     }
 }
 
@@ -243,6 +316,19 @@ impl PyGetSet {
         }
     }
 
+    #[pymethod(magic)]
+    fn delete(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        if let Some(ref f) = self.deleter {
+            f(vm, obj)
+        } else {
+            Err(vm.new_attribute_error(format!(
+                "attribute '{}' of '{}' objects is not writable",
+                self.name,
+                obj.class().name
+            )))
+        }
+    }
+
     #[pyproperty(magic)]
     fn name(&self) -> String {
         self.name.clone()
diff --git a/vm/src/builtins/make_module.rs b/vm/src/builtins/make_module.rs
index 1b2396bb12..821f17fb4d 100644
--- a/vm/src/builtins/make_module.rs
+++ b/vm/src/builtins/make_module.rs
@@ -12,7 +12,7 @@ mod decl {
     use crate::builtins::bytes::PyBytesRef;
     use crate::builtins::code::PyCodeRef;
     use crate::builtins::dict::PyDictRef;
-    use crate::builtins::function::PyFunctionRef;
+    use crate::builtins::function::{PyCellRef, PyFunctionRef};
     use crate::builtins::int::{self, PyIntRef};
     use crate::builtins::iter::{PyCallableIterator, PySequenceIterator};
     use crate::builtins::list::{PyList, SortOptions};
@@ -172,7 +172,7 @@ mod decl {
     fn dir(obj: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult<PyList> {
         let seq = match obj {
             OptionalArg::Present(obj) => vm.call_method(&obj, "__dir__", ())?,
-            OptionalArg::Missing => vm.call_method(&vm.get_locals().into_object(), "keys", ())?,
+            OptionalArg::Missing => vm.call_method(vm.current_locals()?.as_object(), "keys", ())?,
         };
         let sorted = sorted(seq, Default::default(), vm)?;
         Ok(sorted)
@@ -195,6 +195,33 @@ mod decl {
         locals: Option<PyDictRef>,
     }
 
+    #[cfg(feature = "rustpython-compiler")]
+    impl ScopeArgs {
+        fn make_scope(self, vm: &VirtualMachine) -> PyResult<Scope> {
+            let (globals, locals) = match self.globals {
+                Some(globals) => {
+                    if !globals.contains_key("__builtins__", vm) {
+                        let builtins_dict = vm.builtins.dict().unwrap().into_object();
+                        globals.set_item("__builtins__", builtins_dict, vm)?;
+                    }
+                    let locals = self.locals.unwrap_or_else(|| globals.clone());
+                    (globals, locals)
+                }
+                None => {
+                    let globals = vm.current_globals().clone();
+                    let locals = match self.locals {
+                        Some(l) => l,
+                        None => vm.current_locals()?,
+                    };
+                    (globals, locals)
+                }
+            };
+
+            let scope = Scope::with_builtins(Some(locals), globals, vm);
+            Ok(scope)
+        }
+    }
+
     /// Implements `eval`.
     /// See also: https://docs.python.org/3/library/functions.html#eval
     #[cfg(feature = "rustpython-compiler")]
@@ -204,7 +231,7 @@ mod decl {
         scope: ScopeArgs,
         vm: &VirtualMachine,
     ) -> PyResult {
-        run_code(vm, source, scope, compile::Mode::Eval)
+        run_code(vm, source, scope, compile::Mode::Eval, "eval")
     }
 
     /// Implements `exec`
@@ -216,7 +243,7 @@ mod decl {
         scope: ScopeArgs,
         vm: &VirtualMachine,
     ) -> PyResult {
-        run_code(vm, source, scope, compile::Mode::Exec)
+        run_code(vm, source, scope, compile::Mode::Exec, "exec")
     }
 
     #[cfg(feature = "rustpython-compiler")]
@@ -225,8 +252,9 @@ mod decl {
         source: Either<PyStrRef, PyCodeRef>,
         scope: ScopeArgs,
         mode: compile::Mode,
+        func: &str,
     ) -> PyResult {
-        let scope = make_scope(vm, scope)?;
+        let scope = scope.make_scope(vm)?;
 
         // Determine code object:
         let code_obj = match source {
@@ -236,39 +264,17 @@ mod decl {
             Either::B(code_obj) => code_obj,
         };
 
+        if !code_obj.freevars.is_empty() {
+            return Err(vm.new_type_error(format!(
+                "code object passed to {}() may not contain free variables",
+                func
+            )));
+        }
+
         // Run the code:
         vm.run_code_obj(code_obj, scope)
     }
 
-    #[cfg(feature = "rustpython-compiler")]
-    fn make_scope(vm: &VirtualMachine, scope: ScopeArgs) -> PyResult<Scope> {
-        let globals = scope.globals;
-        let current_scope = vm.current_scope();
-        let locals = match scope.locals {
-            Some(dict) => Some(dict),
-            None => {
-                if globals.is_some() {
-                    None
-                } else {
-                    current_scope.get_only_locals()
-                }
-            }
-        };
-        let globals = match globals {
-            Some(dict) => {
-                if !dict.contains_key("__builtins__", vm) {
-                    let builtins_dict = vm.builtins.dict().unwrap().as_object().clone();
-                    dict.set_item("__builtins__", builtins_dict, vm).unwrap();
-                }
-                dict
-            }
-            None => current_scope.globals.clone(),
-        };
-
-        let scope = Scope::with_builtins(locals, globals, vm);
-        Ok(scope)
-    }
-
     #[pyfunction]
     fn format(
         value: PyObjectRef,
@@ -318,7 +324,7 @@ mod decl {
 
     #[pyfunction]
     fn globals(vm: &VirtualMachine) -> PyResult<PyDictRef> {
-        Ok(vm.current_scope().globals.clone())
+        Ok(vm.current_globals().clone())
     }
 
     #[pyfunction]
@@ -448,9 +454,8 @@ mod decl {
     }
 
     #[pyfunction]
-    fn locals(vm: &VirtualMachine) -> PyDictRef {
-        let locals = vm.get_locals();
-        locals.copy().into_ref(vm)
+    fn locals(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        vm.current_locals()
     }
 
     fn min_or_max(
@@ -797,7 +802,7 @@ mod decl {
         if let OptionalArg::Present(obj) = obj {
             vm.get_attribute(obj, "__dict__")
         } else {
-            Ok(vm.get_locals().into_object())
+            Ok(vm.current_locals()?.into_object())
         }
     }
 
@@ -841,22 +846,20 @@ mod decl {
         let prepare = vm.get_attribute(metaclass.clone().into_object(), "__prepare__")?;
         let namespace = vm.invoke(&prepare, vec![name_obj.clone(), bases.clone()])?;
 
-        let namespace: PyDictRef = TryFromObject::try_from_object(vm, namespace)?;
-
-        let cells = vm.ctx.new_dict();
-
-        let scope = function
-            .scope()
-            .new_child_scope_with_locals(cells.clone())
-            .new_child_scope_with_locals(namespace.clone());
+        let namespace = PyDictRef::try_from_object(vm, namespace)?;
 
-        function.invoke_with_scope(().into(), &scope, vm)?;
+        let classcell = function.invoke_with_locals(().into(), Some(namespace.clone()), vm)?;
+        let classcell = <Option<PyCellRef>>::try_from_object(vm, classcell)?;
 
         let class = vm.invoke(
             metaclass.as_object(),
             FuncArgs::new(vec![name_obj, bases, namespace.into_object()], kwargs),
         )?;
-        cells.set_item("__class__", class.clone(), vm)?;
+
+        if let Some(ref classcell) = classcell {
+            classcell.set(Some(class.clone()));
+        }
+
         Ok(class)
     }
 }
diff --git a/vm/src/builtins/mod.rs b/vm/src/builtins/mod.rs
index b199b89f88..d7478b180f 100644
--- a/vm/src/builtins/mod.rs
+++ b/vm/src/builtins/mod.rs
@@ -70,7 +70,7 @@ pub(crate) mod staticmethod;
 pub use staticmethod::PyStaticMethod;
 pub(crate) mod traceback;
 pub use traceback::PyTraceback;
-pub(crate) mod tuple;
+pub mod tuple;
 pub use tuple::PyTuple;
 pub(crate) mod weakproxy;
 pub use weakproxy::PyWeakProxy;
diff --git a/vm/src/builtins/pysuper.rs b/vm/src/builtins/pysuper.rs
index b48c25c9da..a456ad8547 100644
--- a/vm/src/builtins/pysuper.rs
+++ b/vm/src/builtins/pysuper.rs
@@ -11,7 +11,7 @@ use super::pytype::{PyType, PyTypeRef};
 use crate::function::OptionalArg;
 use crate::pyobject::{
     BorrowValue, IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue,
-    TryFromObject, TypeProtocol,
+    TypeProtocol,
 };
 use crate::slots::{SlotDescriptor, SlotGetattro};
 use crate::vm::VirtualMachine;
@@ -58,44 +58,54 @@ impl PySuper {
         vm: &VirtualMachine,
     ) -> PyResult<PyRef<Self>> {
         // Get the type:
-        let typ = if let OptionalArg::Present(ty) = py_type {
-            ty
+        let (typ, obj) = if let OptionalArg::Present(ty) = py_type {
+            (ty, py_obj.unwrap_or_none(vm))
         } else {
-            let obj = vm
-                .current_scope()
-                .load_cell(vm, "__class__")
-                .ok_or_else(|| {
-                    vm.new_type_error(
-                        "super must be called with 1 argument or from inside class method"
-                            .to_owned(),
-                    )
-                })?;
-            PyTypeRef::try_from_object(vm, obj)?
-        };
-
-        // Check type argument:
-        if !typ.as_object().isinstance(&vm.ctx.types.type_type) {
-            return Err(vm.new_type_error(format!(
-                "super() argument 1 must be type, not {}",
-                typ.class().name
-            )));
-        }
+            let frame = vm
+                .current_frame()
+                .ok_or_else(|| vm.new_runtime_error("super(): no current frame".to_owned()))?;
 
-        // Get the bound object:
-        let obj = if let OptionalArg::Present(obj) = py_obj {
-            obj
-        } else {
-            let frame = vm.current_frame().expect("no current frame for super()");
-            if let Some(first_arg) = frame.code.arg_names().args.get(0) {
-                let locals = frame.scope.get_locals();
-                locals
-                    .get_item_option(first_arg.clone(), vm)?
-                    .ok_or_else(|| {
-                        vm.new_type_error(format!("super argument {} was not supplied", first_arg))
-                    })?
-            } else {
-                vm.ctx.none()
+            if frame.code.arg_count == 0 {
+                return Err(vm.new_runtime_error("super(): no arguments".to_owned()));
+            }
+            let obj = frame.fastlocals.lock()[0]
+                .clone()
+                .or_else(|| {
+                    if let Some(cell2arg) = frame.code.cell2arg.as_deref() {
+                        cell2arg[..frame.code.cellvars.len()]
+                            .iter()
+                            .enumerate()
+                            .find(|(_, arg_idx)| **arg_idx == 0)
+                            .and_then(|(cell_idx, _)| frame.cells_frees[cell_idx].get())
+                    } else {
+                        None
+                    }
+                })
+                .ok_or_else(|| vm.new_runtime_error("super(): arg[0] deleted".to_owned()))?;
+
+            let mut typ = None;
+            for (i, var) in frame.code.freevars.iter().enumerate() {
+                if var.borrow_value() == "__class__" {
+                    let i = frame.code.cellvars.len() + i;
+                    let class = frame.cells_frees[i].get().ok_or_else(|| {
+                        vm.new_runtime_error("super(): empty __class__ cell".to_owned())
+                    })?;
+                    typ = Some(class.downcast().map_err(|o| {
+                        vm.new_type_error(format!(
+                            "super(): __class__ is not a type ({})",
+                            o.class().name
+                        ))
+                    })?);
+                    break;
+                }
             }
+            let typ = typ.ok_or_else(|| {
+                vm.new_type_error(
+                    "super must be called with 1 argument or from inside class method".to_owned(),
+                )
+            })?;
+
+            (typ, obj)
         };
 
         PySuper::new(typ, obj, vm)?.into_ref_with_type(vm, cls)
diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs
index 91ce4050d4..74991c69db 100644
--- a/vm/src/builtins/tuple.rs
+++ b/vm/src/builtins/tuple.rs
@@ -1,12 +1,14 @@
 use crossbeam_utils::atomic::AtomicCell;
 use std::fmt;
+use std::marker::PhantomData;
 
 use super::pytype::PyTypeRef;
 use crate::common::hash::PyHash;
 use crate::function::OptionalArg;
 use crate::pyobject::{
     self, BorrowValue, Either, IdProtocol, IntoPyObject, PyArithmaticValue, PyClassImpl,
-    PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
+    PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TransmuteFromObject,
+    TryFromObject, TypeProtocol,
 };
 use crate::sequence::{self, SimpleSeq};
 use crate::sliceable::PySliceableSequence;
@@ -262,7 +264,7 @@ impl Iterable for PyTuple {
 
 #[pyclass(module = false, name = "tuple_iterator")]
 #[derive(Debug)]
-pub struct PyTupleIterator {
+pub(crate) struct PyTupleIterator {
     position: AtomicCell<usize>,
     tuple: PyTupleRef,
 }
@@ -287,9 +289,41 @@ impl PyIter for PyTupleIterator {
     }
 }
 
-pub fn init(context: &PyContext) {
-    let tuple_type = &context.types.tuple_type;
-    PyTuple::extend_class(context, tuple_type);
-
+pub(crate) fn init(context: &PyContext) {
+    PyTuple::extend_class(context, &context.types.tuple_type);
     PyTupleIterator::extend_class(context, &context.types.tuple_iterator_type);
 }
+
+pub struct PyTupleTyped<T: TransmuteFromObject> {
+    // SAFETY INVARIANT: T must be repr(transparent) over PyObjectRef, and the
+    //                   elements must be logically valid when transmuted to T
+    tuple: PyTupleRef,
+    _marker: PhantomData<Vec<T>>,
+}
+
+impl<T: TransmuteFromObject> TryFromObject for PyTupleTyped<T> {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        let tuple = PyTupleRef::try_from_object(vm, obj)?;
+        for elem in tuple.borrow_value() {
+            T::check(vm, elem)?
+        }
+        // SAFETY: the contract of TransmuteFromObject upholds the variant on `tuple`
+        Ok(Self {
+            tuple,
+            _marker: PhantomData,
+        })
+    }
+}
+
+impl<'a, T: TransmuteFromObject + 'a> BorrowValue<'a> for PyTupleTyped<T> {
+    type Borrowed = &'a [T];
+    fn borrow_value(&'a self) -> Self::Borrowed {
+        unsafe { &*(self.tuple.borrow_value() as *const [PyObjectRef] as *const [T]) }
+    }
+}
+
+impl<T: TransmuteFromObject + fmt::Debug> fmt::Debug for PyTupleTyped<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.borrow_value().fmt(f)
+    }
+}
diff --git a/vm/src/dictdatatype.rs b/vm/src/dictdatatype.rs
index 43df5a5a00..7963b92895 100644
--- a/vm/src/dictdatatype.rs
+++ b/vm/src/dictdatatype.rs
@@ -254,6 +254,15 @@ impl<T: Clone> Dict<T> {
     #[cfg_attr(feature = "flame-it", flame("Dict"))]
     pub fn get<K: DictKey>(&self, vm: &VirtualMachine, key: &K) -> PyResult<Option<T>> {
         let hash = key.key_hash(vm)?;
+        self._get_inner(vm, key, hash)
+    }
+
+    fn _get_inner<K: DictKey>(
+        &self,
+        vm: &VirtualMachine,
+        key: &K,
+        hash: HashValue,
+    ) -> PyResult<Option<T>> {
         let ret = loop {
             let (entry, index_index) = self.lookup(vm, key, hash, None)?;
             if let IndexEntry::Index(index) = entry {
@@ -275,6 +284,20 @@ impl<T: Clone> Dict<T> {
         Ok(ret)
     }
 
+    pub fn get_chain<K: DictKey>(
+        &self,
+        other: &Self,
+        vm: &VirtualMachine,
+        key: &K,
+    ) -> PyResult<Option<T>> {
+        let hash = key.key_hash(vm)?;
+        if let Some(x) = self._get_inner(vm, key, hash)? {
+            Ok(Some(x))
+        } else {
+            other._get_inner(vm, key, hash)
+        }
+    }
+
     pub fn clear(&self) {
         let _removed = {
             let mut inner = self.borrow_value_mut();
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
index fee9e595ce..bb749f8758 100644
--- a/vm/src/frame.rs
+++ b/vm/src/frame.rs
@@ -9,12 +9,13 @@ use crate::builtins::asyncgenerator::PyAsyncGenWrappedValue;
 use crate::builtins::code::PyCodeRef;
 use crate::builtins::coroutine::PyCoroutine;
 use crate::builtins::dict::{PyDict, PyDictRef};
+use crate::builtins::function::{PyCell, PyCellRef, PyFunction};
 use crate::builtins::generator::PyGenerator;
 use crate::builtins::pystr::{self, PyStr, PyStrRef};
 use crate::builtins::pytype::PyTypeRef;
 use crate::builtins::slice::PySlice;
 use crate::builtins::traceback::PyTraceback;
-use crate::builtins::tuple::PyTuple;
+use crate::builtins::tuple::{PyTuple, PyTupleTyped};
 use crate::builtins::{list, pybool, set};
 use crate::bytecode;
 use crate::common::lock::PyMutex;
@@ -91,7 +92,13 @@ struct FrameState {
 #[pyclass(module = false, name = "frame")]
 pub struct Frame {
     pub code: PyCodeRef,
-    pub scope: Scope,
+
+    pub fastlocals: PyMutex<Box<[Option<PyObjectRef>]>>,
+    pub(crate) cells_frees: Box<[PyCellRef]>,
+    pub locals: PyDictRef,
+    pub globals: PyDictRef,
+    pub builtins: PyDictRef,
+
     /// index of last instruction ran
     pub lasti: AtomicUsize,
     /// tracer function for this frame (usually is None)
@@ -151,7 +158,13 @@ impl ExecutionResult {
 pub type FrameResult = PyResult<Option<ExecutionResult>>;
 
 impl Frame {
-    pub fn new(code: PyCodeRef, scope: Scope, vm: &VirtualMachine) -> Frame {
+    pub(crate) fn new(
+        code: PyCodeRef,
+        scope: Scope,
+        builtins: PyDictRef,
+        closure: &[PyCellRef],
+        vm: &VirtualMachine,
+    ) -> Frame {
         //populate the globals and locals
         //TODO: This is wrong, check https://github.com/nedbat/byterun/blob/31e6c4a8212c35b5157919abff43a7daa0f377c6/byterun/pyvm2.py#L95
         /*
@@ -162,10 +175,18 @@ impl Frame {
         */
         // let locals = globals;
         // locals.extend(callargs);
+        let cells_frees = std::iter::repeat_with(|| PyCell::default().into_ref(vm))
+            .take(code.cellvars.len())
+            .chain(closure.iter().cloned())
+            .collect();
 
         Frame {
+            fastlocals: PyMutex::new(vec![None; code.varnames.len()].into_boxed_slice()),
+            cells_frees,
+            locals: scope.locals,
+            globals: scope.globals,
+            builtins,
             code,
-            scope,
             lasti: AtomicUsize::new(0),
             state: PyMutex::new(FrameState {
                 stack: Vec::new(),
@@ -182,7 +203,11 @@ impl FrameRef {
         let mut state = self.state.lock();
         let exec = ExecutingFrame {
             code: &self.code,
-            scope: &self.scope,
+            fastlocals: &self.fastlocals,
+            cells_frees: &self.cells_frees,
+            locals: &self.locals,
+            globals: &self.globals,
+            builtins: &self.builtins,
             lasti: &self.lasti,
             object: &self,
             state: &mut state,
@@ -190,6 +215,48 @@ impl FrameRef {
         f(exec)
     }
 
+    pub fn locals(&self, vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        let locals = &self.locals;
+        let code = &**self.code;
+        let map = &code.varnames;
+        let j = std::cmp::min(map.len(), code.varnames.len());
+        if !code.varnames.is_empty() {
+            let fastlocals = self.fastlocals.lock();
+            for (k, v) in itertools::zip(&map[..j], &**fastlocals) {
+                if let Some(v) = v {
+                    locals.set_item(k.clone(), v.clone(), vm)?;
+                } else {
+                    match locals.del_item(k.clone(), vm) {
+                        Ok(()) => {}
+                        Err(e) if e.isinstance(&vm.ctx.exceptions.key_error) => {}
+                        Err(e) => return Err(e),
+                    }
+                }
+            }
+        }
+        if !code.cellvars.is_empty() || !code.freevars.is_empty() {
+            let map_to_dict = |keys: &[PyStrRef], values: &[PyCellRef]| {
+                for (k, v) in itertools::zip(keys, values) {
+                    if let Some(v) = v.get() {
+                        locals.set_item(k.clone(), v, vm)?;
+                    } else {
+                        match locals.del_item(k.clone(), vm) {
+                            Ok(()) => {}
+                            Err(e) if e.isinstance(&vm.ctx.exceptions.key_error) => {}
+                            Err(e) => return Err(e),
+                        }
+                    }
+                }
+                Ok(())
+            };
+            map_to_dict(&code.cellvars, &self.cells_frees)?;
+            if code.flags.contains(bytecode::CodeFlags::IS_OPTIMIZED) {
+                map_to_dict(&code.freevars, &self.cells_frees[code.cellvars.len()..])?;
+            }
+        }
+        Ok(locals.clone())
+    }
+
     // #[cfg_attr(feature = "flame-it", flame("Frame"))]
     pub fn run(&self, vm: &VirtualMachine) -> PyResult<ExecutionResult> {
         self.with_exec(|mut exec| exec.run(vm))
@@ -233,7 +300,11 @@ impl FrameRef {
 /// with the mutable data inside
 struct ExecutingFrame<'a> {
     code: &'a PyCodeRef,
-    scope: &'a Scope,
+    fastlocals: &'a PyMutex<Box<[Option<PyObjectRef>]>>,
+    cells_frees: &'a [PyCellRef],
+    locals: &'a PyDictRef,
+    globals: &'a PyDictRef,
+    builtins: &'a PyDictRef,
     object: &'a FrameRef,
     lasti: &'a AtomicUsize,
     state: &'a mut FrameState,
@@ -243,7 +314,7 @@ impl fmt::Debug for ExecutingFrame<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("ExecutingFrame")
             .field("code", self.code)
-            .field("scope", self.scope)
+            // .field("scope", self.scope)
             .field("lasti", self.lasti)
             .field("state", self.state)
             .finish()
@@ -260,7 +331,7 @@ impl ExecutingFrame<'_> {
             let instr = &self.code.instructions[idx];
             let result = self.execute_instruction(instr, vm);
             match result {
-                Ok(None) => {}
+                Ok(None) => continue,
                 Ok(Some(value)) => {
                     break Ok(value);
                 }
@@ -278,7 +349,7 @@ impl ExecutingFrame<'_> {
                     exception.set_traceback(Some(new_traceback.into_ref(vm)));
 
                     match self.unwind_blocks(vm, UnwindReason::Raising { exception }) {
-                        Ok(None) => {}
+                        Ok(None) => continue,
                         Ok(Some(result)) => {
                             break Ok(result);
                         }
@@ -330,6 +401,21 @@ impl ExecutingFrame<'_> {
         }
     }
 
+    fn unbound_cell_exception(&self, i: usize, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        if let Some(name) = self.code.cellvars.get(i) {
+            vm.new_exception_msg(
+                vm.ctx.exceptions.unbound_local_error.clone(),
+                format!("local variable '{}' referenced before assignment", name),
+            )
+        } else {
+            let name = &self.code.freevars[i - self.code.cellvars.len()];
+            vm.new_name_error(format!(
+                "free variable '{}' referenced before assignment in enclosing scope",
+                name
+            ))
+        }
+    }
+
     /// Execute a single instruction.
     #[inline(always)]
     fn execute_instruction(
@@ -366,9 +452,113 @@ impl ExecutingFrame<'_> {
             } => self.import(vm, *name_idx, symbols_idx, *level),
             bytecode::Instruction::ImportStar => self.import_star(vm),
             bytecode::Instruction::ImportFrom { idx } => self.import_from(vm, *idx),
-            bytecode::Instruction::LoadName { idx, scope } => self.load_name(vm, *idx, *scope),
-            bytecode::Instruction::StoreName { idx, scope } => self.store_name(vm, *idx, *scope),
-            bytecode::Instruction::DeleteName { idx } => self.delete_name(vm, *idx),
+            bytecode::Instruction::LoadFast(idx) => {
+                let x = self.fastlocals.lock()[*idx].clone().ok_or_else(|| {
+                    vm.new_exception_msg(
+                        vm.ctx.exceptions.unbound_local_error.clone(),
+                        format!(
+                            "local variable '{}' referenced before assignment",
+                            self.code.varnames[*idx]
+                        ),
+                    )
+                })?;
+                self.push_value(x);
+                Ok(None)
+            }
+            bytecode::Instruction::LoadNameAny(idx) => {
+                let name = &self.code.names[*idx];
+                let x = self.locals.get_item_option(name.clone(), vm)?;
+                let x = match x {
+                    Some(x) => x,
+                    None => self.load_global_or_builtin(name, vm)?,
+                };
+                self.push_value(x);
+                Ok(None)
+            }
+            bytecode::Instruction::LoadGlobal(idx) => {
+                let name = &self.code.names[*idx];
+                let x = self.load_global_or_builtin(name, vm)?;
+                self.push_value(x);
+                Ok(None)
+            }
+            bytecode::Instruction::LoadDeref(i) => {
+                let i = *i;
+                let x = self.cells_frees[i]
+                    .get()
+                    .ok_or_else(|| self.unbound_cell_exception(i, vm))?;
+                self.push_value(x);
+                Ok(None)
+            }
+            bytecode::Instruction::LoadClassDeref(i) => {
+                let i = *i;
+                let name = self.code.freevars[i - self.code.cellvars.len()].clone();
+                let value = if let Some(value) = self.locals.get_item_option(name, vm)? {
+                    value
+                } else {
+                    self.cells_frees[i]
+                        .get()
+                        .ok_or_else(|| self.unbound_cell_exception(i, vm))?
+                };
+                self.push_value(value);
+                Ok(None)
+            }
+            bytecode::Instruction::StoreFast(idx) => {
+                let value = self.pop_value();
+                self.fastlocals.lock()[*idx] = Some(value);
+                Ok(None)
+            }
+            bytecode::Instruction::StoreLocal(idx) => {
+                let value = self.pop_value();
+                self.locals
+                    .set_item(self.code.names[*idx].clone(), value, vm)?;
+                Ok(None)
+            }
+            bytecode::Instruction::StoreGlobal(idx) => {
+                let value = self.pop_value();
+                self.globals
+                    .set_item(self.code.names[*idx].clone(), value, vm)?;
+                Ok(None)
+            }
+            bytecode::Instruction::StoreDeref(i) => {
+                let value = self.pop_value();
+                self.cells_frees[*i].set(Some(value));
+                Ok(None)
+            }
+            bytecode::Instruction::DeleteFast(idx) => {
+                self.fastlocals.lock()[*idx] = None;
+                Ok(None)
+            }
+            bytecode::Instruction::DeleteLocal(idx) => {
+                let name = &self.code.names[*idx];
+                match self.locals.del_item(name.clone(), vm) {
+                    Ok(()) => {}
+                    Err(e) if e.isinstance(&vm.ctx.exceptions.key_error) => {
+                        return Err(vm.new_name_error(format!("name '{}' is not defined", name)))
+                    }
+                    Err(e) => return Err(e),
+                }
+                Ok(None)
+            }
+            bytecode::Instruction::DeleteGlobal(idx) => {
+                let name = &self.code.names[*idx];
+                match self.globals.del_item(name.clone(), vm) {
+                    Ok(()) => {}
+                    Err(e) if e.isinstance(&vm.ctx.exceptions.key_error) => {
+                        return Err(vm.new_name_error(format!("name '{}' is not defined", name)))
+                    }
+                    Err(e) => return Err(e),
+                }
+                Ok(None)
+            }
+            bytecode::Instruction::DeleteDeref(i) => {
+                self.cells_frees[*i].set(None);
+                Ok(None)
+            }
+            bytecode::Instruction::LoadClosure(i) => {
+                let value = self.cells_frees[*i].clone();
+                self.push_value(value.into_object());
+                Ok(None)
+            }
             bytecode::Instruction::Subscript => self.execute_subscript(vm),
             bytecode::Instruction::StoreSubscript => self.execute_store_subscript(vm),
             bytecode::Instruction::DeleteSubscript => self.execute_delete_subscript(vm),
@@ -472,9 +662,9 @@ impl ExecutingFrame<'_> {
             }
             bytecode::Instruction::YieldFrom => self.execute_yield_from(vm),
             bytecode::Instruction::SetupAnnotation => {
-                let locals = self.scope.get_locals();
-                if !locals.contains_key("__annotations__", vm) {
-                    locals.set_item("__annotations__", vm.ctx.new_dict().into_object(), vm)?;
+                if !self.locals.contains_key("__annotations__", vm) {
+                    self.locals
+                        .set_item("__annotations__", vm.ctx.new_dict().into_object(), vm)?;
                 }
                 Ok(None)
             }
@@ -754,6 +944,13 @@ impl ExecutingFrame<'_> {
         }
     }
 
+    #[inline]
+    fn load_global_or_builtin(&self, name: &PyStrRef, vm: &VirtualMachine) -> PyResult {
+        self.globals
+            .get_chain(self.builtins, name.clone(), vm)?
+            .ok_or_else(|| vm.new_name_error(format!("name '{}' is not defined", name)))
+    }
+
     #[cfg_attr(feature = "flame-it", flame("Frame"))]
     fn get_elements(
         &mut self,
@@ -826,9 +1023,8 @@ impl ExecutingFrame<'_> {
                 };
             for (k, v) in &dict {
                 let k = PyStrRef::try_from_object(vm, k)?;
-                let k = k.as_ref();
-                if filter_pred(k) {
-                    self.scope.store_name(&vm, k, v);
+                if filter_pred(k.borrow_value()) {
+                    self.locals.set_item(k, v, vm)?;
                 }
             }
         }
@@ -904,61 +1100,6 @@ impl ExecutingFrame<'_> {
         }
     }
 
-    fn store_name(
-        &mut self,
-        vm: &VirtualMachine,
-        idx: bytecode::NameIdx,
-        name_scope: bytecode::NameScope,
-    ) -> FrameResult {
-        let name = self.code.names[idx].clone();
-        let obj = self.pop_value();
-        match name_scope {
-            bytecode::NameScope::Global => {
-                self.scope.store_global(vm, name, obj);
-            }
-            bytecode::NameScope::NonLocal => {
-                self.scope.store_cell(vm, name, obj);
-            }
-            bytecode::NameScope::Local => {
-                self.scope.store_name(vm, name, obj);
-            }
-            bytecode::NameScope::Free => {
-                self.scope.store_name(vm, name, obj);
-            }
-        }
-        Ok(None)
-    }
-
-    fn delete_name(&self, vm: &VirtualMachine, idx: bytecode::NameIdx) -> FrameResult {
-        let name = &self.code.names[idx];
-        match self.scope.delete_name(vm, name.clone()) {
-            Ok(_) => Ok(None),
-            Err(_) => Err(vm.new_name_error(format!("name '{}' is not defined", name))),
-        }
-    }
-
-    #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    #[inline]
-    fn load_name(
-        &mut self,
-        vm: &VirtualMachine,
-        idx: bytecode::NameIdx,
-        name_scope: bytecode::NameScope,
-    ) -> FrameResult {
-        let name = &self.code.names[idx];
-        let optional_value = match name_scope {
-            bytecode::NameScope::Global => self.scope.load_global(vm, name.clone()),
-            bytecode::NameScope::NonLocal => self.scope.load_cell(vm, name.clone()),
-            bytecode::NameScope::Local => self.scope.load_local(vm, name.clone()),
-            bytecode::NameScope::Free => self.scope.load_name(vm, name.clone()),
-        };
-
-        let value = optional_value
-            .ok_or_else(|| vm.new_name_error(format!("name '{}' is not defined", name)))?;
-        self.push_value(value);
-        Ok(None)
-    }
-
     fn execute_rotate(&mut self, amount: usize) -> FrameResult {
         // Shuffles top of stack amount down
         if amount < 2 {
@@ -1113,6 +1254,11 @@ impl ExecutingFrame<'_> {
         };
 
         // Call function:
+        // eprintln!(
+        //     "calling from {} {:?}",
+        //     self.code.obj_name,
+        //     self.code.locations[self.lasti.load(Ordering::Relaxed)]
+        // );
         let func_ref = self.pop_value();
         let value = vm.invoke(&func_ref, args)?;
         self.push_value(value);
@@ -1278,6 +1424,12 @@ impl ExecutingFrame<'_> {
 
         let flags = code_obj.flags;
 
+        let closure = if code_obj.freevars.is_empty() {
+            None
+        } else {
+            Some(PyTupleTyped::try_from_object(vm, self.pop_value()).unwrap())
+        };
+
         let annotations = if flags.contains(bytecode::CodeFlags::HAS_ANNOTATIONS) {
             self.pop_value()
         } else {
@@ -1306,10 +1458,15 @@ impl ExecutingFrame<'_> {
 
         // pop argc arguments
         // argument: name, args, globals
-        let scope = self.scope.clone();
-        let func_obj = vm
-            .ctx
-            .new_pyfunction(code_obj, scope, defaults, kw_only_defaults);
+        // let scope = self.scope.clone();
+        let func_obj = PyFunction::new(
+            code_obj,
+            self.globals.clone(),
+            closure,
+            defaults,
+            kw_only_defaults,
+        )
+        .into_object(vm);
 
         vm.set_attr(&func_obj, "__doc__", vm.ctx.none())?;
 
@@ -1320,7 +1477,7 @@ impl ExecutingFrame<'_> {
             .unwrap();
         vm.set_attr(&func_obj, "__name__", vm.ctx.new_str(name))?;
         vm.set_attr(&func_obj, "__qualname__", qualified_name)?;
-        let module = vm.unwrap_or_none(self.scope.globals.get_item_option("__name__", vm)?);
+        let module = vm.unwrap_or_none(self.globals.get_item_option("__name__", vm)?);
         vm.set_attr(&func_obj, "__module__", module)?;
         vm.set_attr(&func_obj, "__annotations__", annotations)?;
 
@@ -1546,7 +1703,8 @@ impl fmt::Debug for Frame {
             .iter()
             .map(|elem| format!("\n  > {:?}", elem))
             .collect::<String>();
-        let dict = self.scope.get_locals();
+        // TODO: fix this up
+        let dict = self.locals.clone();
         let local_str = dict
             .into_iter()
             .map(|elem| format!("\n  {:?} = {:?}", elem.0, elem.1))
diff --git a/vm/src/function.rs b/vm/src/function.rs
index a505ad477d..19495c772a 100644
--- a/vm/src/function.rs
+++ b/vm/src/function.rs
@@ -34,6 +34,7 @@ macro_rules! into_func_args_from_tuple {
         where
             $($T: IntoPyObject,)*
         {
+            #[inline]
             fn into_args(self, vm: &VirtualMachine) -> FuncArgs {
                 let ($($n,)*) = self;
                 vec![$($n.into_pyobject(vm),)*].into()
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
index ca5dc940ad..15f1484ec5 100644
--- a/vm/src/pyobject.rs
+++ b/vm/src/pyobject.rs
@@ -15,7 +15,7 @@ use crate::builtins::code::PyCodeRef;
 use crate::builtins::complex::PyComplex;
 use crate::builtins::dict::{PyDict, PyDictRef};
 use crate::builtins::float::PyFloat;
-use crate::builtins::function::{PyBoundMethod, PyFunction};
+use crate::builtins::function::PyBoundMethod;
 use crate::builtins::getset::{IntoPyGetterFunc, IntoPySetterFunc, PyGetSet};
 use crate::builtins::int::{PyInt, PyIntRef};
 use crate::builtins::iter::PySequenceIterator;
@@ -38,7 +38,6 @@ use crate::exceptions::{self, PyBaseExceptionRef};
 use crate::function::{IntoFuncArgs, IntoPyNativeFunc};
 use crate::iterator;
 pub use crate::pyobjectrc::{PyObject, PyObjectRef, PyObjectWeak, PyRef, PyWeakRef};
-use crate::scope::Scope;
 use crate::slots::{PyTpFlags, PyTypeSlots};
 use crate::types::{create_type_with_slots, TypeZoo};
 use crate::vm::VirtualMachine;
@@ -323,7 +322,7 @@ impl PyContext {
         F: IntoPyGetterFunc<T>,
     {
         PyObject::new(
-            PyGetSet::with_get(name.into(), f),
+            PyGetSet::new(name.into()).with_get(f),
             self.types.getset_type.clone(),
             None,
         )
@@ -335,7 +334,7 @@ impl PyContext {
         S: IntoPySetterFunc<U>,
     {
         PyObject::new(
-            PyGetSet::with_get_set(name.into(), g, s),
+            PyGetSet::new(name.into()).with_get(g).with_set(s),
             self.types.getset_type.clone(),
             None,
         )
@@ -348,20 +347,6 @@ impl PyContext {
         PyRef::new_ref(code::PyCode::new(code), self.types.code_type.clone(), None)
     }
 
-    pub fn new_pyfunction(
-        &self,
-        code_obj: PyCodeRef,
-        scope: Scope,
-        defaults: Option<PyTupleRef>,
-        kw_only_defaults: Option<PyDictRef>,
-    ) -> PyObjectRef {
-        PyObject::new(
-            PyFunction::new(code_obj, scope, defaults, kw_only_defaults),
-            self.types.function_type.clone(),
-            Some(self.new_dict()),
-        )
-    }
-
     pub fn new_bound_method(&self, function: PyObjectRef, object: PyObjectRef) -> PyObjectRef {
         PyObject::new(
             PyBoundMethod::new(object, function),
@@ -398,26 +383,41 @@ impl<T> TryFromObject for PyRef<T>
 where
     T: PyValue,
 {
+    #[inline]
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         let class = T::class(vm);
         if obj.isinstance(class) {
-            obj.downcast().map_err(|obj| {
-                vm.new_runtime_error(format!(
-                    "Unexpected payload '{}' for type '{}'",
-                    class.name,
-                    obj.class().name,
-                ))
-            })
+            obj.downcast()
+                .map_err(|obj| pyref_payload_error(vm, class, obj))
         } else {
-            let expected_type = &class.name;
-            let actual_type = &obj.class().name;
-            Err(vm.new_type_error(format!(
-                "Expected type '{}', not '{}'",
-                expected_type, actual_type,
-            )))
+            Err(pyref_type_error(vm, class, obj))
         }
     }
 }
+// the impl Borrow allows to pass PyObjectRef or &PyObjectRef
+fn pyref_payload_error(
+    vm: &VirtualMachine,
+    class: &PyTypeRef,
+    obj: impl std::borrow::Borrow<PyObjectRef>,
+) -> PyBaseExceptionRef {
+    vm.new_runtime_error(format!(
+        "Unexpected payload '{}' for type '{}'",
+        &*class.name,
+        &*obj.borrow().class().name,
+    ))
+}
+fn pyref_type_error(
+    vm: &VirtualMachine,
+    class: &PyTypeRef,
+    obj: impl std::borrow::Borrow<PyObjectRef>,
+) -> PyBaseExceptionRef {
+    let expected_type = &*class.name;
+    let actual_type = &*obj.borrow().class().name;
+    vm.new_type_error(format!(
+        "Expected type '{}', not '{}'",
+        expected_type, actual_type,
+    ))
+}
 
 impl<'a, T: PyValue> From<&'a PyRef<T>> for &'a PyObjectRef {
     fn from(obj: &'a PyRef<T>) -> Self {
@@ -477,6 +477,7 @@ impl<T: PyValue> Deref for PyRefExact<T> {
     }
 }
 impl<T: PyValue> IntoPyObject for PyRefExact<T> {
+    #[inline]
     fn into_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
         self.obj.into_object()
     }
@@ -637,8 +638,8 @@ where
     T: IntoPyObject + ?Sized,
 {
     fn get_item(&self, key: T, vm: &VirtualMachine) -> PyResult;
-    fn set_item(&self, key: T, value: PyObjectRef, vm: &VirtualMachine) -> PyResult;
-    fn del_item(&self, key: T, vm: &VirtualMachine) -> PyResult;
+    fn set_item(&self, key: T, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()>;
+    fn del_item(&self, key: T, vm: &VirtualMachine) -> PyResult<()>;
 }
 
 impl<T> ItemProtocol<T> for PyObjectRef
@@ -649,12 +650,12 @@ where
         vm.call_method(self, "__getitem__", (key,))
     }
 
-    fn set_item(&self, key: T, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm.call_method(self, "__setitem__", (key, value))
+    fn set_item(&self, key: T, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        vm.call_method(self, "__setitem__", (key, value)).map(drop)
     }
 
-    fn del_item(&self, key: T, vm: &VirtualMachine) -> PyResult {
-        vm.call_method(self, "__delitem__", (key,))
+    fn del_item(&self, key: T, vm: &VirtualMachine) -> PyResult<()> {
+        vm.call_method(self, "__delitem__", (key,)).map(drop)
     }
 }
 
@@ -785,6 +786,31 @@ pub trait TryFromObject: Sized {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self>;
 }
 
+/// Marks a type that has the exact same layout as PyObjectRef, e.g. a type that is
+/// `repr(transparent)` over PyObjectRef.
+///
+/// # Safety
+/// Can only be implemented for types that are `repr(transparent)` over a PyObjectRef `obj`,
+/// and logically valid so long as `check(vm, obj)` returns `Ok(())`
+pub unsafe trait TransmuteFromObject: Sized {
+    fn check(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<()>;
+}
+
+unsafe impl<T: PyValue> TransmuteFromObject for PyRef<T> {
+    fn check(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<()> {
+        let class = T::class(vm);
+        if obj.isinstance(class) {
+            if obj.payload_is::<T>() {
+                Ok(())
+            } else {
+                Err(pyref_payload_error(vm, class, obj))
+            }
+        } else {
+            Err(pyref_type_error(vm, class, obj))
+        }
+    }
+}
+
 pub trait IntoPyRef<T: PyObjectPayload> {
     fn into_pyref(self, vm: &VirtualMachine) -> PyRef<T>;
 }
@@ -808,18 +834,21 @@ pub trait IntoPyObject {
 }
 
 impl<T: PyObjectPayload> IntoPyObject for PyRef<T> {
+    #[inline]
     fn into_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
         self.into_object()
     }
 }
 
 impl IntoPyObject for PyCallable {
+    #[inline]
     fn into_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
         self.into_object()
     }
 }
 
 impl IntoPyObject for PyObjectRef {
+    #[inline]
     fn into_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
         self
     }
@@ -831,6 +860,7 @@ impl<T> IntoPyObject for T
 where
     T: PyValue + Sized,
 {
+    #[inline]
     fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
         PyValue::into_object(self, vm)
     }
@@ -871,33 +901,36 @@ cfg_if::cfg_if! {
 pub trait PyValue: fmt::Debug + PyThreadingConstraint + Sized + 'static {
     fn class(vm: &VirtualMachine) -> &PyTypeRef;
 
+    #[inline]
     fn into_object(self, vm: &VirtualMachine) -> PyObjectRef {
         self.into_ref(vm).into_object()
     }
 
     fn into_ref(self, vm: &VirtualMachine) -> PyRef<Self> {
-        self.into_ref_with_type_unchecked(Self::class(vm).clone(), vm)
+        let cls = Self::class(vm).clone();
+        let dict = if cls.slots.flags.has_feature(PyTpFlags::HAS_DICT) {
+            Some(vm.ctx.new_dict())
+        } else {
+            None
+        };
+        PyRef::new_ref(self, cls, dict)
     }
 
     fn into_ref_with_type(self, vm: &VirtualMachine, cls: PyTypeRef) -> PyResult<PyRef<Self>> {
-        let class = Self::class(vm);
-        if cls.issubclass(class) {
-            Ok(self.into_ref_with_type_unchecked(cls, vm))
+        let exact_class = Self::class(vm);
+        if cls.issubclass(exact_class) {
+            let dict = if cls.slots.flags.has_feature(PyTpFlags::HAS_DICT) {
+                Some(vm.ctx.new_dict())
+            } else {
+                None
+            };
+            Ok(PyRef::new_ref(self, cls, dict))
         } else {
             let subtype = vm.to_str(cls.as_object())?;
-            let basetype = vm.to_str(cls.as_object())?;
+            let basetype = vm.to_str(exact_class.as_object())?;
             Err(vm.new_type_error(format!("{} is not a subtype of {}", subtype, basetype)))
         }
     }
-
-    fn into_ref_with_type_unchecked(self, cls: PyTypeRef, vm: &VirtualMachine) -> PyRef<Self> {
-        let dict = if cls.slots.flags.has_feature(PyTpFlags::HAS_DICT) {
-            Some(vm.ctx.new_dict())
-        } else {
-            None
-        };
-        PyRef::new_ref(self, cls, dict)
-    }
 }
 
 pub trait PyObjectPayload: Any + fmt::Debug + PyThreadingConstraint + 'static {}
diff --git a/vm/src/scope.rs b/vm/src/scope.rs
index e770279263..8a25dc3a55 100644
--- a/vm/src/scope.rs
+++ b/vm/src/scope.rs
@@ -1,16 +1,12 @@
 use std::fmt;
 
 use crate::builtins::{PyDictRef, PyStr, PyStrRef};
-use crate::pyobject::{IntoPyObject, ItemProtocol, PyContext, PyObjectRef, PyResult, TryIntoRef};
+use crate::pyobject::{IntoPyObject, ItemProtocol, TryIntoRef};
 use crate::VirtualMachine;
 
-/*
- * So a scope is a linked list of scopes.
- * When a name is looked up, it is check in its scope.
- */
 #[derive(Clone)]
 pub struct Scope {
-    locals: Vec<PyDictRef>,
+    pub locals: PyDictRef,
     pub globals: PyDictRef,
 }
 
@@ -22,14 +18,10 @@ impl fmt::Debug for Scope {
 }
 
 impl Scope {
-    pub fn new(locals: Option<PyDictRef>, globals: PyDictRef, vm: &VirtualMachine) -> Scope {
-        let locals = match locals {
-            Some(dict) => vec![dict],
-            None => vec![],
-        };
-        let scope = Scope { locals, globals };
-        scope.store_name(vm, "__annotations__", vm.ctx.new_dict().into_object());
-        scope
+    #[inline]
+    pub fn new(locals: Option<PyDictRef>, globals: PyDictRef) -> Scope {
+        let locals = locals.unwrap_or_else(|| globals.clone());
+        Scope { locals, globals }
     }
 
     pub fn with_builtins(
@@ -42,108 +34,108 @@ impl Scope {
                 .set_item("__builtins__", vm.builtins.clone(), vm)
                 .unwrap();
         }
-        Scope::new(locals, globals, vm)
+        Scope::new(locals, globals)
     }
 
-    pub fn get_locals(&self) -> &PyDictRef {
-        match self.locals.first() {
-            Some(dict) => dict,
-            None => &self.globals,
-        }
-    }
-
-    pub fn get_only_locals(&self) -> Option<PyDictRef> {
-        self.locals.first().cloned()
-    }
-
-    pub fn new_child_scope_with_locals(&self, locals: PyDictRef) -> Scope {
-        let mut new_locals = Vec::with_capacity(self.locals.len() + 1);
-        new_locals.push(locals);
-        new_locals.extend_from_slice(&self.locals);
-        Scope {
-            locals: new_locals,
-            globals: self.globals.clone(),
-        }
-    }
-
-    pub fn new_child_scope(&self, ctx: &PyContext) -> Scope {
-        self.new_child_scope_with_locals(ctx.new_dict())
-    }
-
-    #[cfg_attr(feature = "flame-it", flame("Scope"))]
-    pub fn load_name(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
-        for dict in self.locals.iter() {
-            if let Some(value) = dict.get_item_option(name.clone(), vm).unwrap() {
-                return Some(value);
-            }
-        }
-
-        // Fall back to loading a global after all scopes have been searched!
-        self.load_global(vm, name)
-    }
-
-    #[cfg_attr(feature = "flame-it", flame("Scope"))]
-    /// Load a local name. Only check the local dictionary for the given name.
-    pub fn load_local(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
-        self.get_locals().get_item_option(name, vm).unwrap()
-    }
-
-    #[cfg_attr(feature = "flame-it", flame("Scope"))]
-    pub fn load_cell(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
-        for dict in self.locals.iter().skip(1) {
-            if let Some(value) = dict.get_item_option(name.clone(), vm).unwrap() {
-                return Some(value);
-            }
-        }
-        None
-    }
-
-    pub fn store_cell(&self, vm: &VirtualMachine, name: impl PyName, value: PyObjectRef) {
-        // find the innermost outer scope that contains the symbol name
-        if let Some(locals) = self
-            .locals
-            .iter()
-            .rev()
-            .find(|l| l.contains_key(name.clone(), vm))
-        {
-            // add to the symbol
-            locals.set_item(name, value, vm).unwrap();
-        } else {
-            // somewhat limited solution -> fallback to the old rustpython strategy
-            // and store the next outer scope
-            // This case is usually considered as a failure case, but kept for the moment
-            // to support the scope propagation for named expression assignments to so far
-            // unknown names in comprehensions. We need to consider here more context
-            // information for correct handling.
-            self.locals
-                .get(1)
-                .expect("no outer scope for non-local")
-                .set_item(name, value, vm)
-                .unwrap();
-        }
-    }
-
-    pub fn store_name(&self, vm: &VirtualMachine, key: impl PyName, value: PyObjectRef) {
-        self.get_locals().set_item(key, value, vm).unwrap();
-    }
-
-    pub fn delete_name(&self, vm: &VirtualMachine, key: impl PyName) -> PyResult {
-        self.get_locals().del_item(key, vm)
-    }
-
-    #[cfg_attr(feature = "flame-it", flame("Scope"))]
-    /// Load a global name.
-    pub fn load_global(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
-        if let Some(value) = self.globals.get_item_option(name.clone(), vm).unwrap() {
-            Some(value)
-        } else {
-            vm.get_attribute(vm.builtins.clone(), name).ok()
-        }
-    }
-
-    pub fn store_global(&self, vm: &VirtualMachine, name: impl PyName, value: PyObjectRef) {
-        self.globals.set_item(name, value, vm).unwrap();
-    }
+    // pub fn get_locals(&self) -> &PyDictRef {
+    //     match self.locals.first() {
+    //         Some(dict) => dict,
+    //         None => &self.globals,
+    //     }
+    // }
+
+    // pub fn get_only_locals(&self) -> Option<PyDictRef> {
+    //     self.locals.first().cloned()
+    // }
+
+    // pub fn new_child_scope_with_locals(&self, locals: PyDictRef) -> Scope {
+    //     let mut new_locals = Vec::with_capacity(self.locals.len() + 1);
+    //     new_locals.push(locals);
+    //     new_locals.extend_from_slice(&self.locals);
+    //     Scope {
+    //         locals: new_locals,
+    //         globals: self.globals.clone(),
+    //     }
+    // }
+
+    // pub fn new_child_scope(&self, ctx: &PyContext) -> Scope {
+    //     self.new_child_scope_with_locals(ctx.new_dict())
+    // }
+
+    // #[cfg_attr(feature = "flame-it", flame("Scope"))]
+    // pub fn load_name(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
+    //     for dict in self.locals.iter() {
+    //         if let Some(value) = dict.get_item_option(name.clone(), vm).unwrap() {
+    //             return Some(value);
+    //         }
+    //     }
+
+    //     // Fall back to loading a global after all scopes have been searched!
+    //     self.load_global(vm, name)
+    // }
+
+    // #[cfg_attr(feature = "flame-it", flame("Scope"))]
+    // /// Load a local name. Only check the local dictionary for the given name.
+    // pub fn load_local(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
+    //     self.get_locals().get_item_option(name, vm).unwrap()
+    // }
+
+    // #[cfg_attr(feature = "flame-it", flame("Scope"))]
+    // pub fn load_cell(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
+    //     for dict in self.locals.iter().skip(1) {
+    //         if let Some(value) = dict.get_item_option(name.clone(), vm).unwrap() {
+    //             return Some(value);
+    //         }
+    //     }
+    //     None
+    // }
+
+    // pub fn store_cell(&self, vm: &VirtualMachine, name: impl PyName, value: PyObjectRef) {
+    //     // find the innermost outer scope that contains the symbol name
+    //     if let Some(locals) = self
+    //         .locals
+    //         .iter()
+    //         .rev()
+    //         .find(|l| l.contains_key(name.clone(), vm))
+    //     {
+    //         // add to the symbol
+    //         locals.set_item(name, value, vm).unwrap();
+    //     } else {
+    //         // somewhat limited solution -> fallback to the old rustpython strategy
+    //         // and store the next outer scope
+    //         // This case is usually considered as a failure case, but kept for the moment
+    //         // to support the scope propagation for named expression assignments to so far
+    //         // unknown names in comprehensions. We need to consider here more context
+    //         // information for correct handling.
+    //         self.locals
+    //             .get(1)
+    //             .expect("no outer scope for non-local")
+    //             .set_item(name, value, vm)
+    //             .unwrap();
+    //     }
+    // }
+
+    // pub fn store_name(&self, vm: &VirtualMachine, key: impl PyName, value: PyObjectRef) {
+    //     self.get_locals().set_item(key, value, vm).unwrap();
+    // }
+
+    // pub fn delete_name(&self, vm: &VirtualMachine, key: impl PyName) -> PyResult {
+    //     self.get_locals().del_item(key, vm)
+    // }
+
+    // #[cfg_attr(feature = "flame-it", flame("Scope"))]
+    // /// Load a global name.
+    // pub fn load_global(&self, vm: &VirtualMachine, name: impl PyName) -> Option<PyObjectRef> {
+    //     if let Some(value) = self.globals.get_item_option(name.clone(), vm).unwrap() {
+    //         Some(value)
+    //     } else {
+    //         vm.get_attribute(vm.builtins.clone(), name).ok()
+    //     }
+    // }
+
+    // pub fn store_global(&self, vm: &VirtualMachine, name: impl PyName, value: PyObjectRef) {
+    //     self.globals.set_item(name, value, vm).unwrap();
+    // }
 }
 
 mod sealed {
diff --git a/vm/src/stdlib/symtable.rs b/vm/src/stdlib/symtable.rs
index e645dc1dee..ca79878895 100644
--- a/vm/src/stdlib/symtable.rs
+++ b/vm/src/stdlib/symtable.rs
@@ -205,7 +205,7 @@ mod decl {
 
         #[pymethod(name = "is_nonlocal")]
         fn is_nonlocal(&self) -> bool {
-            matches!(self.symbol.scope, SymbolScope::Nonlocal)
+            self.symbol.is_nonlocal
         }
 
         #[pymethod(name = "is_referenced")]
@@ -225,7 +225,7 @@ mod decl {
 
         #[pymethod(name = "is_free")]
         fn is_free(&self) -> bool {
-            self.symbol.is_free
+            matches!(self.symbol.scope, SymbolScope::Free)
         }
 
         #[pymethod(name = "is_namespace")]
diff --git a/vm/src/types.rs b/vm/src/types.rs
index 834a9e01d8..a810107819 100644
--- a/vm/src/types.rs
+++ b/vm/src/types.rs
@@ -54,6 +54,7 @@ pub struct TypeZoo {
     pub bytearray_iterator_type: PyTypeRef,
     pub bool_type: PyTypeRef,
     pub callable_iterator: PyTypeRef,
+    pub cell_type: PyTypeRef,
     pub classmethod_type: PyTypeRef,
     pub code_type: PyTypeRef,
     pub coroutine_type: PyTypeRef,
@@ -159,6 +160,7 @@ impl TypeZoo {
             bytearray_iterator_type: bytearray::PyByteArrayIterator::init_bare_type().clone(),
             bytes_iterator_type: bytes::PyBytesIterator::init_bare_type().clone(),
             callable_iterator: iter::PyCallableIterator::init_bare_type().clone(),
+            cell_type: function::PyCell::init_bare_type().clone(),
             code_type: code::PyCode::init_bare_type().clone(),
             coroutine_type: coroutine::PyCoroutine::init_bare_type().clone(),
             coroutine_wrapper_type: coroutine::PyCoroutineWrapper::init_bare_type().clone(),
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
index ce1baf5a87..b6e2f97db6 100644
--- a/vm/src/vm.rs
+++ b/vm/src/vm.rs
@@ -448,7 +448,8 @@ impl VirtualMachine {
     }
 
     pub fn run_code_obj(&self, code: PyCodeRef, scope: Scope) -> PyResult {
-        let frame = Frame::new(code, scope, self).into_ref(self);
+        let frame =
+            Frame::new(code, scope, self.builtins.dict().unwrap(), &[], self).into_ref(self);
         self.run_frame_full(frame)
     }
 
@@ -495,11 +496,17 @@ impl VirtualMachine {
         }
     }
 
-    pub fn current_scope(&self) -> Ref<Scope> {
+    pub fn current_locals(&self) -> PyResult<PyDictRef> {
+        self.current_frame()
+            .expect("called current_locals but no frames on the stack")
+            .locals(self)
+    }
+
+    pub fn current_globals(&self) -> Ref<PyDictRef> {
         let frame = self
             .current_frame()
-            .expect("called current_scope but no frames on the stack");
-        Ref::map(frame, |f| &f.scope)
+            .expect("called current_globals but no frames on the stack");
+        Ref::map(frame, |f| &f.globals)
     }
 
     pub fn try_class(&self, module: &str, class: &str) -> PyResult<PyTypeRef> {
@@ -794,10 +801,6 @@ impl VirtualMachine {
         obj.unwrap_or_else(|| self.ctx.none())
     }
 
-    pub fn get_locals(&self) -> PyDictRef {
-        self.current_scope().get_locals().clone()
-    }
-
     // Container of the virtual machine state:
     pub fn to_str(&self, obj: &PyObjectRef) -> PyResult<PyStrRef> {
         if obj.class().is(&self.ctx.types.str_type) {
@@ -872,12 +875,9 @@ impl VirtualMachine {
                     })?;
 
                 let (locals, globals) = if let Some(frame) = self.current_frame() {
-                    (
-                        frame.scope.get_locals().clone().into_object(),
-                        frame.scope.globals.clone().into_object(),
-                    )
+                    (Some(frame.locals.clone()), Some(frame.globals.clone()))
                 } else {
-                    (self.ctx.none(), self.ctx.none())
+                    (None, None)
                 };
                 let from_list = self
                     .ctx
@@ -971,38 +971,44 @@ impl VirtualMachine {
     }
 
     /// Call registered trace function.
+    #[inline]
     fn trace_event(&self, event: TraceEvent) -> PyResult<()> {
         if self.use_tracing.get() {
-            let trace_func = self.trace_func.borrow().clone();
-            let profile_func = self.profile_func.borrow().clone();
-            if self.is_none(&trace_func) && self.is_none(&profile_func) {
-                return Ok(());
-            }
+            self._trace_event_inner(event)
+        } else {
+            Ok(())
+        }
+    }
+    fn _trace_event_inner(&self, event: TraceEvent) -> PyResult<()> {
+        let trace_func = self.trace_func.borrow().clone();
+        let profile_func = self.profile_func.borrow().clone();
+        if self.is_none(&trace_func) && self.is_none(&profile_func) {
+            return Ok(());
+        }
 
-            let frame_ref = self.current_frame();
-            if frame_ref.is_none() {
-                return Ok(());
-            }
+        let frame_ref = self.current_frame();
+        if frame_ref.is_none() {
+            return Ok(());
+        }
 
-            let frame = frame_ref.unwrap().as_object().clone();
-            let event = self.ctx.new_str(event.to_string());
-            let args = vec![frame, event, self.ctx.none()];
-
-            // temporarily disable tracing, during the call to the
-            // tracing function itself.
-            if !self.is_none(&trace_func) {
-                self.use_tracing.set(false);
-                let res = self.invoke(&trace_func, args.clone());
-                self.use_tracing.set(true);
-                res?;
-            }
+        let frame = frame_ref.unwrap().as_object().clone();
+        let event = self.ctx.new_str(event.to_string());
+        let args = vec![frame, event, self.ctx.none()];
+
+        // temporarily disable tracing, during the call to the
+        // tracing function itself.
+        if !self.is_none(&trace_func) {
+            self.use_tracing.set(false);
+            let res = self.invoke(&trace_func, args.clone());
+            self.use_tracing.set(true);
+            res?;
+        }
 
-            if !self.is_none(&profile_func) {
-                self.use_tracing.set(false);
-                let res = self.invoke(&profile_func, args);
-                self.use_tracing.set(true);
-                res?;
-            }
+        if !self.is_none(&profile_func) {
+            self.use_tracing.set(false);
+            let res = self.invoke(&profile_func, args);
+            self.use_tracing.set(true);
+            res?;
         }
         Ok(())
     }
diff --git a/wasm/lib/src/vm_class.rs b/wasm/lib/src/vm_class.rs
index 35fc59f130..edb62ff2a1 100644
--- a/wasm/lib/src/vm_class.rs
+++ b/wasm/lib/src/vm_class.rs
@@ -17,7 +17,7 @@ use crate::wasm_builtins;
 
 pub(crate) struct StoredVirtualMachine {
     pub interp: Interpreter,
-    pub scope: RefCell<Scope>,
+    pub scope: Scope,
     /// you can put a Rc in here, keep it as a Weak, and it'll be held only for
     /// as long as the StoredVM is alive
     held_objects: RefCell<Vec<PyObjectRef>>,
@@ -47,7 +47,7 @@ impl StoredVirtualMachine {
 
         StoredVirtualMachine {
             interp,
-            scope: RefCell::new(scope.unwrap()),
+            scope: scope.unwrap(),
             held_objects: RefCell::new(Vec::new()),
         }
     }
@@ -203,8 +203,8 @@ impl WASMVirtualMachine {
     pub fn add_to_scope(&self, name: String, value: JsValue) -> Result<(), JsValue> {
         self.with_vm(move |vm, StoredVirtualMachine { ref scope, .. }| {
             let value = convert::js_to_py(vm, value);
-            scope.borrow_mut().store_name(&vm, name.as_str(), value);
-        })
+            scope.globals.set_item(name, value, vm).to_js(vm)
+        })?
     }
 
     #[wasm_bindgen(js_name = setStdout)]
@@ -264,7 +264,7 @@ impl WASMVirtualMachine {
                 }
             }
 
-            vm.run_code_obj(code, Scope::new(None, attrs.clone(), vm))
+            vm.run_code_obj(code, Scope::new(None, attrs.clone()))
                 .to_js(vm)?;
 
             let module = vm.new_module(&name, attrs);
@@ -309,7 +309,7 @@ impl WASMVirtualMachine {
             let source_path = source_path.unwrap_or_else(|| "<wasm>".to_owned());
             let code = vm.compile(source, mode, source_path);
             let code = code.map_err(convert::syntax_err)?;
-            let result = vm.run_code_obj(code, scope.borrow().clone());
+            let result = vm.run_code_obj(code, scope.clone());
             convert::pyresult_to_jsresult(vm, result)
         })?
     }