diff --git a/codeGenTargets/src/prog8/codegen/target/C128Target.kt b/codeGenTargets/src/prog8/codegen/target/C128Target.kt
index b1f8359eb..82248d270 100644
--- a/codeGenTargets/src/prog8/codegen/target/C128Target.kt
+++ b/codeGenTargets/src/prog8/codegen/target/C128Target.kt
@@ -12,10 +12,14 @@ import prog8.compilerinterface.IMemSizer
 import prog8.compilerinterface.IStringEncoding
 
 
-object C128Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
-    override val name = "c128"
+class C128Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+    override val name = NAME
     override val machine = C128MachineDefinition()
 
+    companion object {
+        const val NAME = "c128"
+    }
+
     override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
         asmsub6502ArgsEvalOrder(sub)
     override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
diff --git a/codeGenTargets/src/prog8/codegen/target/C64Target.kt b/codeGenTargets/src/prog8/codegen/target/C64Target.kt
index ed6747ee9..af891085c 100644
--- a/codeGenTargets/src/prog8/codegen/target/C64Target.kt
+++ b/codeGenTargets/src/prog8/codegen/target/C64Target.kt
@@ -12,10 +12,14 @@ import prog8.compilerinterface.IMemSizer
 import prog8.compilerinterface.IStringEncoding
 
 
-object C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
-    override val name = "c64"
+class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+    override val name = NAME
     override val machine = C64MachineDefinition()
 
+    companion object {
+        const val NAME = "c64"
+    }
+
     override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
         asmsub6502ArgsEvalOrder(sub)
     override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
diff --git a/codeGenTargets/src/prog8/codegen/target/Cx16Target.kt b/codeGenTargets/src/prog8/codegen/target/Cx16Target.kt
index 8995a1796..38c38a9fd 100644
--- a/codeGenTargets/src/prog8/codegen/target/Cx16Target.kt
+++ b/codeGenTargets/src/prog8/codegen/target/Cx16Target.kt
@@ -12,10 +12,14 @@ import prog8.compilerinterface.IMemSizer
 import prog8.compilerinterface.IStringEncoding
 
 
-object Cx16Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
-    override val name = "cx16"
+class Cx16Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+    override val name = NAME
     override val machine = CX16MachineDefinition()
 
+    companion object {
+        const val NAME = "cx16"
+    }
+
     override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
         asmsub6502ArgsEvalOrder(sub)
     override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
