diff --git a/compiler/src/prog8/CompilerMain.kt b/compiler/src/prog8/CompilerMain.kt
index 99a567f66..3ea67d472 100644
--- a/compiler/src/prog8/CompilerMain.kt
+++ b/compiler/src/prog8/CompilerMain.kt
@@ -8,7 +8,7 @@ import prog8.ast.base.AstException
 import prog8.compiler.CompilationResult
 import prog8.compiler.compileProgram
 import prog8.compiler.target.C64Target
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.Cx16Target
 import prog8.parser.ParsingFailedError
 import java.nio.file.FileSystems
@@ -117,7 +117,7 @@ private fun compileMain(args: Array<String>) {
                 if (compilationResult.programName.isEmpty())
                     println("\nCan't start emulator because no program was assembled.")
                 else {
-                    CompilationTarget.instance.machine.launchEmulator(compilationResult.programName)
+                    ICompilationTarget.instance.machine.launchEmulator(compilationResult.programName)
                 }
             }
         }
diff --git a/compiler/src/prog8/compiler/BeforeAsmGenerationAstChanger.kt b/compiler/src/prog8/compiler/BeforeAsmGenerationAstChanger.kt
index e26645579..caa7cf0bd 100644
--- a/compiler/src/prog8/compiler/BeforeAsmGenerationAstChanger.kt
+++ b/compiler/src/prog8/compiler/BeforeAsmGenerationAstChanger.kt
@@ -8,7 +8,7 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 
 
 internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: ErrorReporter) : AstWalker() {
@@ -38,7 +38,7 @@ internal class BeforeAsmGenerationAstChanger(val program: Program, val errors: E
         // But it can only be done if the target variable IS NOT OCCURRING AS AN OPERAND ITSELF.
         if(!assignment.isAugmentable
                 && assignment.target.identifier != null
-                && CompilationTarget.instance.isInRegularRAM(assignment.target, program)) {
+                && ICompilationTarget.instance.isInRegularRAM(assignment.target, program)) {
             val binExpr = assignment.value as? BinaryExpression
             if (binExpr != null && binExpr.operator !in comparisonOperators) {
                 if (binExpr.left !is BinaryExpression) {
diff --git a/compiler/src/prog8/compiler/Compiler.kt b/compiler/src/prog8/compiler/Compiler.kt
index b9710d20c..006410eed 100644
--- a/compiler/src/prog8/compiler/Compiler.kt
+++ b/compiler/src/prog8/compiler/Compiler.kt
@@ -11,8 +11,9 @@ import prog8.ast.statements.Directive
 import prog8.compiler.astprocessing.*
 import prog8.compiler.functions.*
 import prog8.compiler.target.C64Target
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.Cx16Target
+import prog8.compiler.target.asmGeneratorFor
 import prog8.optimizer.*
 import prog8.parser.ModuleImporter
 import prog8.parser.ParsingFailedError
@@ -73,8 +74,8 @@ fun compileProgram(filepath: Path,
     val errors = ErrorReporter()
 
     when(compilationTarget) {
-        C64Target.name -> CompilationTarget.instance = C64Target
-        Cx16Target.name -> CompilationTarget.instance = Cx16Target
+        C64Target.name -> ICompilationTarget.instance = C64Target
+        Cx16Target.name -> ICompilationTarget.instance = Cx16Target
         else -> {
             System.err.println("invalid compilation target")
             exitProcess(1)
@@ -161,13 +162,13 @@ private class BuiltinFunctionsFacade(functions: Map<String, FSignature>): IBuilt
 }
 
 private fun parseImports(filepath: Path, errors: ErrorReporter): Triple<Program, CompilationOptions, List<Path>> {
-    val compilationTargetName = CompilationTarget.instance.name
+    val compilationTargetName = ICompilationTarget.instance.name
     println("Compiler target: $compilationTargetName. Parsing...")
     val importer = ModuleImporter()
     val bf = BuiltinFunctionsFacade(BuiltinFunctions)
     val programAst = Program(moduleName(filepath.fileName), mutableListOf(), bf)
     bf.program = programAst
-    importer.importModule(programAst, filepath, CompilationTarget.instance, compilationTargetName)
+    importer.importModule(programAst, filepath, ICompilationTarget.instance, compilationTargetName)
     errors.handle()
 
     val importedFiles = programAst.modules.filter { !it.source.startsWith("@embedded@") }.map { it.source }
@@ -177,11 +178,11 @@ private fun parseImports(filepath: Path, errors: ErrorReporter): Triple<Program,
         throw ParsingFailedError("${programAst.modules.first().position} BASIC launcher requires output type PRG.")
 
     // depending on the machine and compiler options we may have to include some libraries
-    CompilationTarget.instance.machine.importLibs(compilerOptions, importer, programAst, CompilationTarget.instance, compilationTargetName)
+    ICompilationTarget.instance.machine.importLibs(compilerOptions, importer, programAst, ICompilationTarget.instance, compilationTargetName)
 
     // always import prog8_lib and math
-    importer.importLibraryModule(programAst, "math", CompilationTarget.instance, compilationTargetName)
-    importer.importLibraryModule(programAst, "prog8_lib", CompilationTarget.instance, compilationTargetName)
+    importer.importLibraryModule(programAst, "math", ICompilationTarget.instance, compilationTargetName)
+    importer.importLibraryModule(programAst, "prog8_lib", ICompilationTarget.instance, compilationTargetName)
     errors.handle()
     return Triple(programAst, compilerOptions, importedFiles)
 }
@@ -208,7 +209,7 @@ private fun determineCompilationOptions(program: Program): CompilationOptions {
                     // error will be printed by the astchecker
                 }
 
-    if (zpType==ZeropageType.FLOATSAFE && CompilationTarget.instance.name == Cx16Target.name) {
+    if (zpType==ZeropageType.FLOATSAFE && ICompilationTarget.instance.name == Cx16Target.name) {
         System.err.println("Warning: Cx16 target must use zp option basicsafe instead of floatsafe")
         zpType = ZeropageType.BASICSAFE
     }
@@ -238,7 +239,7 @@ private fun determineCompilationOptions(program: Program): CompilationOptions {
 
 private fun processAst(programAst: Program, errors: ErrorReporter, compilerOptions: CompilationOptions) {
     // perform initial syntax checks and processings
-    println("Processing for target ${CompilationTarget.instance.name}...")
+    println("Processing for target ${ICompilationTarget.instance.name}...")
     programAst.checkIdentifiers(errors)
     errors.handle()
     programAst.constantFold(errors)
@@ -295,11 +296,11 @@ private fun writeAssembly(programAst: Program, errors: ErrorReporter, outputDir:
 
     // printAst(programAst)
 
-    CompilationTarget.instance.machine.initializeZeropage(compilerOptions)
-    val assembly = CompilationTarget.instance.asmGenerator(
+    ICompilationTarget.instance.machine.initializeZeropage(compilerOptions)
+    val assembly = asmGeneratorFor(ICompilationTarget.instance,
             programAst,
             errors,
-            CompilationTarget.instance.machine.zeropage,
+            ICompilationTarget.instance.machine.zeropage,
             compilerOptions,
             outputDir).compileToAssembly()
     assembly.assemble(compilerOptions)
diff --git a/compiler/src/prog8/compiler/astprocessing/AstChecker.kt b/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
index 194a6e83c..35065d42a 100644
--- a/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
+++ b/compiler/src/prog8/compiler/astprocessing/AstChecker.kt
@@ -12,7 +12,7 @@ import prog8.compiler.ErrorReporter
 import prog8.compiler.functions.BuiltinFunctions
 import prog8.compiler.functions.builtinFunctionReturnType
 import prog8.compiler.target.C64Target
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.Cx16Target
 import java.io.File
 
@@ -1286,7 +1286,7 @@ internal class AstChecker(private val program: Program,
 
                     // check if the floating point values are all within range
                     val doubles = value.value.map {it.constValue(program)?.number!!.toDouble()}.toDoubleArray()
-                    if(doubles.any { it < CompilationTarget.instance.machine.FLOAT_MAX_NEGATIVE || it > CompilationTarget.instance.machine.FLOAT_MAX_POSITIVE })
+                    if(doubles.any { it < ICompilationTarget.instance.machine.FLOAT_MAX_NEGATIVE || it > ICompilationTarget.instance.machine.FLOAT_MAX_POSITIVE })
                         return err("floating point value overflow")
                     return true
                 }
diff --git a/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt b/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt
index cb15175c2..663a33a54 100644
--- a/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt
+++ b/compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt
@@ -12,7 +12,7 @@ import prog8.ast.expressions.StringLiteralValue
 import prog8.ast.statements.*
 import prog8.ast.walk.IAstVisitor
 import prog8.compiler.functions.BuiltinFunctions
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 
 internal class AstIdentifiersChecker(private val program: Program, private val errors: ErrorReporter) : IAstVisitor {
     private var blocks = mutableMapOf<String, Block>()
@@ -28,7 +28,7 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
     }
 
     override fun visit(block: Block) {
-        if(block.name in CompilationTarget.instance.machine.opcodeNames)
+        if(block.name in ICompilationTarget.instance.machine.opcodeNames)
             errors.err("can't use a cpu opcode name as a symbol: '${block.name}'", block.position)
 
         val existing = blocks[block.name]
@@ -50,8 +50,8 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
     override fun visit(directive: Directive) {
         if(directive.directive=="%target") {
             val compatibleTarget = directive.args.single().name
-            if (compatibleTarget != CompilationTarget.instance.name)
-                errors.err("module's compilation target ($compatibleTarget) differs from active target (${CompilationTarget.instance.name})", directive.position)
+            if (compatibleTarget != ICompilationTarget.instance.name)
+                errors.err("module's compilation target ($compatibleTarget) differs from active target (${ICompilationTarget.instance.name})", directive.position)
         }
 
         super.visit(directive)
@@ -63,7 +63,7 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
         if(decl.name in BuiltinFunctions)
             errors.err("builtin function cannot be redefined", decl.position)
 
-        if(decl.name in CompilationTarget.instance.machine.opcodeNames)
+        if(decl.name in ICompilationTarget.instance.machine.opcodeNames)
             errors.err("can't use a cpu opcode name as a symbol: '${decl.name}'", decl.position)
 
         if(decl.datatype==DataType.STRUCT) {
@@ -102,7 +102,7 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
     }
 
     override fun visit(subroutine: Subroutine) {
-        if(subroutine.name in CompilationTarget.instance.machine.opcodeNames) {
+        if(subroutine.name in ICompilationTarget.instance.machine.opcodeNames) {
             errors.err("can't use a cpu opcode name as a symbol: '${subroutine.name}'", subroutine.position)
         } else if(subroutine.name in BuiltinFunctions) {
             // the builtin functions can't be redefined
@@ -142,7 +142,7 @@ internal class AstIdentifiersChecker(private val program: Program, private val e
     }
 
     override fun visit(label: Label) {
-        if(label.name in CompilationTarget.instance.machine.opcodeNames)
+        if(label.name in ICompilationTarget.instance.machine.opcodeNames)
             errors.err("can't use a cpu opcode name as a symbol: '${label.name}'", label.position)
 
         if(label.name in BuiltinFunctions) {
diff --git a/compiler/src/prog8/compiler/functions/BuiltinFunctions.kt b/compiler/src/prog8/compiler/functions/BuiltinFunctions.kt
index ae438287c..c48b9aaa8 100644
--- a/compiler/src/prog8/compiler/functions/BuiltinFunctions.kt
+++ b/compiler/src/prog8/compiler/functions/BuiltinFunctions.kt
@@ -6,7 +6,7 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.StructDecl
 import prog8.ast.statements.VarDecl
 import prog8.compiler.CompilerException
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import kotlin.math.*
 
 
@@ -297,7 +297,7 @@ private fun builtinOffsetof(args: List<Expression>, position: Position, program:
     for(member in struct.statements) {
         if((member as VarDecl).name == membername)
             return NumericLiteralValue(DataType.UBYTE, offset, position)
-        offset += CompilationTarget.instance.memorySize(member.datatype)
+        offset += ICompilationTarget.instance.memorySize(member.datatype)
     }
     throw SyntaxError("undefined struct member", position)
 }
@@ -315,13 +315,13 @@ private fun builtinSizeof(args: List<Expression>, position: Position, program: P
                 ?: throw CannotEvaluateException("sizeof", "no target")
 
         fun structSize(target: StructDecl) =
-                NumericLiteralValue(DataType.UBYTE, target.statements.map { CompilationTarget.instance.memorySize((it as VarDecl).datatype) }.sum(), position)
+                NumericLiteralValue(DataType.UBYTE, target.statements.map { ICompilationTarget.instance.memorySize((it as VarDecl).datatype) }.sum(), position)
 
         return when {
             dt.typeOrElse(DataType.STRUCT) in ArrayDatatypes -> {
                 val length = (target as VarDecl).arraysize!!.constIndex() ?: throw CannotEvaluateException("sizeof", "unknown array size")
                 val elementDt = ArrayElementTypes.getValue(dt.typeOrElse(DataType.STRUCT))
-                numericLiteral(CompilationTarget.instance.memorySize(elementDt) * length, position)
+                numericLiteral(ICompilationTarget.instance.memorySize(elementDt) * length, position)
             }
             dt.istype(DataType.STRUCT) -> {
                 when (target) {
@@ -331,7 +331,7 @@ private fun builtinSizeof(args: List<Expression>, position: Position, program: P
                 }
             }
             dt.istype(DataType.STR) -> throw SyntaxError("sizeof str is undefined, did you mean len?", position)
-            else -> NumericLiteralValue(DataType.UBYTE, CompilationTarget.instance.memorySize(dt.typeOrElse(DataType.STRUCT)), position)
+            else -> NumericLiteralValue(DataType.UBYTE, ICompilationTarget.instance.memorySize(dt.typeOrElse(DataType.STRUCT)), position)
         }
     } else {
         throw SyntaxError("sizeof invalid argument type", position)
diff --git a/compiler/src/prog8/compiler/target/CompilationTarget.kt b/compiler/src/prog8/compiler/target/ICompilationTarget.kt
similarity index 85%
rename from compiler/src/prog8/compiler/target/CompilationTarget.kt
rename to compiler/src/prog8/compiler/target/ICompilationTarget.kt
index 59b363928..3de5339ea 100644
--- a/compiler/src/prog8/compiler/target/CompilationTarget.kt
+++ b/compiler/src/prog8/compiler/target/ICompilationTarget.kt
@@ -16,16 +16,15 @@ import prog8.compiler.target.cx16.CX16MachineDefinition
 import java.nio.file.Path
 
 
-internal interface CompilationTarget: IStringEncoding {
+internal interface ICompilationTarget: IStringEncoding {
     val name: String
     val machine: IMachineDefinition
     override fun encodeString(str: String, altEncoding: Boolean): List<Short>
     override fun decodeString(bytes: List<Short>, altEncoding: Boolean): String
     fun memorySize(dt: DataType): Int
-    fun asmGenerator(program: Program, errors: ErrorReporter, zp: Zeropage, options: CompilationOptions, path: Path): IAssemblyGenerator
 
     companion object {
-        lateinit var instance: CompilationTarget
+        lateinit var instance: ICompilationTarget
     }
 
     fun isInRegularRAM(target: AssignTarget, program: Program): Boolean {
@@ -72,15 +71,13 @@ internal interface CompilationTarget: IStringEncoding {
 }
 
 
-internal object C64Target: CompilationTarget {
+internal object C64Target: ICompilationTarget {
     override val name = "c64"
     override val machine = C64MachineDefinition
     override fun encodeString(str: String, altEncoding: Boolean) =
             if(altEncoding) Petscii.encodeScreencode(str, true) else Petscii.encodePetscii(str, true)
     override fun decodeString(bytes: List<Short>, altEncoding: Boolean) =
             if(altEncoding) Petscii.decodeScreencode(bytes, true) else Petscii.decodePetscii(bytes, true)
-    override fun asmGenerator(program: Program, errors: ErrorReporter, zp: Zeropage, options: CompilationOptions, path: Path) =
-            AsmGen(program, errors, zp, options, path)
 
     override fun memorySize(dt: DataType): Int {
         return when(dt) {
@@ -93,15 +90,13 @@ internal object C64Target: CompilationTarget {
     }
 }
 
-internal object Cx16Target: CompilationTarget {
+internal object Cx16Target: ICompilationTarget {
     override val name = "cx16"
     override val machine = CX16MachineDefinition
     override fun encodeString(str: String, altEncoding: Boolean) =
             if(altEncoding) Petscii.encodeScreencode(str, true) else Petscii.encodePetscii(str, true)
     override fun decodeString(bytes: List<Short>, altEncoding: Boolean) =
             if(altEncoding) Petscii.decodeScreencode(bytes, true) else Petscii.decodePetscii(bytes, true)
-    override fun asmGenerator(program: Program, errors: ErrorReporter, zp: Zeropage, options: CompilationOptions, path: Path) =
-            AsmGen(program, errors, zp, options, path)
 
     override fun memorySize(dt: DataType): Int {
         return when(dt) {
@@ -113,3 +108,16 @@ internal object Cx16Target: CompilationTarget {
         }
     }
 }
+
+
+internal fun asmGeneratorFor(
+    compTarget: ICompilationTarget,
+    program: Program,
+    errors: ErrorReporter,
+    zp: Zeropage,
+    options: CompilationOptions,
+    outputDir: Path
+): IAssemblyGenerator
+{
+    return AsmGen(program, errors, zp, options, outputDir)
+}
diff --git a/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt b/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt
index 1a223b837..1eb4df94a 100644
--- a/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt
+++ b/compiler/src/prog8/compiler/target/c64/AssemblyProgram.kt
@@ -2,7 +2,7 @@ package prog8.compiler.target.c64
 
 import prog8.compiler.CompilationOptions
 import prog8.compiler.OutputType
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.IAssemblyProgram
 import prog8.compiler.target.generatedLabelPrefix
 import java.nio.file.Path
@@ -23,12 +23,12 @@ class AssemblyProgram(override val name: String, outputDir: Path) : IAssemblyPro
         val outFile = when (options.output) {
             OutputType.PRG -> {
                 command.add("--cbm-prg")
-                println("\nCreating prg for target ${CompilationTarget.instance.name}.")
+                println("\nCreating prg for target ${ICompilationTarget.instance.name}.")
                 prgFile
             }
             OutputType.RAW -> {
                 command.add("--nostart")
-                println("\nCreating raw binary for target ${CompilationTarget.instance.name}.")
+                println("\nCreating raw binary for target ${ICompilationTarget.instance.name}.")
                 binFile
             }
         }
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
index 6950c73df..015fad2da 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
@@ -90,7 +90,7 @@ internal class AsmGen(private val program: Program,
 
     private fun header() {
         val ourName = this.javaClass.name
-        val cpu = when(CompilationTarget.instance.machine.cpu) {
+        val cpu = when(ICompilationTarget.instance.machine.cpu) {
             CpuType.CPU6502 -> "6502"
             CpuType.CPU65c02 -> "65c02"
             else -> "unsupported"
@@ -105,16 +105,16 @@ internal class AsmGen(private val program: Program,
         program.actualLoadAddress = program.definedLoadAddress
         if (program.actualLoadAddress == 0)   // fix load address
             program.actualLoadAddress = if (options.launcher == LauncherType.BASIC)
-                CompilationTarget.instance.machine.BASIC_LOAD_ADDRESS else CompilationTarget.instance.machine.RAW_LOAD_ADDRESS
+                ICompilationTarget.instance.machine.BASIC_LOAD_ADDRESS else ICompilationTarget.instance.machine.RAW_LOAD_ADDRESS
 
         // the global prog8 variables needed
-        val zp = CompilationTarget.instance.machine.zeropage
+        val zp = ICompilationTarget.instance.machine.zeropage
         out("P8ZP_SCRATCH_B1 = ${zp.SCRATCH_B1}")
         out("P8ZP_SCRATCH_REG = ${zp.SCRATCH_REG}")
         out("P8ZP_SCRATCH_W1 = ${zp.SCRATCH_W1}    ; word")
         out("P8ZP_SCRATCH_W2 = ${zp.SCRATCH_W2}    ; word")
-        out("P8ESTACK_LO = ${CompilationTarget.instance.machine.ESTACK_LO.toHex()}")
-        out("P8ESTACK_HI = ${CompilationTarget.instance.machine.ESTACK_HI.toHex()}")
+        out("P8ESTACK_LO = ${ICompilationTarget.instance.machine.ESTACK_LO.toHex()}")
+        out("P8ESTACK_HI = ${ICompilationTarget.instance.machine.ESTACK_HI.toHex()}")
 
         when {
             options.launcher == LauncherType.BASIC -> {
@@ -128,13 +128,13 @@ internal class AsmGen(private val program: Program,
                 out("+\t.word  0")
                 out("_prog8_entrypoint\t; assembly code starts here\n")
                 if(!options.noSysInit)
-                    out("  jsr  ${CompilationTarget.instance.name}.init_system")
+                    out("  jsr  ${ICompilationTarget.instance.name}.init_system")
             }
             options.output == OutputType.PRG -> {
                 out("; ---- program without basic sys call ----")
                 out("* = ${program.actualLoadAddress.toHex()}\n")
                 if(!options.noSysInit)
-                    out("  jsr  ${CompilationTarget.instance.name}.init_system")
+                    out("  jsr  ${ICompilationTarget.instance.name}.init_system")
             }
             options.output == OutputType.RAW -> {
                 out("; ---- raw assembler program ----")
@@ -166,7 +166,7 @@ internal class AsmGen(private val program: Program,
         // the global list of all floating point constants for the whole program
         out("; global float constants")
         for (flt in globalFloatConsts) {
-            val floatFill = CompilationTarget.instance.machine.getFloat(flt.key).makeFloatFillAsm()
+            val floatFill = ICompilationTarget.instance.machine.getFloat(flt.key).makeFloatFillAsm()
             val floatvalue = flt.key
             out("${flt.value}\t.byte  $floatFill  ; float $floatvalue")
         }
@@ -337,7 +337,7 @@ internal class AsmGen(private val program: Program,
                         }
                 val floatFills = array.map {
                     val number = (it as NumericLiteralValue).number
-                    CompilationTarget.instance.machine.getFloat(number).makeFloatFillAsm()
+                    ICompilationTarget.instance.machine.getFloat(number).makeFloatFillAsm()
                 }
                 out(name)
                 for (f in array.zip(floatFills))
@@ -526,7 +526,7 @@ internal class AsmGen(private val program: Program,
         val sourceName = asmVariableName(pointervar)
         val vardecl = pointervar.targetVarDecl(program)!!
         val scopedName = vardecl.makeScopedName(vardecl.name)
-        if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+        if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
             return if (isZpVar(scopedName)) {
                 // pointervar is already in the zero page, no need to copy
                 out("  lda  ($sourceName)")
@@ -561,7 +561,7 @@ internal class AsmGen(private val program: Program,
     private  fun fixNameSymbols(name: String) = name.replace("<", "prog8_").replace(">", "")     // take care of the autogenerated invalid (anon) label names
 
     internal fun saveRegisterLocal(register: CpuRegister, scope: Subroutine) {
-        if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+        if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
             // just use the cpu's stack for all registers, shorter code
             when (register) {
                 CpuRegister.A -> out("  pha")
@@ -590,7 +590,7 @@ internal class AsmGen(private val program: Program,
         when (register) {
             CpuRegister.A -> out("  pha")
             CpuRegister.X -> {
-                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phx")
+                if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phx")
                 else {
                     if(keepA)
                         out("  sta  P8ZP_SCRATCH_REG |  txa |  pha  |  lda  P8ZP_SCRATCH_REG")
@@ -599,7 +599,7 @@ internal class AsmGen(private val program: Program,
                 }
             }
             CpuRegister.Y -> {
-                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phy")
+                if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phy")
                 else {
                     if(keepA)
                         out("  sta  P8ZP_SCRATCH_REG |  tya |  pha  |  lda  P8ZP_SCRATCH_REG")
@@ -611,7 +611,7 @@ internal class AsmGen(private val program: Program,
     }
 
     internal fun restoreRegisterLocal(register: CpuRegister) {
-        if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+        if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
             when (register) {
                 // this just used the stack, for all registers. Shorter code.
                 CpuRegister.A -> out("  pla")
@@ -636,7 +636,7 @@ internal class AsmGen(private val program: Program,
                 out("  pla")
             }
             CpuRegister.X -> {
-                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  plx")
+                if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  plx")
                 else {
                     if(keepA)
                         out("  sta  P8ZP_SCRATCH_REG |  pla |  tax |  lda  P8ZP_SCRATCH_REG")
@@ -645,7 +645,7 @@ internal class AsmGen(private val program: Program,
                 }
             }
             CpuRegister.Y -> {
-                if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  ply")
+                if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  ply")
                 else {
                     if(keepA)
                         out("  sta  P8ZP_SCRATCH_REG |  pla |  tay |  lda  P8ZP_SCRATCH_REG")
@@ -705,7 +705,7 @@ internal class AsmGen(private val program: Program,
         val reg = register.toString().toLowerCase()
         val indexnum = expr.indexer.constIndex()
         if(indexnum!=null) {
-            val indexValue = indexnum * CompilationTarget.instance.memorySize(elementDt) + if(addOneExtra) 1 else 0
+            val indexValue = indexnum * ICompilationTarget.instance.memorySize(elementDt) + if(addOneExtra) 1 else 0
             out("  ld$reg  #$indexValue")
             return
         }
@@ -731,7 +731,7 @@ internal class AsmGen(private val program: Program,
                     }
                 }
                 DataType.FLOAT -> {
-                    require(CompilationTarget.instance.memorySize(DataType.FLOAT)==5)
+                    require(ICompilationTarget.instance.memorySize(DataType.FLOAT)==5)
                     out("""
                                 lda  $indexName
                                 asl  a
@@ -758,7 +758,7 @@ internal class AsmGen(private val program: Program,
                     }
                 }
                 DataType.FLOAT -> {
-                    require(CompilationTarget.instance.memorySize(DataType.FLOAT)==5)
+                    require(ICompilationTarget.instance.memorySize(DataType.FLOAT)==5)
                     out("""
                                 lda  $indexName
                                 asl  a
@@ -1328,7 +1328,7 @@ $label              nop""")
         // sign extend signed byte on stack to signed word on stack
         when(valueDt) {
             DataType.UBYTE -> {
-                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                     out("  stz  P8ESTACK_HI+1,x")
                 else
                     out("  lda  #0 |  sta  P8ESTACK_HI+1,x")
@@ -1342,7 +1342,7 @@ $label              nop""")
         // sign extend signed byte in a var to a full word in that variable
         when(valueDt) {
             DataType.UBYTE -> {
-                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                     out("  stz  $asmvar+1")
                 else
                     out("  lda  #0 |  sta  $asmvar+1")
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt
index 46525b63d..d7014fc5c 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt
@@ -9,7 +9,7 @@ import prog8.ast.statements.*
 import prog8.ast.toHex
 import prog8.compiler.AssemblyError
 import prog8.compiler.functions.FSignature
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.c64.codegen.assignment.*
 import prog8.compiler.target.subroutineFloatEvalResultVar2
 
@@ -679,8 +679,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
     }
 
     private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexValue1: NumericLiteralValue, arrayVarName2: String, indexValue2: NumericLiteralValue) {
-        val index1 = indexValue1.number.toInt() * CompilationTarget.instance.memorySize(elementDt)
-        val index2 = indexValue2.number.toInt() * CompilationTarget.instance.memorySize(elementDt)
+        val index1 = indexValue1.number.toInt() * ICompilationTarget.instance.memorySize(elementDt)
+        val index2 = indexValue2.number.toInt() * ICompilationTarget.instance.memorySize(elementDt)
         when(elementDt) {
             DataType.UBYTE, DataType.BYTE -> {
                 asmgen.out("""
@@ -793,7 +793,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
     }
 
     private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexValue1: NumericLiteralValue, arrayVarName2: String, indexName2: IdentifierReference) {
-        val index1 = indexValue1.number.toInt() * CompilationTarget.instance.memorySize(elementDt)
+        val index1 = indexValue1.number.toInt() * ICompilationTarget.instance.memorySize(elementDt)
         val idxAsmName2 = asmgen.asmVariableName(indexName2)
         when(elementDt) {
             DataType.UBYTE, DataType.BYTE -> {
@@ -852,7 +852,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
 
     private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexName1: IdentifierReference, arrayVarName2: String, indexValue2: NumericLiteralValue) {
         val idxAsmName1 = asmgen.asmVariableName(indexName1)
-        val index2 = indexValue2.number.toInt() * CompilationTarget.instance.memorySize(elementDt)
+        val index2 = indexValue2.number.toInt() * ICompilationTarget.instance.memorySize(elementDt)
         when(elementDt) {
             DataType.UBYTE, DataType.BYTE -> {
                 asmgen.out("""
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt
index 62a3c0ca3..83b8e2f80 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt
@@ -9,7 +9,7 @@ import prog8.ast.statements.Subroutine
 import prog8.ast.toHex
 import prog8.compiler.AssemblyError
 import prog8.compiler.functions.BuiltinFunctions
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.CpuType
 import prog8.compiler.target.subroutineFloatEvalResultVar1
 import kotlin.math.absoluteValue
@@ -1394,7 +1394,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 when(typecast.type) {
                     DataType.UBYTE, DataType.BYTE -> {}
                     DataType.UWORD, DataType.WORD -> {
-                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
                             asmgen.out("  stz  P8ESTACK_HI+1,x")
                         else
                             asmgen.out("  lda  #0  |  sta  P8ESTACK_HI+1,x")
@@ -1460,7 +1460,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
 
         fun assignViaExprEval() {
             asmgen.assignExpressionToVariable(expr.addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
-            if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+            if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
                 if (pushResultOnEstack) {
                     asmgen.out("  lda  (P8ZP_SCRATCH_W2) |  dex |  sta  P8ESTACK_LO+1,x")
                 } else {
@@ -1674,7 +1674,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                         }
                         DataType.UWORD -> {
                             if(amount>=16) {
-                                if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                                if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
                                     asmgen.out("  stz  P8ESTACK_LO+1,x |  stz  P8ESTACK_HI+1,x")
                                 else
                                     asmgen.out("  lda  #0 |  sta  P8ESTACK_LO+1,x |  sta  P8ESTACK_HI+1,x")
@@ -1889,7 +1889,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
         val elementDt = elementIDt.typeOrElse(DataType.STRUCT)
         val arrayVarName = asmgen.asmVariableName(arrayExpr.arrayvar)
         if(arrayExpr.indexer.indexNum!=null) {
-            val indexValue = arrayExpr.indexer.constIndex()!! * CompilationTarget.instance.memorySize(elementDt)
+            val indexValue = arrayExpr.indexer.constIndex()!! * ICompilationTarget.instance.memorySize(elementDt)
             when(elementDt) {
                 in ByteDatatypes -> {
                     asmgen.out("  lda  $arrayVarName+$indexValue |  sta  P8ESTACK_LO,x |  dex")
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt
index 2054d49b5..2a9698c32 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt
@@ -7,7 +7,7 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.compiler.AssemblyError
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.CpuType
 import prog8.compiler.target.c64.codegen.assignment.AsmAssignSource
 import prog8.compiler.target.c64.codegen.assignment.AsmAssignTarget
@@ -169,7 +169,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                                 lda  P8ESTACK_LO$plusIdxStr,x
                                 sta  cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}
                             """)
-                            if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                                 asmgen.out("  stz  cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}+1")
                             else
                                 asmgen.out("  lda  #0 |  sta  cx16.${argi.value.second.registerOrPair.toString().toLowerCase()}+1")
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt
index 54caf438f..30b3ad28b 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt
@@ -7,7 +7,7 @@ import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.statements.PostIncrDecr
 import prog8.ast.toHex
 import prog8.compiler.AssemblyError
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 
 
 internal class PostIncrDecrAsmGen(private val program: Program, private val asmgen: AsmGen) {
@@ -68,7 +68,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
                 val asmArrayvarname = asmgen.asmVariableName(targetArrayIdx.arrayvar)
                 val elementDt = targetArrayIdx.inferType(program).typeOrElse(DataType.STRUCT)
                 if(targetArrayIdx.indexer.indexNum!=null) {
-                    val indexValue = targetArrayIdx.indexer.constIndex()!! * CompilationTarget.instance.memorySize(elementDt)
+                    val indexValue = targetArrayIdx.indexer.constIndex()!! * ICompilationTarget.instance.memorySize(elementDt)
                     when(elementDt) {
                         in ByteDatatypes -> asmgen.out(if (incr) "  inc  $asmArrayvarname+$indexValue" else "  dec  $asmArrayvarname+$indexValue")
                         in WordDatatypes -> {
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt
index e2bfafb0d..503d2c88a 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AsmAssignment.kt
@@ -5,7 +5,7 @@ import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.compiler.AssemblyError
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.c64.codegen.AsmGen
 
 
@@ -212,7 +212,7 @@ internal class AsmAssignment(val source: AsmAssignSource,
     init {
         if(target.register !in setOf(RegisterOrPair.XY, RegisterOrPair.AX, RegisterOrPair.AY))
             require(source.datatype != DataType.STRUCT) { "must not be placeholder datatype" }
-            require(CompilationTarget.instance.memorySize(source.datatype) <= CompilationTarget.instance.memorySize(target.datatype)) {
+            require(ICompilationTarget.instance.memorySize(source.datatype) <= ICompilationTarget.instance.memorySize(target.datatype)) {
                 "source storage size must be less or equal to target datatype storage size"
             }
     }
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt
index 4646d49f6..f651ed485 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt
@@ -8,7 +8,7 @@ import prog8.ast.toHex
 import prog8.compiler.AssemblyError
 import prog8.compiler.functions.BuiltinFunctions
 import prog8.compiler.functions.builtinFunctionReturnType
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.CpuType
 import prog8.compiler.target.c64.codegen.AsmGen
 import prog8.compiler.target.c64.codegen.ExpressionsAsmGen
@@ -66,7 +66,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 val arrayVarName = asmgen.asmVariableName(value.arrayvar)
                 if (value.indexer.indexNum!=null) {
                     // constant array index value
-                    val indexValue = value.indexer.constIndex()!! * CompilationTarget.instance.memorySize(elementDt)
+                    val indexValue = value.indexer.constIndex()!! * ICompilationTarget.instance.memorySize(elementDt)
                     when (elementDt) {
                         in ByteDatatypes -> {
                             asmgen.out("  lda  $arrayVarName+$indexValue")
@@ -114,7 +114,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             SourceStorageKind.MEMORY -> {
                 fun assignViaExprEval(expression: Expression) {
                     assignExpressionToVariable(expression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, assign.target.scope)
-                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  lda  (P8ZP_SCRATCH_W2)")
                     else
                         asmgen.out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y")
@@ -319,7 +319,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
 
                     fun assignViaExprEval(addressExpression: Expression) {
                         asmgen.assignExpressionToVariable(addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
-                        if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("  lda  (P8ZP_SCRATCH_W2)")
                         else
                             asmgen.out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y")
@@ -473,7 +473,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
                     }
                     DataType.UWORD, DataType.WORD -> {
-                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
                             asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  stz  $targetAsmVarName+1")
                         else
                             asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
@@ -496,7 +496,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
                     }
                     DataType.UWORD -> {
-                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
                             asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  stz  $targetAsmVarName+1")
                         else
                             asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
@@ -592,7 +592,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName")
                     }
                     DataType.UWORD, DataType.WORD -> {
-                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
                             asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  stz  $targetAsmVarName+1")
                         else
                             asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
@@ -620,7 +620,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName")
                     }
                     DataType.UWORD -> {
-                        if(CompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
                             asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  stz  $targetAsmVarName+1")
                         else
                             asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
@@ -762,7 +762,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             TargetStorageKind.ARRAY -> {
                 if(target.constArrayIndexValue!=null) {
-                    val scaledIdx = target.constArrayIndexValue!! * CompilationTarget.instance.memorySize(target.datatype)
+                    val scaledIdx = target.constArrayIndexValue!! * ICompilationTarget.instance.memorySize(target.datatype)
                     when(target.datatype) {
                         in ByteDatatypes -> {
                             asmgen.out(" inx | lda  P8ESTACK_LO,x  | sta  ${target.asmVarname}+$scaledIdx")
@@ -968,7 +968,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             TargetStorageKind.ARRAY -> {
                 target.array!!
                 if(target.constArrayIndexValue!=null) {
-                    val scaledIdx = target.constArrayIndexValue!! * CompilationTarget.instance.memorySize(target.datatype)
+                    val scaledIdx = target.constArrayIndexValue!! * ICompilationTarget.instance.memorySize(target.datatype)
                     when(target.datatype) {
                         in ByteDatatypes -> {
                             asmgen.out(" lda  $sourceName  | sta  ${target.asmVarname}+$scaledIdx")
@@ -1191,7 +1191,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             TargetStorageKind.ARRAY -> {
                 if (target.constArrayIndexValue!=null) {
-                    val scaledIdx = target.constArrayIndexValue!! * CompilationTarget.instance.memorySize(target.datatype)
+                    val scaledIdx = target.constArrayIndexValue!! * ICompilationTarget.instance.memorySize(target.datatype)
                     asmgen.out(" lda  $sourceName  | sta  ${target.asmVarname}+$scaledIdx")
                 }
                 else {
@@ -1295,7 +1295,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         when(wordtarget.kind) {
             TargetStorageKind.VARIABLE -> {
                 asmgen.out("  lda  $sourceName |  sta  ${wordtarget.asmVarname}")
-                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                     asmgen.out("  stz  ${wordtarget.asmVarname}+1")
                 else
                     asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
@@ -1304,7 +1304,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 if (wordtarget.constArrayIndexValue!=null) {
                     val scaledIdx = wordtarget.constArrayIndexValue!! * 2
                     asmgen.out("  lda  $sourceName  | sta  ${wordtarget.asmVarname}+$scaledIdx")
-                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  ${wordtarget.asmVarname}+$scaledIdx+1")
                     else
                         asmgen.out("  lda  #0  | sta  ${wordtarget.asmVarname}+$scaledIdx+1")
@@ -1329,7 +1329,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             TargetStorageKind.STACK -> {
                 asmgen.out("  lda  $sourceName |  sta  P8ESTACK_LO,x")
-                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                     asmgen.out("  stz  P8ESTACK_HI,x |  dex")
                 else
                     asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
@@ -1571,7 +1571,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
     }
 
     private fun assignConstantWord(target: AsmAssignTarget, word: Int) {
-        if(word==0 && CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+        if(word==0 && ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
             // optimize setting zero value for this processor
             when(target.kind) {
                 TargetStorageKind.VARIABLE -> {
@@ -1666,7 +1666,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
     }
 
     private fun assignConstantByte(target: AsmAssignTarget, byte: Short) {
-        if(byte==0.toShort() && CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+        if(byte==0.toShort() && ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
             // optimize setting zero value for this cpu
             when(target.kind) {
                 TargetStorageKind.VARIABLE -> {
@@ -1736,7 +1736,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
                 in Cx16VirtualRegisters -> {
                     asmgen.out("  lda  #${byte.toHex()} |  sta  cx16.${target.register.toString().toLowerCase()}")
-                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  cx16.${target.register.toString().toLowerCase()}+1\n")
                     else
                         asmgen.out("  lda  #0 |  sta  cx16.${target.register.toString().toLowerCase()}+1\n")
@@ -1757,7 +1757,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             // optimized case for float zero
             when(target.kind) {
                 TargetStorageKind.VARIABLE -> {
-                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("""
                             stz  ${target.asmVarname}
                             stz  ${target.asmVarname}+1
@@ -1777,8 +1777,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
                 TargetStorageKind.ARRAY -> {
                     if (target.array!!.indexer.indexNum!=null) {
-                        val indexValue = target.array.indexer.constIndex()!! * CompilationTarget.instance.memorySize(DataType.FLOAT)
-                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        val indexValue = target.array.indexer.constIndex()!! * ICompilationTarget.instance.memorySize(DataType.FLOAT)
+                        if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("""
                                 stz  ${target.asmVarname}+$indexValue
                                 stz  ${target.asmVarname}+$indexValue+1
@@ -1842,7 +1842,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 TargetStorageKind.ARRAY -> {
                     val arrayVarName = target.asmVarname
                     if (target.array!!.indexer.indexNum!=null) {
-                        val indexValue = target.array.indexer.constIndex()!! * CompilationTarget.instance.memorySize(DataType.FLOAT)
+                        val indexValue = target.array.indexer.constIndex()!! * ICompilationTarget.instance.memorySize(DataType.FLOAT)
                         asmgen.out("""
                             lda  $constFloat
                             sta  $arrayVarName+$indexValue
@@ -1975,7 +1975,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             when(wordtarget.kind) {
                 TargetStorageKind.VARIABLE -> {
                     asmgen.out("  lda  ${address.toHex()} |  sta  ${wordtarget.asmVarname}")
-                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  ${wordtarget.asmVarname}+1")
                     else
                         asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
@@ -1991,7 +1991,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
                 TargetStorageKind.STACK -> {
                     asmgen.out("  lda  ${address.toHex()} |  sta  P8ESTACK_LO,x")
-                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  P8ESTACK_HI,x |  dex")
                     else
                         asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
@@ -2003,7 +2003,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 TargetStorageKind.VARIABLE -> {
                     asmgen.loadByteFromPointerIntoA(identifier)
                     asmgen.out(" sta  ${wordtarget.asmVarname}")
-                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  ${wordtarget.asmVarname}+1")
                     else
                         asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
@@ -2023,7 +2023,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 TargetStorageKind.STACK -> {
                     asmgen.loadByteFromPointerIntoA(identifier)
                     asmgen.out("  sta  P8ESTACK_LO,x")
-                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  P8ESTACK_HI,x |  dex")
                     else
                         asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
@@ -2041,7 +2041,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             when(addressExpr) {
                 is NumericLiteralValue, is IdentifierReference -> {
                     assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
-                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  sta  (P8ZP_SCRATCH_W2)")
                     else
                         asmgen.out("  ldy  #0 |  sta  (P8ZP_SCRATCH_W2),y")
@@ -2051,7 +2051,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     asmgen.out("  pha")
                     assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
                     asmgen.out("  pla")
-                    if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  sta  (P8ZP_SCRATCH_W2)")
                     else
                         asmgen.out("  ldy  #0 |  sta  (P8ZP_SCRATCH_W2),y")
@@ -2063,7 +2063,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             val sourceName = asmgen.asmVariableName(pointervar)
             val vardecl = pointervar.targetVarDecl(program)!!
             val scopedName = vardecl.makeScopedName(vardecl.name)
-            if (CompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+            if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
                 if (asmgen.isZpVar(scopedName)) {
                     // pointervar is already in the zero page, no need to copy
                     asmgen.out("  sta  ($sourceName)")
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt
index 87b544382..251befb38 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AugmentableAssignmentAsmGen.kt
@@ -6,7 +6,7 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.Subroutine
 import prog8.ast.toHex
 import prog8.compiler.AssemblyError
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.CpuType
 import prog8.compiler.target.Cx16Target
 import prog8.compiler.target.c64.codegen.AsmGen
@@ -202,7 +202,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 with(target.array!!.indexer) {
                     when {
                         indexNum!=null -> {
-                            val targetVarName = "${target.asmVarname} + ${indexNum!!.number.toInt()*CompilationTarget.instance.memorySize(target.datatype)}"
+                            val targetVarName = "${target.asmVarname} + ${indexNum!!.number.toInt()*ICompilationTarget.instance.memorySize(target.datatype)}"
                             when(target.datatype) {
                                 in ByteDatatypes -> {
                                     when {
@@ -632,7 +632,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             }
             "<<" -> {
                 if(value>=8) {
-                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  $name")
                     else
                         asmgen.out("  lda  #0 |  sta  $name")
@@ -643,7 +643,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                 if(value>0) {
                     if (dt == DataType.UBYTE) {
                         if(value>=8) {
-                            if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                                 asmgen.out("  stz  $name")
                             else
                                 asmgen.out("  lda  #0 |  sta  $name")
@@ -858,14 +858,14 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             "<<" -> {
                 when {
                     value>=16 -> {
-                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("  stz  $name |  stz  $name+1")
                         else
                             asmgen.out("  lda  #0 |  sta  $name |  sta  $name+1")
                     }
                     value==8 -> {
                         asmgen.out("  lda  $name |  sta  $name+1")
-                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("  stz  $name")
                         else
                             asmgen.out("  lda  #0 |  sta  $name")
@@ -885,14 +885,14 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     if(dt==DataType.UWORD) {
                         when {
                             value>=16 -> {
-                                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                                     asmgen.out("  stz  $name |  stz  $name+1")
                                 else
                                     asmgen.out("  lda  #0 |  sta  $name |  sta  $name+1")
                             }
                             value==8 -> {
                                 asmgen.out("  lda  $name+1 |  sta  $name")
-                                if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                                     asmgen.out("  stz  $name+1")
                                 else
                                     asmgen.out("  lda  #0 |  sta  $name+1")
@@ -941,13 +941,13 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
             "&", "and" -> {
                 when {
                     value == 0 -> {
-                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("  stz  $name |  stz  $name+1")
                         else
                             asmgen.out("  lda  #0 |  sta  $name |  sta  $name+1")
                     }
                     value and 255 == 0 -> {
-                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("  stz  $name")
                         else
                             asmgen.out("  lda  #0 |  sta  $name")
@@ -955,7 +955,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     }
                     value < 0x0100 -> {
                         asmgen.out("  lda  $name |  and  #$value |  sta  $name")
-                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("  stz  $name+1")
                         else
                             asmgen.out("  lda  #0 |  sta  $name+1")
@@ -1042,7 +1042,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     }
                     "*" -> {
                         asmgen.out("  lda  $otherName |  sta  P8ZP_SCRATCH_W1")
-                        if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("  stz  P8ZP_SCRATCH_W1+1")
                         else
                             asmgen.out("  lda  #0 |  sta  P8ZP_SCRATCH_W1+1")
@@ -1093,7 +1093,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                     "&", "and" -> {
                         asmgen.out("  lda  $otherName |  and  $name |  sta  $name")
                         if(dt in WordDatatypes) {
-                            if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                                 asmgen.out("  stz  $name+1")
                             else
                                 asmgen.out("  lda  #0 |  sta  $name+1")
@@ -1352,7 +1352,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                         asmgen.out("  and  $name |  sta  $name")
                         if(dt in WordDatatypes) {
-                            if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                            if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                                 asmgen.out("  stz  $name+1")
                             else
                                 asmgen.out("  lda  #0 |  sta  $name+1")
@@ -1475,7 +1475,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         asmgen.saveRegisterLocal(CpuRegister.X, scope)
         when (operator) {
             "**" -> {
-                if(CompilationTarget.instance is Cx16Target) {
+                if(ICompilationTarget.instance is Cx16Target) {
                     // cx16 doesn't have FPWR() only FPWRT()
                     asmgen.out("""
                         lda  #<$name
@@ -1553,7 +1553,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         asmgen.saveRegisterLocal(CpuRegister.X, scope)
         when (operator) {
             "**" -> {
-                if(CompilationTarget.instance is Cx16Target) {
+                if(ICompilationTarget.instance is Cx16Target) {
                     // cx16 doesn't have FPWR() only FPWRT()
                     asmgen.out("""
                         lda  #<$name
@@ -1645,7 +1645,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                         DataType.UBYTE, DataType.BYTE -> {
                             when(target.kind) {
                                 TargetStorageKind.VARIABLE -> {
-                                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                                         asmgen.out(" stz  ${target.asmVarname}+1")
                                     else
                                         asmgen.out(" lda  #0 |  sta  ${target.asmVarname}+1")
@@ -1655,7 +1655,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                     asmgen.out("  lda  #0 |  sta  ${target.asmVarname},y")
                                 }
                                 TargetStorageKind.STACK -> {
-                                    if(CompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
                                         asmgen.out(" stz  P8ESTACK_HI+1,x")
                                     else
                                         asmgen.out(" lda  #0 |  sta  P8ESTACK_HI+1,x")
diff --git a/compiler/src/prog8/optimizer/BinExprSplitter.kt b/compiler/src/prog8/optimizer/BinExprSplitter.kt
index f624ae7cf..517768a65 100644
--- a/compiler/src/prog8/optimizer/BinExprSplitter.kt
+++ b/compiler/src/prog8/optimizer/BinExprSplitter.kt
@@ -7,7 +7,7 @@ import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.Assignment
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 
 
 internal class BinExprSplitter(private val program: Program) : AstWalker() {
@@ -80,7 +80,7 @@ X =      BinExpr                                    X   =   LeftExpr
 
     private fun isSimpleTarget(target: AssignTarget, program: Program) =
             if (target.identifier!=null || target.memoryAddress!=null)
-                CompilationTarget.instance.isInRegularRAM(target, program)
+                ICompilationTarget.instance.isInRegularRAM(target, program)
             else
                 false
 
diff --git a/compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt b/compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt
index b074d79e4..372425c93 100644
--- a/compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt
+++ b/compiler/src/prog8/optimizer/ConstantFoldingOptimizer.kt
@@ -9,7 +9,7 @@ import prog8.ast.statements.ForLoop
 import prog8.ast.statements.VarDecl
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import kotlin.math.pow
 
 
@@ -224,7 +224,7 @@ internal class ConstantFoldingOptimizer(private val program: Program) : AstWalke
                     range.step
                 }
 
-            return RangeExpr(fromCast.valueOrZero(), toCast.valueOrZero(), newStep, CompilationTarget.instance, range.position)
+            return RangeExpr(fromCast.valueOrZero(), toCast.valueOrZero(), newStep, ICompilationTarget.instance, range.position)
         }
 
         // adjust the datatype of a range expression in for loops to the loop variable.
diff --git a/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt b/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt
index 0f97a3072..c03349fec 100644
--- a/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt
+++ b/compiler/src/prog8/optimizer/ConstantIdentifierReplacer.kt
@@ -11,7 +11,7 @@ import prog8.ast.statements.VarDecl
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.compiler.ErrorReporter
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 
 // Fix up the literal value's type to match that of the vardecl
 internal class VarConstantValueTypeAdjuster(private val program: Program, private val errors: ErrorReporter) : AstWalker() {
@@ -192,7 +192,7 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                     if(rangeExpr==null && litval!=null) {
                         // arraysize initializer is a single int, and we know the size.
                         val fillvalue = litval.number.toDouble()
-                        if (fillvalue < CompilationTarget.instance.machine.FLOAT_MAX_NEGATIVE || fillvalue > CompilationTarget.instance.machine.FLOAT_MAX_POSITIVE)
+                        if (fillvalue < ICompilationTarget.instance.machine.FLOAT_MAX_NEGATIVE || fillvalue > ICompilationTarget.instance.machine.FLOAT_MAX_POSITIVE)
                             errors.err("float value overflow", litval.position)
                         else {
                             // create the array itself, filled with the fillvalue.
diff --git a/compiler/src/prog8/optimizer/StatementOptimizer.kt b/compiler/src/prog8/optimizer/StatementOptimizer.kt
index 988e047d2..a0bf1bbd5 100644
--- a/compiler/src/prog8/optimizer/StatementOptimizer.kt
+++ b/compiler/src/prog8/optimizer/StatementOptimizer.kt
@@ -11,7 +11,7 @@ import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.ast.walk.IAstVisitor
 import prog8.compiler.ErrorReporter
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import kotlin.math.floor
 
 
@@ -96,7 +96,7 @@ internal class StatementOptimizer(private val program: Program,
                 if(string!=null) {
                     val pos = functionCallStatement.position
                     if (string.value.length == 1) {
-                        val firstCharEncoded = CompilationTarget.instance.encodeString(string.value, string.altEncoding)[0]
+                        val firstCharEncoded = ICompilationTarget.instance.encodeString(string.value, string.altEncoding)[0]
                         val chrout = FunctionCallStatement(
                                 IdentifierReference(listOf("c64", "CHROUT"), pos),
                                 mutableListOf(NumericLiteralValue(DataType.UBYTE, firstCharEncoded.toInt(), pos)),
@@ -104,7 +104,7 @@ internal class StatementOptimizer(private val program: Program,
                         )
                         return listOf(IAstModification.ReplaceNode(functionCallStatement, chrout, parent))
                     } else if (string.value.length == 2) {
-                        val firstTwoCharsEncoded = CompilationTarget.instance.encodeString(string.value.take(2), string.altEncoding)
+                        val firstTwoCharsEncoded = ICompilationTarget.instance.encodeString(string.value.take(2), string.altEncoding)
                         val chrout1 = FunctionCallStatement(
                                 IdentifierReference(listOf("c64", "CHROUT"), pos),
                                 mutableListOf(NumericLiteralValue(DataType.UBYTE, firstTwoCharsEncoded[0].toInt(), pos)),
@@ -212,7 +212,7 @@ internal class StatementOptimizer(private val program: Program,
                 val size = sv.value.length
                 if(size==1) {
                     // loop over string of length 1 -> just assign the single character
-                    val character = CompilationTarget.instance.encodeString(sv.value, sv.altEncoding)[0]
+                    val character = ICompilationTarget.instance.encodeString(sv.value, sv.altEncoding)[0]
                     val byte = NumericLiteralValue(DataType.UBYTE, character, iterable.position)
                     val scope = AnonymousScope(mutableListOf(), forLoop.position)
                     scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), byte, forLoop.position))
diff --git a/compiler/src/prog8/optimizer/UnusedCodeRemover.kt b/compiler/src/prog8/optimizer/UnusedCodeRemover.kt
index d830298c9..5beac5e7c 100644
--- a/compiler/src/prog8/optimizer/UnusedCodeRemover.kt
+++ b/compiler/src/prog8/optimizer/UnusedCodeRemover.kt
@@ -11,7 +11,7 @@ import prog8.ast.expressions.TypecastExpression
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 
 
 internal class UnusedCodeRemover(private val program: Program, private val errors: ErrorReporter): AstWalker() {
@@ -96,7 +96,7 @@ internal class UnusedCodeRemover(private val program: Program, private val error
             val assign1 = stmtPairs[0] as? Assignment
             val assign2 = stmtPairs[1] as? Assignment
             if (assign1 != null && assign2 != null && !assign2.isAugmentable) {
-                if (assign1.target.isSameAs(assign2.target, program) && CompilationTarget.instance.isInRegularRAM(assign1.target, program))  {
+                if (assign1.target.isSameAs(assign2.target, program) && ICompilationTarget.instance.isInRegularRAM(assign1.target, program))  {
                     if(assign2.target.identifier==null || !assign2.value.referencesIdentifier(*(assign2.target.identifier!!.nameInSource.toTypedArray())))
                         // only remove the second assignment if its value is a simple expression!
                         when(assign2.value) {
diff --git a/compiler/test/UnitTests.kt b/compiler/test/UnitTests.kt
index d7b8beefc..1607f9592 100644
--- a/compiler/test/UnitTests.kt
+++ b/compiler/test/UnitTests.kt
@@ -14,7 +14,7 @@ import prog8.ast.statements.*
 import prog8.ast.toHex
 import prog8.compiler.*
 import prog8.compiler.target.C64Target
-import prog8.compiler.target.CompilationTarget
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.c64.C64MachineDefinition.C64Zeropage
 import prog8.compiler.target.c64.C64MachineDefinition.FLOAT_MAX_NEGATIVE
 import prog8.compiler.target.c64.C64MachineDefinition.FLOAT_MAX_POSITIVE
@@ -415,67 +415,67 @@ class TestMemory {
 
     @Test
     fun testInValidRamC64_memory_addresses() {
-        CompilationTarget.instance = C64Target
+        ICompilationTarget.instance = C64Target
 
         var memexpr = NumericLiteralValue.optimalInteger(0x0000, Position.DUMMY)
         var target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         val program = Program("test", mutableListOf(), DummyFunctions())
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
 
         memexpr = NumericLiteralValue.optimalInteger(0x1000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
 
         memexpr = NumericLiteralValue.optimalInteger(0x9fff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
 
         memexpr = NumericLiteralValue.optimalInteger(0xc000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
 
         memexpr = NumericLiteralValue.optimalInteger(0xcfff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
     }
 
     @Test
     fun testNotInValidRamC64_memory_addresses() {
-        CompilationTarget.instance = C64Target
+        ICompilationTarget.instance = C64Target
 
         var memexpr = NumericLiteralValue.optimalInteger(0xa000, Position.DUMMY)
         var target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         val program = Program("test", mutableListOf(), DummyFunctions())
-        assertFalse(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertFalse(ICompilationTarget.instance.isInRegularRAM(target, program))
 
         memexpr = NumericLiteralValue.optimalInteger(0xafff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assertFalse(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertFalse(ICompilationTarget.instance.isInRegularRAM(target, program))
 
         memexpr = NumericLiteralValue.optimalInteger(0xd000, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assertFalse(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertFalse(ICompilationTarget.instance.isInRegularRAM(target, program))
 
         memexpr = NumericLiteralValue.optimalInteger(0xffff, Position.DUMMY)
         target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
-        assertFalse(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertFalse(ICompilationTarget.instance.isInRegularRAM(target, program))
     }
 
     @Test
     fun testInValidRamC64_memory_identifiers() {
-        CompilationTarget.instance = C64Target
+        ICompilationTarget.instance = C64Target
         var target = createTestProgramForMemoryRefViaVar(0x1000, VarDeclType.VAR)
         val program = Program("test", mutableListOf(), DummyFunctions())
 
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
         target = createTestProgramForMemoryRefViaVar(0xd020, VarDeclType.VAR)
-        assertFalse(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertFalse(ICompilationTarget.instance.isInRegularRAM(target, program))
         target = createTestProgramForMemoryRefViaVar(0x1000, VarDeclType.CONST)
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
         target = createTestProgramForMemoryRefViaVar(0xd020, VarDeclType.CONST)
-        assertFalse(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertFalse(ICompilationTarget.instance.isInRegularRAM(target, program))
         target = createTestProgramForMemoryRefViaVar(0x1000, VarDeclType.MEMORY)
-        assertFalse(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertFalse(ICompilationTarget.instance.isInRegularRAM(target, program))
     }
 
     @Test
@@ -492,16 +492,16 @@ class TestMemory {
 
     @Test
     fun testInValidRamC64_memory_expression() {
-        CompilationTarget.instance = C64Target
+        ICompilationTarget.instance = C64Target
         val memexpr = PrefixExpression("+", NumericLiteralValue.optimalInteger(0x1000, Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, null, DirectMemoryWrite(memexpr, Position.DUMMY), Position.DUMMY)
         val program = Program("test", mutableListOf(), DummyFunctions())
-        assertFalse(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertFalse(ICompilationTarget.instance.isInRegularRAM(target, program))
     }
 
     @Test
     fun testInValidRamC64_variable() {
-        CompilationTarget.instance = C64Target
+        ICompilationTarget.instance = C64Target
         val decl = VarDecl(VarDeclType.VAR, DataType.BYTE, ZeropageWish.DONTCARE, null, "address", null, null, false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
         val assignment = Assignment(target, NumericLiteralValue.optimalInteger(0, Position.DUMMY), Position.DUMMY)
@@ -509,12 +509,12 @@ class TestMemory {
         val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of(""))
         val program = Program("test", mutableListOf(module), DummyFunctions())
         module.linkParents(ParentSentinel)
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
     }
 
     @Test
     fun testInValidRamC64_memmap_variable() {
-        CompilationTarget.instance = C64Target
+        ICompilationTarget.instance = C64Target
         val address = 0x1000
         val decl = VarDecl(VarDeclType.MEMORY, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
@@ -523,12 +523,12 @@ class TestMemory {
         val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of(""))
         val program = Program("test", mutableListOf(module), DummyFunctions())
         module.linkParents(ParentSentinel)
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
     }
 
     @Test
     fun testNotInValidRamC64_memmap_variable() {
-        CompilationTarget.instance = C64Target
+        ICompilationTarget.instance = C64Target
         val address = 0xd020
         val decl = VarDecl(VarDeclType.MEMORY, DataType.UBYTE, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val target = AssignTarget(IdentifierReference(listOf("address"), Position.DUMMY), null, null, Position.DUMMY)
@@ -537,12 +537,12 @@ class TestMemory {
         val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of(""))
         val program = Program("test", mutableListOf(module), DummyFunctions())
         module.linkParents(ParentSentinel)
-        assertFalse(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertFalse(ICompilationTarget.instance.isInRegularRAM(target, program))
     }
 
     @Test
     fun testInValidRamC64_array() {
-        CompilationTarget.instance = C64Target
+        ICompilationTarget.instance = C64Target
         val decl = VarDecl(VarDeclType.VAR, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, null, false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
         val target = AssignTarget(null, arrayindexed, null, Position.DUMMY)
@@ -551,12 +551,12 @@ class TestMemory {
         val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of(""))
         val program = Program("test", mutableListOf(module), DummyFunctions())
         module.linkParents(ParentSentinel)
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
     }
 
     @Test
     fun testInValidRamC64_array_memmapped() {
-        CompilationTarget.instance = C64Target
+        ICompilationTarget.instance = C64Target
         val address = 0x1000
         val decl = VarDecl(VarDeclType.MEMORY, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
@@ -566,12 +566,12 @@ class TestMemory {
         val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of(""))
         val program = Program("test", mutableListOf(module), DummyFunctions())
         module.linkParents(ParentSentinel)
-        assertTrue(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertTrue(ICompilationTarget.instance.isInRegularRAM(target, program))
     }
 
     @Test
     fun testNotValidRamC64_array_memmapped() {
-        CompilationTarget.instance = C64Target
+        ICompilationTarget.instance = C64Target
         val address = 0xe000
         val decl = VarDecl(VarDeclType.MEMORY, DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, "address", null, NumericLiteralValue.optimalInteger(address, Position.DUMMY), false, false, Position.DUMMY)
         val arrayindexed = ArrayIndexedExpression(IdentifierReference(listOf("address"), Position.DUMMY), ArrayIndex(NumericLiteralValue.optimalInteger(1, Position.DUMMY), Position.DUMMY), Position.DUMMY)
@@ -581,6 +581,6 @@ class TestMemory {
         val module = Module("test", mutableListOf(subroutine), Position.DUMMY, false, Path.of(""))
         val program = Program("test", mutableListOf(module), DummyFunctions())
         module.linkParents(ParentSentinel)
-        assertFalse(CompilationTarget.instance.isInRegularRAM(target, program))
+        assertFalse(ICompilationTarget.instance.isInRegularRAM(target, program))
     }
 }