diff --git a/compiler/src/prog8/CompilerMain.kt b/compiler/src/prog8/CompilerMain.kt
index 8288aa7fd..1ac676e56 100644
--- a/compiler/src/prog8/CompilerMain.kt
+++ b/compiler/src/prog8/CompilerMain.kt
@@ -44,7 +44,7 @@ private fun compileMain(args: Array<String>): Boolean {
     val quietAssembler by cli.option(ArgType.Boolean, fullName = "quietasm", description = "don't print assembler output results")
     val asmListfile by cli.option(ArgType.Boolean, fullName = "asmlist", description = "make the assembler produce a listing file as well")
     val experimentalCodegen by cli.option(ArgType.Boolean, fullName = "expericodegen", description = "use experimental codegen")
-    val compilationTarget by cli.option(ArgType.String, fullName = "target", description = "target output of the compiler (one of '${C64Target.name}', '${C128Target.name}', '${Cx16Target.name}')").default(C64Target.name)
+    val compilationTarget by cli.option(ArgType.String, fullName = "target", description = "target output of the compiler (one of '${C64Target.NAME}', '${C128Target.NAME}', '${Cx16Target.NAME}')").default(C64Target.NAME)
     val sourceDirs by cli.option(ArgType.String, fullName="srcdirs", description = "list of extra paths, separated with ${File.pathSeparator}, to search in for imported modules").multiple().delimiter(File.pathSeparator)
     val moduleFiles by cli.argument(ArgType.String, fullName = "modules", description = "main module file(s) to compile").multiple(999)
 
@@ -71,7 +71,7 @@ private fun compileMain(args: Array<String>): Boolean {
     if(srcdirs.firstOrNull()!=".")
         srcdirs.add(0, ".")
 
-    if (compilationTarget !in setOf(C64Target.name, C128Target.name, Cx16Target.name)) {
+    if (compilationTarget !in setOf(C64Target.NAME, C128Target.NAME, Cx16Target.NAME)) {
         System.err.println("Invalid compilation target: $compilationTarget")
         return false
     }
diff --git a/compiler/src/prog8/compiler/Compiler.kt b/compiler/src/prog8/compiler/Compiler.kt
index c7d158ae9..4bca1373c 100644
--- a/compiler/src/prog8/compiler/Compiler.kt
+++ b/compiler/src/prog8/compiler/Compiler.kt
@@ -54,9 +54,9 @@ fun compileProgram(args: CompilerArguments): CompilationResult {
 
     val compTarget =
         when(args.compilationTarget) {
-            C64Target.name -> C64Target
-            C128Target.name -> C128Target
-            Cx16Target.name -> Cx16Target
+            C64Target.NAME -> C64Target()
+            C128Target.NAME -> C128Target()
+            Cx16Target.NAME -> Cx16Target()
             else -> throw IllegalArgumentException("invalid compilation target")
         }
 
@@ -233,7 +233,7 @@ fun determineCompilationOptions(program: Program, compTarget: ICompilationTarget
                 // error will be printed by the astchecker
             }
 
-    if (zpType == ZeropageType.FLOATSAFE && compTarget.name == Cx16Target.name) {
+    if (zpType == ZeropageType.FLOATSAFE && compTarget.name == Cx16Target.NAME) {
         System.err.println("Warning: zp option floatsafe changed to basicsafe for cx16 target")
         zpType = ZeropageType.BASICSAFE
     }
diff --git a/compiler/test/TestAstChecks.kt b/compiler/test/TestAstChecks.kt
index 18a0fc2df..46a99b19c 100644
--- a/compiler/test/TestAstChecks.kt
+++ b/compiler/test/TestAstChecks.kt
@@ -25,7 +25,7 @@ class TestAstChecks: FunSpec({
             }
         """
         val errors = ErrorReporterForTests(keepMessagesAfterReporting = true)
-        compileText(C64Target, true, text, writeAssembly = true, errors=errors).assertSuccess()
+        compileText(C64Target(), true, text, writeAssembly = true, errors=errors).assertSuccess()
         errors.errors.size shouldBe 0
         errors.warnings.size shouldBe 2
         errors.warnings[0] shouldContain "converted to float"
@@ -50,7 +50,7 @@ class TestAstChecks: FunSpec({
             }
             """
         val errors = ErrorReporterForTests()
-        compileText(C64Target, true, text, writeAssembly = true, errors=errors).assertFailure()
+        compileText(C64Target(), true, text, writeAssembly = true, errors=errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.warnings.size shouldBe 0
         errors.errors[0] shouldContain ":7:28) assignment value is invalid"
@@ -73,7 +73,7 @@ class TestAstChecks: FunSpec({
             }
             """
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = false, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = false, errors=errors).assertFailure()
         errors.errors.filter { it.contains("missing &") }.size shouldBe 4
     }
 
@@ -95,6 +95,6 @@ class TestAstChecks: FunSpec({
                 }
             }
             """
-        compileText(C64Target, false, text, writeAssembly = false).assertSuccess()
+        compileText(C64Target(), false, text, writeAssembly = false).assertSuccess()
     }
 })
diff --git a/compiler/test/TestCallgraph.kt b/compiler/test/TestCallgraph.kt
index f6c8ba393..9593eb283 100644
--- a/compiler/test/TestCallgraph.kt
+++ b/compiler/test/TestCallgraph.kt
@@ -26,7 +26,7 @@ class TestCallgraph: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, sourcecode).assertSuccess()
+        val result = compileText(C64Target(), false, sourcecode).assertSuccess()
         val graph = CallGraph(result.program)
 
         graph.imports.size shouldBe 1
@@ -67,7 +67,7 @@ class TestCallgraph: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, sourcecode).assertSuccess()
+        val result = compileText(C64Target(), false, sourcecode).assertSuccess()
         val graph = CallGraph(result.program)
 
         graph.imports.size shouldBe 1
@@ -110,7 +110,7 @@ class TestCallgraph: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, sourcecode).assertSuccess()
+        val result = compileText(C64Target(), false, sourcecode).assertSuccess()
         val graph = CallGraph(result.program)
         graph.allIdentifiers.size shouldBeGreaterThanOrEqual 9
         val empties = graph.allIdentifiers.keys.filter { it.nameInSource==listOf("empty") }
diff --git a/compiler/test/TestCompilerOnCharLit.kt b/compiler/test/TestCompilerOnCharLit.kt
index 75c655358..e3855f96d 100644
--- a/compiler/test/TestCompilerOnCharLit.kt
+++ b/compiler/test/TestCompilerOnCharLit.kt
@@ -24,7 +24,7 @@ import prog8tests.helpers.compileText
 class TestCompilerOnCharLit: FunSpec({
 
     test("testCharLitAsRomsubArg") {
-        val platform = Cx16Target
+        val platform = Cx16Target()
         val result = compileText(platform, false, """
             main {
                 romsub ${"$"}FFD2 = chrout(ubyte ch @ A)
@@ -47,7 +47,7 @@ class TestCompilerOnCharLit: FunSpec({
     }
 
     test("testCharVarAsRomsubArg") {
-        val platform = Cx16Target
+        val platform = Cx16Target()
         val result = compileText(platform, false, """
             main {
                 romsub ${"$"}FFD2 = chrout(ubyte ch @ A)
@@ -87,7 +87,7 @@ class TestCompilerOnCharLit: FunSpec({
     }
 
     test("testCharConstAsRomsubArg") {
-        val platform = Cx16Target
+        val platform = Cx16Target()
         val result = compileText(platform, false, """
             main {
                 romsub ${"$"}FFD2 = chrout(ubyte ch @ A)
diff --git a/compiler/test/TestCompilerOnExamples.kt b/compiler/test/TestCompilerOnExamples.kt
index 0d342a88d..f509446b9 100644
--- a/compiler/test/TestCompilerOnExamples.kt
+++ b/compiler/test/TestCompilerOnExamples.kt
@@ -40,7 +40,7 @@ private fun compileTheThing(filepath: Path, optimize: Boolean, target: ICompilat
 
 private fun prepareTestFiles(source: String, optimize: Boolean, target: ICompilationTarget): Pair<String, Path> {
     val searchIn = mutableListOf(examplesDir)
-    if (target == Cx16Target) {
+    if (target is Cx16Target) {
         searchIn.add(0, assumeDirectory(examplesDir, "cx16"))
     }
     val filepath = searchIn.asSequence()
@@ -72,9 +72,10 @@ class TestCompilerOnExamplesC64: FunSpec({
 
     onlyC64.forEach {
         val (source, optimize) = it
-        val (displayName, filepath) = prepareTestFiles(source, optimize, C64Target)
+        val target = C64Target()
+        val (displayName, filepath) = prepareTestFiles(source, optimize, target)
         test(displayName) {
-            compileTheThing(filepath, optimize, C64Target).assertSuccess()
+            compileTheThing(filepath, optimize, target).assertSuccess()
         }
     }
 })
@@ -103,9 +104,10 @@ class TestCompilerOnExamplesCx16: FunSpec({
 
     onlyCx16.forEach {
         val (source, optimize) = it
-        val (displayName, filepath) = prepareTestFiles(source, optimize, Cx16Target)
+        val target = Cx16Target()
+        val (displayName, filepath) = prepareTestFiles(source, optimize, target)
         test(displayName) {
-            compileTheThing(filepath, optimize, Cx16Target).assertSuccess()
+            compileTheThing(filepath, optimize, target).assertSuccess()
         }
     }
 })
@@ -141,13 +143,15 @@ class TestCompilerOnExamplesBothC64andCx16: FunSpec({
 
     bothCx16AndC64.forEach {
         val (source, optimize) = it
-        val (displayNameC64, filepathC64) = prepareTestFiles(source, optimize, C64Target)
-        val (displayNameCx16, filepathCx16) = prepareTestFiles(source, optimize, Cx16Target)
+        val c64target = C64Target()
+        val cx16target = Cx16Target()
+        val (displayNameC64, filepathC64) = prepareTestFiles(source, optimize, c64target)
+        val (displayNameCx16, filepathCx16) = prepareTestFiles(source, optimize, cx16target)
         test(displayNameC64) {
-            compileTheThing(filepathC64, optimize, C64Target).assertSuccess()
+            compileTheThing(filepathC64, optimize, c64target).assertSuccess()
         }
         test(displayNameCx16) {
-            compileTheThing(filepathCx16, optimize, Cx16Target).assertSuccess()
+            compileTheThing(filepathCx16, optimize, cx16target).assertSuccess()
         }
     }
 })
diff --git a/compiler/test/TestCompilerOnImportsAndIncludes.kt b/compiler/test/TestCompilerOnImportsAndIncludes.kt
index d8a77a7fc..a5b522f8c 100644
--- a/compiler/test/TestCompilerOnImportsAndIncludes.kt
+++ b/compiler/test/TestCompilerOnImportsAndIncludes.kt
@@ -27,7 +27,7 @@ class TestCompilerOnImportsAndIncludes: FunSpec({
             val filepath = assumeReadableFile(fixturesDir, "importFromSameFolder.p8")
             assumeReadableFile(fixturesDir, "foo_bar.p8")
 
-            val platform = Cx16Target
+            val platform = Cx16Target()
             val result = compileFile(platform, optimize = false, fixturesDir, filepath.name)
                 .assertSuccess()
 
@@ -50,7 +50,7 @@ class TestCompilerOnImportsAndIncludes: FunSpec({
             val filepath = assumeReadableFile(fixturesDir, "asmIncludeFromSameFolder.p8")
             assumeReadableFile(fixturesDir, "foo_bar.asm")
 
-            val platform = Cx16Target
+            val platform = Cx16Target()
             val result = compileFile(platform, optimize = false, fixturesDir, filepath.name)
                 .assertSuccess()
 
@@ -76,7 +76,7 @@ class TestCompilerOnImportsAndIncludes: FunSpec({
             val p8Path = assumeReadableFile(fixturesDir, "asmBinaryNonExisting.p8")
             assumeNotExists(fixturesDir, "i_do_not_exist.bin")
 
-            compileFile(Cx16Target, false, p8Path.parent, p8Path.name, outputDir)
+            compileFile(Cx16Target(), false, p8Path.parent, p8Path.name, outputDir)
                 .assertFailure()
         }
 
@@ -84,7 +84,7 @@ class TestCompilerOnImportsAndIncludes: FunSpec({
             val p8Path = assumeReadableFile(fixturesDir, "asmBinaryNonReadable.p8")
             assumeDirectory(fixturesDir, "subFolder")
 
-            compileFile(Cx16Target, false, p8Path.parent, p8Path.name, outputDir)
+            compileFile(Cx16Target(), false, p8Path.parent, p8Path.name, outputDir)
                 .assertFailure()
         }
 
@@ -104,7 +104,7 @@ class TestCompilerOnImportsAndIncludes: FunSpec({
                     outputDir.normalize().toAbsolutePath() shouldNotBe workingDir.normalize().toAbsolutePath()
                 }
 
-                compileFile(Cx16Target, false, p8Path.parent, p8Path.name, outputDir)
+                compileFile(Cx16Target(), false, p8Path.parent, p8Path.name, outputDir)
                     .assertSuccess(
                         "argument to assembler directive .binary " +
                                 "should be relative to the generated .asm file (in output dir), " +
diff --git a/compiler/test/TestCompilerOnRanges.kt b/compiler/test/TestCompilerOnRanges.kt
index b5ebe713c..b7aced439 100644
--- a/compiler/test/TestCompilerOnRanges.kt
+++ b/compiler/test/TestCompilerOnRanges.kt
@@ -27,7 +27,7 @@ import prog8tests.helpers.*
 class TestCompilerOnRanges: FunSpec({
 
     test("testUByteArrayInitializerWithRange_char_to_char") {
-        val platform = Cx16Target
+        val platform = Cx16Target()
         val result = compileText(platform, false, """
             main {
                 sub start() {
@@ -58,7 +58,7 @@ class TestCompilerOnRanges: FunSpec({
     }
 
     test("testFloatArrayInitializerWithRange_char_to_char") {
-        val platform = C64Target
+        val platform = C64Target()
         val result = compileText(platform, optimize = false, """
             %import floats
             main {
@@ -93,7 +93,7 @@ class TestCompilerOnRanges: FunSpec({
         val combos = cartesianProduct(
             listOf("", "42", "41"),                 // sizeInDecl
             listOf("%import floats", ""),           // optEnableFloats
-            listOf(Cx16Target, C64Target),          // platform
+            listOf(Cx16Target(), C64Target()),          // platform
             listOf(false, true)                     // optimize
         )
 
@@ -128,7 +128,7 @@ class TestCompilerOnRanges: FunSpec({
     }
 
     test("testForLoopWithRange_char_to_char") {
-        val platform = Cx16Target
+        val platform = Cx16Target()
         val result = compileText(platform, optimize = true, """
             main {
                 sub start() {
@@ -162,7 +162,7 @@ class TestCompilerOnRanges: FunSpec({
     }
 
     test("testForLoopWithRange_bool_to_bool") {
-        val platform = Cx16Target
+        val platform = Cx16Target()
         val result = compileText(platform, optimize = true, """
             main {
                 sub start() {
@@ -188,7 +188,7 @@ class TestCompilerOnRanges: FunSpec({
     }
 
     test("testForLoopWithRange_ubyte_to_ubyte") {
-        val platform = Cx16Target
+        val platform = Cx16Target()
         val result = compileText(platform, optimize = true, """
             main {
                 sub start() {
@@ -215,7 +215,7 @@ class TestCompilerOnRanges: FunSpec({
 
     test("testForLoopWithRange_str_downto_str") {
         val errors = ErrorReporterForTests()
-        compileText(Cx16Target, true, """
+        compileText(Cx16Target(), true, """
             main {
                 sub start() {
                     ubyte i
@@ -231,7 +231,7 @@ class TestCompilerOnRanges: FunSpec({
     }
 
     test("testForLoopWithIterable_str") {
-        val result = compileText(Cx16Target, false, """
+        val result = compileText(Cx16Target(), false, """
             main {
                 sub start() {
                     ubyte i
@@ -263,7 +263,7 @@ class TestCompilerOnRanges: FunSpec({
     }
 
     test("range with negative step should be constvalue") {
-        val result = compileText(C64Target, false, """
+        val result = compileText(C64Target(), false, """
             main {
                 sub start() {
                     ubyte[] array = 100 to 50 step -2
@@ -283,7 +283,7 @@ class TestCompilerOnRanges: FunSpec({
     }
 
     test("range with start/end variables should be ok") {
-        val result = compileText(C64Target, false, """
+        val result = compileText(C64Target(), false, """
             main {
                 sub start() {
                     byte from = 100
@@ -302,7 +302,7 @@ class TestCompilerOnRanges: FunSpec({
 
 
     test("for statement on all possible iterable expressions") {
-        compileText(C64Target, false, """
+        compileText(C64Target(), false, """
             main {
                 sub start() {
                     ubyte xx
@@ -343,7 +343,7 @@ class TestCompilerOnRanges: FunSpec({
     }
 
     test("if containment check on all possible iterable expressions") {
-        compileText(C64Target, false, """
+        compileText(C64Target(), false, """
             main {
                 sub start() {
                     ubyte xx
@@ -404,7 +404,7 @@ class TestCompilerOnRanges: FunSpec({
     }
 
     test("containment check in expressions") {
-        compileText(C64Target, false, """
+        compileText(C64Target(), false, """
             main {
                 sub start() {
                     ubyte xx
diff --git a/compiler/test/TestCompilerOptionLibdirs.kt b/compiler/test/TestCompilerOptionLibdirs.kt
index 3a93a9a6a..8c6e80463 100644
--- a/compiler/test/TestCompilerOptionLibdirs.kt
+++ b/compiler/test/TestCompilerOptionLibdirs.kt
@@ -46,7 +46,7 @@ class TestCompilerOptionSourcedirs: FunSpec({
             quietAssembler = true,
             asmListfile = false,
             experimentalCodegen = false,
-            compilationTarget = Cx16Target.name,
+            compilationTarget = Cx16Target.NAME,
             sourceDirs,
             outputDir
         )
diff --git a/compiler/test/TestImportedModulesOrderAndOptions.kt b/compiler/test/TestImportedModulesOrderAndOptions.kt
index e468c6828..eebf16846 100644
--- a/compiler/test/TestImportedModulesOrderAndOptions.kt
+++ b/compiler/test/TestImportedModulesOrderAndOptions.kt
@@ -18,7 +18,7 @@ import prog8tests.helpers.outputDir
 class TestImportedModulesOrderAndOptions: FunSpec({
 
     test("testImportedModuleOrderAndMainModuleCorrect") {
-        val result = compileText(C64Target, false, """
+        val result = compileText(C64Target(), false, """
 %import textio
 %import floats
 
@@ -49,7 +49,7 @@ main {
     }
 
     test("testCompilationOptionsCorrectFromMain") {
-        val result = compileText(C64Target, false, """
+        val result = compileText(C64Target(), false, """
 %import textio
 %import floats
 %zeropage dontuse
@@ -62,7 +62,7 @@ main {
 }
 """).assertSuccess()
         result.program.toplevelModule.name shouldStartWith "on_the_fly_test"
-        val options = determineCompilationOptions(result.program, C64Target)
+        val options = determineCompilationOptions(result.program, C64Target())
         options.floats shouldBe true
         options.zeropage shouldBe ZeropageType.DONTUSE
         options.noSysInit shouldBe true
@@ -85,7 +85,7 @@ main {
         val filenameBase = "on_the_fly_test_" + sourceText.hashCode().toUInt().toString(16)
         val filepath = outputDir.resolve("$filenameBase.p8")
         filepath.toFile().writeText(sourceText)
-        val (program, options, importedfiles) = parseImports(filepath, errors, C64Target, emptyList())
+        val (program, options, importedfiles) = parseImports(filepath, errors, C64Target(), emptyList())
 
         program.toplevelModule.name shouldBe filenameBase
         withClue("all imports other than the test source must have been internal resources library files") {
diff --git a/compiler/test/TestMemory.kt b/compiler/test/TestMemory.kt
index 4253bbaa9..f6f19d122 100644
--- a/compiler/test/TestMemory.kt
+++ b/compiler/test/TestMemory.kt
@@ -21,6 +21,8 @@ import prog8tests.helpers.*
 
 class TestMemory: FunSpec({
 
+    val c64target = C64Target()
+
     fun wrapWithProgram(statements: List<Statement>): Program {
         val program = Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
         val subroutine = Subroutine("test", mutableListOf(), emptyList(), statements.toMutableList(), false, Position.DUMMY)
@@ -35,49 +37,49 @@ class TestMemory: FunSpec({
         var target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         var assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0x1000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0x9fff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0xa000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0xc000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0xcfff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0xeeee, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
 
         memexpr = NumericLiteralValue.optimalInteger(0xffff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
     }
 
     test("assign target in mapped IO space C64") {
@@ -86,25 +88,25 @@ class TestMemory: FunSpec({
         var target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         var assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe true
+        target.isIOAddress(c64target.machine) shouldBe true
 
         memexpr = NumericLiteralValue.optimalInteger(0x0001, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe true
+        target.isIOAddress(c64target.machine) shouldBe true
 
         memexpr = NumericLiteralValue.optimalInteger(0xd000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe true
+        target.isIOAddress(c64target.machine) shouldBe true
 
         memexpr = NumericLiteralValue.optimalInteger(0xdfff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe true
+        target.isIOAddress(c64target.machine) shouldBe true
     }
 
     fun createTestProgramForMemoryRefViaVar(address: UInt, vartype: VarDeclType): AssignTarget {
@@ -118,17 +120,17 @@ class TestMemory: FunSpec({
 
     test("identifier mapped to IO memory on C64") {
         var target = createTestProgramForMemoryRefViaVar(0x1000u, VarDeclType.VAR)
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
         target = createTestProgramForMemoryRefViaVar(0xd020u, VarDeclType.VAR)
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
         target = createTestProgramForMemoryRefViaVar(0x1000u, VarDeclType.CONST)
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
         target = createTestProgramForMemoryRefViaVar(0xd020u, VarDeclType.CONST)
-        target.isIOAddress(C64Target.machine) shouldBe true
+        target.isIOAddress(c64target.machine) shouldBe true
         target = createTestProgramForMemoryRefViaVar(0x1000u, VarDeclType.MEMORY)
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
         target = createTestProgramForMemoryRefViaVar(0xd020u, VarDeclType.MEMORY)
-        target.isIOAddress(C64Target.machine) shouldBe true
+        target.isIOAddress(c64target.machine) shouldBe true
     }
 
     test("memory expression mapped to IO memory on C64") {
@@ -136,14 +138,14 @@ class TestMemory: FunSpec({
         var target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         var assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
 
         memexpr = PrefixExpression("+", NumericLiteralValue.optimalInteger(0xd020, Position.DUMMY), Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         assign = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), AssignmentOrigin.USERCODE, Position.DUMMY)
         wrapWithProgram(listOf(assign))
         printProgram(target.definingModule.program)
-        target.isIOAddress(C64Target.machine) shouldBe true
+        target.isIOAddress(c64target.machine) shouldBe true
     }
 
     test("regular variable not in mapped IO ram on C64") {
@@ -154,7 +156,7 @@ class TestMemory: FunSpec({
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
             .addModule(module)
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
     }
 
     test("memory mapped variable not in mapped IO ram on C64") {
@@ -166,7 +168,7 @@ class TestMemory: FunSpec({
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
             .addModule(module)
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
     }
 
     test("memory mapped variable in mapped IO ram on C64") {
@@ -178,7 +180,7 @@ class TestMemory: FunSpec({
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
             .addModule(module)
-        target.isIOAddress(C64Target.machine) shouldBe true
+        target.isIOAddress(c64target.machine) shouldBe true
     }
 
     test("array not in mapped IO ram") {
@@ -190,7 +192,7 @@ class TestMemory: FunSpec({
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
             .addModule(module)
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
     }
 
     test("memory mapped array not in mapped IO ram") {
@@ -203,7 +205,7 @@ class TestMemory: FunSpec({
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
             .addModule(module)
-        target.isIOAddress(C64Target.machine) shouldBe false
+        target.isIOAddress(c64target.machine) shouldBe false
     }
 
     test("memory mapped array in mapped IO ram") {
@@ -216,12 +218,12 @@ class TestMemory: FunSpec({
         val module = Module(mutableListOf(subroutine), Position.DUMMY, SourceCode.Generated("test"))
         Program("test", DummyFunctions, DummyMemsizer, DummyStringEncoder)
             .addModule(module)
-        target.isIOAddress(C64Target.machine) shouldBe true
+        target.isIOAddress(c64target.machine) shouldBe true
     }
 
 
     test("memory() with spaces in name works") {
-        compileText(C64Target, false, """
+        compileText(C64Target(), false, """
             main {
                 sub start() {
                     uword @shared mem = memory("a b c", 100, $100)
@@ -231,7 +233,7 @@ class TestMemory: FunSpec({
     }
 
     test("memory() with invalid argument") {
-        compileText(C64Target, false, """
+        compileText(C64Target(), false, """
             main {
                 sub start() {
                     uword @shared mem1 = memory("abc", 100, -2)
diff --git a/compiler/test/TestNumbers.kt b/compiler/test/TestNumbers.kt
index 1b5334476..319d8c08e 100644
--- a/compiler/test/TestNumbers.kt
+++ b/compiler/test/TestNumbers.kt
@@ -126,7 +126,7 @@ class TestNumbers: FunSpec({
             }
         """
         val errors = ErrorReporterForTests(keepMessagesAfterReporting = true)
-        compileText(C64Target, true, src, writeAssembly = false, errors=errors).assertSuccess()
+        compileText(C64Target(), true, src, writeAssembly = false, errors=errors).assertSuccess()
         errors.errors.size shouldBe 0
         errors.warnings.size shouldBe 2
         errors.warnings[0] shouldContain "converted to float"
@@ -146,7 +146,7 @@ class TestNumbers: FunSpec({
             }
         """
         val errors = ErrorReporterForTests()
-        compileText(C64Target, true, src, writeAssembly = false, errors=errors).assertFailure()
+        compileText(C64Target(), true, src, writeAssembly = false, errors=errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.warnings.size shouldBe 0
         errors.errors[0] shouldContain "converted to float"
@@ -163,7 +163,7 @@ class TestNumbers: FunSpec({
             }
         """
         val errors = ErrorReporterForTests()
-        compileText(C64Target, true, src, writeAssembly = false, errors=errors).assertFailure()
+        compileText(C64Target(), true, src, writeAssembly = false, errors=errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.warnings.size shouldBe 0
         errors.errors[0] shouldContain "out of range"
@@ -179,6 +179,6 @@ class TestNumbers: FunSpec({
                 }
             }
         """
-        compileText(C64Target, true, src, writeAssembly = false).assertSuccess()
+        compileText(C64Target(), true, src, writeAssembly = false).assertSuccess()
     }
 })
diff --git a/compiler/test/TestOptimization.kt b/compiler/test/TestOptimization.kt
index ebcd43b57..aeb099cdf 100644
--- a/compiler/test/TestOptimization.kt
+++ b/compiler/test/TestOptimization.kt
@@ -35,7 +35,7 @@ class TestOptimization: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, true, sourcecode).assertSuccess()
+        val result = compileText(C64Target(), true, sourcecode).assertSuccess()
         val toplevelModule = result.program.toplevelModule
         val mainBlock = toplevelModule.statements.single() as Block
         val startSub = mainBlock.statements.single() as Subroutine
@@ -60,7 +60,7 @@ class TestOptimization: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, true, sourcecode).assertSuccess()
+        val result = compileText(C64Target(), true, sourcecode).assertSuccess()
         val toplevelModule = result.program.toplevelModule
         val mainBlock = toplevelModule.statements.single() as Block
         val startSub = mainBlock.statements[0] as Subroutine
@@ -119,7 +119,7 @@ class TestOptimization: FunSpec({
                     cx16.r7s = llw - 900 + 999
                 }
             }"""
-        val result = compileText(C64Target, true, source, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), true, source, writeAssembly = false).assertSuccess()
         // expected:
 //        uword load_location
 //        load_location = 12345
@@ -172,7 +172,7 @@ class TestOptimization: FunSpec({
                     cx16.r4s = llw * 90 / 5     ; not optimized because of loss of integer division precision
                 }
             }"""
-        val result = compileText(C64Target, true, source, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), true, source, writeAssembly = false).assertSuccess()
         printProgram(result.program)
         // expected:
 //        word llw
@@ -229,7 +229,7 @@ class TestOptimization: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, sourcecode).assertSuccess()
+        val result = compileText(C64Target(), false, sourcecode).assertSuccess()
         val mainsub = result.program.entrypoint
         mainsub.statements.size shouldBe 10
         val declTest = mainsub.statements[0] as VarDecl
@@ -267,7 +267,7 @@ class TestOptimization: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, src, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), false, src, writeAssembly = false).assertSuccess()
 
         // ww = ((( not bb as uword)  or  not ww) as uword)
         val wwAssign = result.program.entrypoint.statements.last() as Assignment
@@ -288,7 +288,7 @@ class TestOptimization: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, src, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), false, src, writeAssembly = false).assertSuccess()
 
         // bb = (( not bb as uword)  or  not ww)
         val bbAssign = result.program.entrypoint.statements.last() as Assignment
@@ -300,7 +300,7 @@ class TestOptimization: FunSpec({
         expr.right.inferType(result.program).getOrElse { fail("dt") } shouldBe DataType.UWORD
         expr.inferType(result.program).getOrElse { fail("dt") } shouldBe DataType.UBYTE
 
-        val options = CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), false, true, C64Target, outputDir= outputDir)
+        val options = CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), false, true, C64Target(), outputDir= outputDir)
         result.program.processAstBeforeAsmGeneration(options, ErrorReporterForTests())
 
         // assignment is now split into:
@@ -340,7 +340,7 @@ class TestOptimization: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, true, src, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), true, src, writeAssembly = true).assertSuccess()
         /* turned into:
         ubyte r
         r = 0
@@ -376,7 +376,7 @@ class TestOptimization: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, optimize=false, src, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), optimize=false, src, writeAssembly = false).assertSuccess()
         val assignFF = result.program.entrypoint.statements.last() as Assignment
         assignFF.isAugmentable shouldBe true
         assignFF.target.identifier!!.nameInSource shouldBe listOf("ff")
@@ -404,7 +404,7 @@ class TestOptimization: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
+        val result = compileText(C64Target(), optimize=true, src, writeAssembly=false).assertSuccess()
         result.program.entrypoint.statements.size shouldBe 7
         val alldecls = result.program.entrypoint.allDefinedSymbols.toList()
         alldecls.map { it.first } shouldBe listOf("unused_but_shared", "usedvar_only_written", "usedvar")
@@ -427,7 +427,7 @@ class TestOptimization: FunSpec({
                     }
                 }
             }"""
-        val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
+        val result = compileText(C64Target(), optimize=true, src, writeAssembly=false).assertSuccess()
         printProgram(result.program)
         result.program.entrypoint.statements.size shouldBe 3
         val ifstmt = result.program.entrypoint.statements[0] as IfElse
@@ -456,7 +456,7 @@ class TestOptimization: FunSpec({
                     z6 = z1+z6-5
                 }
             }"""
-        val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
+        val result = compileText(C64Target(), optimize=true, src, writeAssembly=false).assertSuccess()
         /* expected:
         ubyte z1
         z1 = 10
@@ -523,7 +523,7 @@ class TestOptimization: FunSpec({
             }
         """
 
-        val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
+        val result = compileText(C64Target(), optimize=true, src, writeAssembly=false).assertSuccess()
         val stmts = result.program.entrypoint.statements
         stmts.size shouldBe 6
         val assign=stmts.last() as Assignment
@@ -540,7 +540,7 @@ class TestOptimization: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
+        val result = compileText(C64Target(), optimize=true, src, writeAssembly=false).assertSuccess()
         val stmts = result.program.entrypoint.statements
         stmts.size shouldBe 6
         val assign=stmts.last() as Assignment
@@ -559,7 +559,7 @@ class TestOptimization: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
+        val result = compileText(C64Target(), optimize=true, src, writeAssembly=false).assertSuccess()
         val stmts = result.program.entrypoint.statements
         stmts.size shouldBe 10
         stmts.filterIsInstance<VarDecl>().size shouldBe 5
@@ -575,7 +575,7 @@ class TestOptimization: FunSpec({
             }
         """
         val errors = ErrorReporterForTests()
-        compileText(C64Target, optimize=true, src, writeAssembly=false, errors = errors).assertFailure()
+        compileText(C64Target(), optimize=true, src, writeAssembly=false, errors = errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.errors[0] shouldContain  "type of value BYTE doesn't match target UBYTE"
         errors.errors[1] shouldContain  "out of range"
@@ -594,7 +594,7 @@ class TestOptimization: FunSpec({
                 q=r
             }
         }"""
-        val result = compileText(C64Target, optimize=false, src, writeAssembly=true).assertSuccess()
+        val result = compileText(C64Target(), optimize=false, src, writeAssembly=true).assertSuccess()
         result.program.entrypoint.statements.size shouldBe 11
         result.program.entrypoint.statements.last() shouldBe instanceOf<Return>()
     }
@@ -612,7 +612,7 @@ class TestOptimization: FunSpec({
             }
         }
         """
-        val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
+        val result = compileText(C64Target(), optimize=true, src, writeAssembly=false).assertSuccess()
         printProgram(result.program)
         /* expected result:
         uword yy
@@ -642,7 +642,7 @@ class TestOptimization: FunSpec({
                 xx = xx+10      ; so this should not be changed into xx=10
             }
         }"""
-        val result = compileText(C64Target, optimize=true, src, writeAssembly=false).assertSuccess()
+        val result = compileText(C64Target(), optimize=true, src, writeAssembly=false).assertSuccess()
         /*
         expected result:
         uword xx
diff --git a/compiler/test/TestPipes.kt b/compiler/test/TestPipes.kt
index daea45175..aaf5b0357 100644
--- a/compiler/test/TestPipes.kt
+++ b/compiler/test/TestPipes.kt
@@ -42,7 +42,7 @@ class TestPipes: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, true, text, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), true, text, writeAssembly = true).assertSuccess()
         val stmts = result.program.entrypoint.statements
         stmts.size shouldBe 3
         val pipef = stmts[0] as Pipe
@@ -76,7 +76,7 @@ class TestPipes: FunSpec({
             }
         """
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, errors=errors).assertFailure()
         errors.errors.size shouldBe 1
         errors.errors[0] shouldContain "incompatible"
     }
@@ -104,7 +104,7 @@ class TestPipes: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, true, text, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), true, text, writeAssembly = true).assertSuccess()
         val stmts = result.program.entrypoint.statements
         stmts.size shouldBe 5
         val assignf = stmts[1] as Assignment
@@ -139,7 +139,7 @@ class TestPipes: FunSpec({
             }
         """
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, errors=errors).assertFailure()
         errors.errors.size shouldBe 1
         errors.errors[0] shouldContain "incompatible"
     }
diff --git a/compiler/test/TestScoping.kt b/compiler/test/TestScoping.kt
index 9c7f9df61..bf94b76c5 100644
--- a/compiler/test/TestScoping.kt
+++ b/compiler/test/TestScoping.kt
@@ -27,7 +27,7 @@ class TestScoping: FunSpec({
             }
         """
 
-        val result = compileText(C64Target, false, src, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), false, src, writeAssembly = false).assertSuccess()
         val module = result.program.toplevelModule
         module.parent shouldBe instanceOf<GlobalNamespace>()
         module.program shouldBeSameInstanceAs result.program
@@ -46,7 +46,7 @@ class TestScoping: FunSpec({
             }
         """
 
-        val result = compileText(C64Target, false, src, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), false, src, writeAssembly = false).assertSuccess()
         val module = result.program.toplevelModule
         val mainBlock = module.statements.single() as Block
         val start = mainBlock.statements.single() as Subroutine
@@ -120,7 +120,7 @@ class TestScoping: FunSpec({
             }
         """
 
-        val result = compileText(C64Target, false, src, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), false, src, writeAssembly = true).assertSuccess()
         val module = result.program.toplevelModule
         val mainBlock = module.statements.single() as Block
         val start = mainBlock.statements.single() as Subroutine
@@ -145,7 +145,7 @@ class TestScoping: FunSpec({
                 }
             }
         """
-        compileText(C64Target, false, text, writeAssembly = false).assertSuccess()
+        compileText(C64Target(), false, text, writeAssembly = false).assertSuccess()
     }
 
     test("wrong subroutine call without qualified names") {
@@ -161,7 +161,7 @@ class TestScoping: FunSpec({
             }
         """
         val errors= ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = false, errors = errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = false, errors = errors).assertFailure()
         errors.errors.size shouldBe 1
         errors.errors[0] shouldContain "undefined symbol: routine2"
     }
@@ -181,7 +181,7 @@ class TestScoping: FunSpec({
                 }
             }
         """
-        compileText(C64Target, false, text, writeAssembly = false).assertSuccess()
+        compileText(C64Target(), false, text, writeAssembly = false).assertSuccess()
     }
 
     test("wrong subroutine calls with qualified names (not from root)") {
@@ -200,7 +200,7 @@ class TestScoping: FunSpec({
             }
         """
         val errors= ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = false, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = false, errors=errors).assertFailure()
         errors.errors.size shouldBe 4
         errors.errors[0] shouldContain "undefined symbol: start.routine2"
         errors.errors[1] shouldContain "undefined symbol: wrong.start.routine2"
@@ -232,7 +232,7 @@ class TestScoping: FunSpec({
                 }
             }
         """
-        compileText(C64Target, false, text, writeAssembly = false).assertSuccess()
+        compileText(C64Target(), false, text, writeAssembly = false).assertSuccess()
     }
 
     test("wrong variables without qualified names") {
@@ -264,7 +264,7 @@ class TestScoping: FunSpec({
             }
         """
         val errors= ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = false, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = false, errors=errors).assertFailure()
         errors.errors.size shouldBe 5
         errors.errors[0] shouldContain "undefined symbol: v3"
         errors.errors[1] shouldContain "undefined symbol: v4"
@@ -297,7 +297,7 @@ class TestScoping: FunSpec({
                 }
             }
         """
-        compileText(C64Target, false, text, writeAssembly = false).assertSuccess()
+        compileText(C64Target(), false, text, writeAssembly = false).assertSuccess()
     }
 
     test("wrong variable refs with qualified names 1 (not from root)") {
@@ -324,7 +324,7 @@ class TestScoping: FunSpec({
             }
         """
         val errors= ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = false, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = false, errors=errors).assertFailure()
         errors.errors.size shouldBe 5
         errors.errors[0] shouldContain "undefined symbol: routine.value"
         errors.errors[1] shouldContain "undefined symbol: routine.arg"
@@ -362,7 +362,7 @@ class TestScoping: FunSpec({
                 }
             }
         """
-        compileText(C64Target, false, text, writeAssembly = false).assertSuccess()
+        compileText(C64Target(), false, text, writeAssembly = false).assertSuccess()
     }
 
     test("various wrong goto targets") {
@@ -380,7 +380,7 @@ class TestScoping: FunSpec({
             }
         """
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = false, errors = errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = false, errors = errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.errors[0] shouldContain "wrong address"
         errors.errors[1] shouldContain "takes parameters"
diff --git a/compiler/test/TestSubroutines.kt b/compiler/test/TestSubroutines.kt
index 1b100021f..466e3e7f5 100644
--- a/compiler/test/TestSubroutines.kt
+++ b/compiler/test/TestSubroutines.kt
@@ -44,7 +44,7 @@ class TestSubroutines: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, text, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = false).assertSuccess()
         val module = result.program.toplevelModule
         val mainBlock = module.statements.single() as Block
         val asmfunc = mainBlock.statements.filterIsInstance<Subroutine>().single { it.name=="asmfunc"}
@@ -100,7 +100,7 @@ class TestSubroutines: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, text, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = true).assertSuccess()
         val module = result.program.toplevelModule
         val mainBlock = module.statements.single() as Block
         val asmfunc = mainBlock.statements.filterIsInstance<Subroutine>().single { it.name=="asmfunc"}
@@ -162,7 +162,7 @@ class TestSubroutines: FunSpec({
             }
         """
 
-        val result = compileText(C64Target, false, text, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = false).assertSuccess()
         val module = result.program.toplevelModule
         val mainBlock = module.statements.single() as Block
         val asmfunc = mainBlock.statements.filterIsInstance<Subroutine>().single { it.name=="asmfunc"}
@@ -188,7 +188,7 @@ class TestSubroutines: FunSpec({
         """
 
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = false, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = false, errors=errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.errors[0] shouldContain "pass-by-reference type can't be used"
         errors.errors[1] shouldContain "pass-by-reference type can't be used"
@@ -212,7 +212,7 @@ class TestSubroutines: FunSpec({
             }
         """
 
-        val result = compileText(C64Target, false, text, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = true).assertSuccess()
         val module = result.program.toplevelModule
         val block = module.statements.single() as Block
         val thing = block.statements.filterIsInstance<Subroutine>().single {it.name=="thing"}
@@ -253,7 +253,7 @@ class TestSubroutines: FunSpec({
             }
         """
 
-        val result = compileText(C64Target, false, text, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = true).assertSuccess()
         val module = result.program.toplevelModule
         val block = module.statements.single() as Block
         val thing = block.statements.filterIsInstance<Subroutine>().single {it.name=="thing"}
@@ -284,7 +284,7 @@ class TestSubroutines: FunSpec({
         """
 
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = false, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = false, errors=errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.errors[0] shouldContain "7:25) invalid number of arguments"
         errors.errors[1] shouldContain "9:25) invalid number of arguments"
@@ -305,7 +305,7 @@ class TestSubroutines: FunSpec({
         """
 
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = false, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = false, errors=errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.errors[0] shouldContain "7:25) invalid number of arguments"
         errors.errors[1] shouldContain "9:25) invalid number of arguments"
@@ -325,7 +325,7 @@ class TestSubroutines: FunSpec({
         """
 
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = false, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = false, errors=errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.errors[0] shouldContain "cannot use arguments"
         errors.errors[1] shouldContain "invalid number of arguments"
@@ -343,7 +343,7 @@ class TestSubroutines: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, text, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = true).assertSuccess()
         val stmts = result.program.entrypoint.statements
 
         stmts.last() shouldBe instanceOf<Subroutine>()
diff --git a/compiler/test/TestTypecasts.kt b/compiler/test/TestTypecasts.kt
index 5f354e9df..154e1a636 100644
--- a/compiler/test/TestTypecasts.kt
+++ b/compiler/test/TestTypecasts.kt
@@ -32,7 +32,7 @@ class TestTypecasts: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, text, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = true).assertSuccess()
         result.program.entrypoint.statements.size shouldBe 13
     }
 
@@ -54,7 +54,7 @@ class TestTypecasts: FunSpec({
             }
         """
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, writeAssembly = true, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, writeAssembly = true, errors=errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.errors[0] shouldContain "can't cast"
         errors.errors[1] shouldContain "can't cast"
@@ -70,7 +70,7 @@ class TestTypecasts: FunSpec({
                 }
             }"""
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, errors=errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.errors[0] shouldContain "can't cast"
         errors.errors[1] shouldContain "can't cast"
@@ -87,7 +87,7 @@ class TestTypecasts: FunSpec({
                 }
             }"""
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, errors=errors).assertFailure()
         errors.errors.size shouldBe 1
         errors.errors[0] shouldContain "in-place makes no sense"
     }
@@ -103,7 +103,7 @@ class TestTypecasts: FunSpec({
                 }
             }"""
         val errors = ErrorReporterForTests()
-        compileText(C64Target, false, text, errors=errors).assertFailure()
+        compileText(C64Target(), false, text, errors=errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.errors[0] shouldContain "can't cast"
         errors.errors[1] shouldContain "can't cast"
@@ -152,7 +152,7 @@ class TestTypecasts: FunSpec({
                 }
             }
         """
-        val result = compileText(C64Target, false, text, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = true).assertSuccess()
         printProgram(result.program)
         val statements = result.program.entrypoint.statements
         statements.size shouldBe 27
@@ -180,7 +180,7 @@ class TestTypecasts: FunSpec({
                     }
                 }
             }"""
-        val result = compileText(C64Target, false, text, writeAssembly = true).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = true).assertSuccess()
         val statements = result.program.entrypoint.statements
         statements.size shouldBe 14
     }
@@ -197,7 +197,7 @@ class TestTypecasts: FunSpec({
                 }
             }
         """
-        compileText(C64Target, false, text, writeAssembly = true).assertSuccess()
+        compileText(C64Target(), false, text, writeAssembly = true).assertSuccess()
     }
 
     test("(u)byte extend to word parameters") {
@@ -226,7 +226,7 @@ class TestTypecasts: FunSpec({
                     }}
                 }
             }"""
-        compileText(C64Target, true, text, writeAssembly = true).assertSuccess()
+        compileText(C64Target(), true, text, writeAssembly = true).assertSuccess()
     }
 
     test("lsb msb used as args with word types") {
@@ -245,6 +245,6 @@ class TestTypecasts: FunSpec({
                     }}
                 }
             }"""
-        compileText(C64Target, true, text, writeAssembly = true).assertSuccess()
+        compileText(C64Target(), true, text, writeAssembly = true).assertSuccess()
     }
 })
diff --git a/compiler/test/ZeropageTests.kt b/compiler/test/ZeropageTests.kt
index ef6effcc8..23283478c 100644
--- a/compiler/test/ZeropageTests.kt
+++ b/compiler/test/ZeropageTests.kt
@@ -59,9 +59,10 @@ class TestAbstractZeropage: FunSpec({
 class TestC64Zeropage: FunSpec({
 
     val errors = ErrorReporterForTests()
+    val c64target = C64Target()
 
     test("testNames") {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false, C64Target))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false, c64target))
 
         var result = zp.allocate(emptyList(), DataType.UBYTE, null, null, errors)
         result.onFailure { fail(it.toString()) }
@@ -75,33 +76,33 @@ class TestC64Zeropage: FunSpec({
     }
 
     test("testZpFloatEnable") {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, C64Target))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, c64target))
         var result = zp.allocate(emptyList(), DataType.FLOAT, null, null, errors)
         result.expectError { "should be allocation error due to disabled floats" }
-        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), true, false, C64Target))
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), true, false, c64target))
         result = zp2.allocate(emptyList(), DataType.FLOAT, null, null, errors)
         result.expectError { "should be allocation error due to disabled ZP use" }
-        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true, false, C64Target))
+        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true, false, c64target))
         zp3.allocate(emptyList(), DataType.FLOAT, null, null, errors)
     }
 
     test("testZpModesWithFloats") {
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, C64Target))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, C64Target))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false, C64Target))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false, false, C64Target))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, C64Target))
-        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true, false, C64Target))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, c64target))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, c64target))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false, c64target))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false, false, c64target))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, c64target))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true, false, c64target))
         shouldThrow<InternalCompilerException> {
-            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true, false, C64Target))
+            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true, false, c64target))
         }
         shouldThrow<InternalCompilerException> {
-            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), true, false, C64Target))
+            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), true, false, c64target))
         }
     }
 
     test("testZpDontuse") {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), false, false, C64Target))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), false, false, c64target))
         println(zp.free)
         zp.availableBytes() shouldBe 0
         val result = zp.allocate(emptyList(), DataType.BYTE, null, null, errors)
@@ -109,13 +110,13 @@ class TestC64Zeropage: FunSpec({
     }
 
     test("testFreeSpacesBytes") {
-        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, C64Target))
+        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, c64target))
         zp1.availableBytes() shouldBe 18
-        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false, false, C64Target))
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false, false, c64target))
         zp2.availableBytes() shouldBe 85
-        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, C64Target))
+        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, c64target))
         zp3.availableBytes() shouldBe 125
-        val zp4 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, C64Target))
+        val zp4 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, c64target))
         zp4.availableBytes() shouldBe 239
         zp4.allocate(listOf("test"), DataType.UBYTE, null, null, errors)
         zp4.availableBytes() shouldBe 238
@@ -124,7 +125,7 @@ class TestC64Zeropage: FunSpec({
     }
 
     test("testReservedSpace") {
-        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, C64Target))
+        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, c64target))
         zp1.availableBytes() shouldBe 239
         50u shouldBeIn zp1.free
         100u shouldBeIn zp1.free
@@ -133,7 +134,7 @@ class TestC64Zeropage: FunSpec({
         200u shouldBeIn zp1.free
         255u shouldBeIn zp1.free
         199u shouldBeIn zp1.free
-        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, listOf(50u .. 100u, 200u..255u), false, false, C64Target))
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, listOf(50u .. 100u, 200u..255u), false, false, c64target))
         zp2.availableBytes() shouldBe 139
         50u shouldNotBeIn zp2.free
         100u shouldNotBeIn zp2.free
@@ -145,7 +146,7 @@ class TestC64Zeropage: FunSpec({
     }
 
     test("testBasicsafeAllocation") {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, C64Target))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, c64target))
         zp.availableBytes() shouldBe 18
         zp.hasByteAvailable() shouldBe true
         zp.hasWordAvailable() shouldBe true
@@ -167,7 +168,7 @@ class TestC64Zeropage: FunSpec({
     }
 
     test("testFullAllocation") {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, C64Target))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, c64target))
         zp.availableBytes() shouldBe 239
         zp.hasByteAvailable() shouldBe true
         zp.hasWordAvailable() shouldBe true
@@ -198,7 +199,7 @@ class TestC64Zeropage: FunSpec({
     }
 
     test("testEfficientAllocation") {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(),  true, false, C64Target))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(),  true, false, c64target))
         zp.availableBytes() shouldBe 18
         zp.allocate(emptyList(), DataType.WORD, null, null, errors ).getOrElse{throw it}.first shouldBe 0x04u
         zp.allocate(emptyList(), DataType.UBYTE, null, null, errors).getOrElse{throw it}.first shouldBe 0x06u
@@ -216,7 +217,7 @@ class TestC64Zeropage: FunSpec({
     }
 
     test("testReservedLocations") {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false, C64Target))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false, c64target))
         withClue("zp _B1 and _REG must be next to each other to create a word") {
             zp.SCRATCH_B1 + 1u shouldBe zp.SCRATCH_REG
         }
@@ -226,20 +227,21 @@ class TestC64Zeropage: FunSpec({
 
 class TestCx16Zeropage: FunSpec({
     val errors = ErrorReporterForTests()
+    val cx16target = Cx16Target()
 
     test("testReservedLocations") {
-        val zp = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false, Cx16Target))
+        val zp = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false, false, cx16target))
         withClue("zp _B1 and _REG must be next to each other to create a word") {
             zp.SCRATCH_B1 + 1u shouldBe zp.SCRATCH_REG
         }
     }
 
     test("testFreeSpacesBytes") {
-        val zp1 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, Cx16Target))
+        val zp1 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true, false, cx16target))
         zp1.availableBytes() shouldBe 88
-        val zp2 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, Cx16Target))
+        val zp2 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false, false, cx16target))
         zp2.availableBytes() shouldBe 175
-        val zp3 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, Cx16Target))
+        val zp3 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, cx16target))
         zp3.availableBytes() shouldBe 216
         zp3.allocate(listOf("test"), DataType.UBYTE, null, null, errors)
         zp3.availableBytes() shouldBe 215
@@ -248,7 +250,7 @@ class TestCx16Zeropage: FunSpec({
     }
 
     test("testReservedSpace") {
-        val zp1 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, Cx16Target))
+        val zp1 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, cx16target))
         zp1.availableBytes() shouldBe 216
         0x22u shouldBeIn zp1.free
         0x80u shouldBeIn zp1.free
@@ -258,7 +260,7 @@ class TestCx16Zeropage: FunSpec({
     }
 
     test("preallocated zp vars") {
-        val zp1 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, Cx16Target))
+        val zp1 = CX16Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, false, cx16target))
         zp1.variables[listOf("test")] shouldBe null
         zp1.variables[listOf("cx16", "r0")] shouldNotBe null
         zp1.variables[listOf("cx16", "r15")] shouldNotBe null
diff --git a/compiler/test/ast/TestProg8Parser.kt b/compiler/test/ast/TestProg8Parser.kt
index 90e765082..932aae3cd 100644
--- a/compiler/test/ast/TestProg8Parser.kt
+++ b/compiler/test/ast/TestProg8Parser.kt
@@ -908,7 +908,7 @@ class TestProg8Parser: FunSpec( {
                 }
             }
         """
-        val result = compileText(C64Target, false, text, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = false).assertSuccess()
         val start = result.program.entrypoint
         val string = (start.statements[0] as VarDecl).value as StringLiteralValue
         withClue("x-escapes are hacked to range 0x8000-0x80ff") {
@@ -945,7 +945,7 @@ class TestProg8Parser: FunSpec( {
                 }
             }
         """
-        val result = compileText(C64Target, false, text, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(), false, text, writeAssembly = false).assertSuccess()
         val start = result.program.entrypoint
         val containmentChecks = start.statements.takeLast(4)
         (containmentChecks[0] as IfElse).condition shouldBe instanceOf<ContainmentCheck>()
@@ -966,7 +966,7 @@ class TestProg8Parser: FunSpec( {
             }
         """
         val errors = ErrorReporterForTests()
-        compileText(C64Target,  false, text, writeAssembly = false, errors = errors).assertFailure()
+        compileText(C64Target(),  false, text, writeAssembly = false, errors = errors).assertFailure()
         errors.errors.size shouldBe 2
         errors.errors[0] shouldContain "must be an iterable type"
         errors.errors[1] shouldContain "datatype doesn't match"
@@ -986,7 +986,7 @@ class TestProg8Parser: FunSpec( {
                 }
             }
         """
-        val result = compileText(C64Target,  false, text, writeAssembly = false).assertSuccess()
+        val result = compileText(C64Target(),  false, text, writeAssembly = false).assertSuccess()
         val stmt = result.program.entrypoint.statements
         stmt.size shouldBe 12
         val var1 = stmt[0] as VarDecl
diff --git a/compiler/test/codegeneration/TestAsmGenSymbols.kt b/compiler/test/codegeneration/TestAsmGenSymbols.kt
index b06e8816e..04eaffc8b 100644
--- a/compiler/test/codegeneration/TestAsmGenSymbols.kt
+++ b/compiler/test/codegeneration/TestAsmGenSymbols.kt
@@ -77,7 +77,7 @@ class TestAsmGenSymbols: StringSpec({
 
     fun createTestAsmGen(program: Program): AsmGen6502 {
         val errors = ErrorReporterForTests()
-        val options = CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, true, C64Target)
+        val options = CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false, true, C64Target())
         options.compTarget.machine.zeropage = C64Zeropage(options)
         val asmgen = AsmGen6502(program, errors, options)
         return asmgen
diff --git a/compiler/test/codegeneration/TestVariables.kt b/compiler/test/codegeneration/TestVariables.kt
index 3fd2681db..e412c195a 100644
--- a/compiler/test/codegeneration/TestVariables.kt
+++ b/compiler/test/codegeneration/TestVariables.kt
@@ -24,7 +24,7 @@ class TestVariables: FunSpec({
                 }
             }
         """
-        compileText(C64Target, true, text, writeAssembly = true).assertSuccess()
+        compileText(C64Target(), true, text, writeAssembly = true).assertSuccess()
     }
 
     test("array initialization with array literal") {
@@ -35,7 +35,7 @@ class TestVariables: FunSpec({
                 }
             }
         """
-        compileText(C64Target, true, text, writeAssembly = true).assertSuccess()
+        compileText(C64Target(), true, text, writeAssembly = true).assertSuccess()
     }
 
     test("array initialization with array var assignment") {
@@ -48,6 +48,6 @@ class TestVariables: FunSpec({
                 ubyte[] values = [1,2,3]
             }
         """
-        compileText(C64Target, false, text, writeAssembly = true).assertSuccess()
+        compileText(C64Target(), false, text, writeAssembly = true).assertSuccess()
     }
 })
diff --git a/compiler/test/helpers/compileXyz.kt b/compiler/test/helpers/compileXyz.kt
index 18e2a5a1c..0ad3a01e4 100644
--- a/compiler/test/helpers/compileXyz.kt
+++ b/compiler/test/helpers/compileXyz.kt
@@ -85,7 +85,7 @@ internal fun generateAssembly(
     program: Program,
     options: CompilationOptions? = null
 ): IAssemblyProgram? {
-    val coptions = options ?: CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), true, true, C64Target, outputDir = outputDir)
+    val coptions = options ?: CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), true, true, C64Target(), outputDir = outputDir)
     coptions.compTarget.machine.zeropage = C64Zeropage(coptions)
     val asmgen = AsmGen6502(program, ErrorReporterForTests(), coptions)
     return asmgen.compileToAssembly()
diff --git a/docs/source/todo.rst b/docs/source/todo.rst
index 7bc5024ff..34d5f277b 100644
--- a/docs/source/todo.rst
+++ b/docs/source/todo.rst
@@ -3,8 +3,7 @@ TODO
 
 For next release
 ^^^^^^^^^^^^^^^^
-fix the concurrent modification issue on zeropage when running unit tests in parallel -> don't use static objects anymore
-
+...
 
 Need help with
 ^^^^^^^^^^^^^^