diff --git a/.gitignore b/.gitignore
index adc560b..35031c9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,4 +5,6 @@
 build/
 
 .idea/workspace.xml
+.idea/dictionaries/
+.idea/inspectionProfiles/
 .attach_pid*
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 455250f..f502804 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -4,7 +4,7 @@
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
     <MarkdownNavigatorCodeStyleSettings>
-      <option name="RIGHT_MARGIN" value="72" />
+      <option name="RIGHT_MARGIN" value="80" />
     </MarkdownNavigatorCodeStyleSettings>
     <codeStyleSettings language="kotlin">
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 8dd54ae..37e5426 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
diff --git a/src/main/kotlin/razorvine/examplemachine/GUI.kt b/src/main/kotlin/razorvine/examplemachine/GUI.kt
new file mode 100644
index 0000000..114f501
--- /dev/null
+++ b/src/main/kotlin/razorvine/examplemachine/GUI.kt
@@ -0,0 +1,360 @@
+package razorvine.examplemachine
+
+import razorvine.ksim65.Cpu6502
+import java.awt.*
+import java.awt.image.BufferedImage
+import java.util.ArrayDeque
+import javax.imageio.ImageIO
+import javax.swing.event.MouseInputListener
+import razorvine.ksim65.IHostInterface
+import java.awt.event.*
+import javax.swing.*
+
+
+/**
+ * Define a monochrome screen that can display 640x480 pixels
+ * and/or 80x30 characters (these are 8x16 pixels).
+ */
+object ScreenDefs {
+    const val SCREEN_WIDTH_CHARS = 80
+    const val SCREEN_HEIGHT_CHARS = 30
+    const val SCREEN_WIDTH = SCREEN_WIDTH_CHARS * 8
+    const val SCREEN_HEIGHT = SCREEN_HEIGHT_CHARS * 16
+    const val DISPLAY_PIXEL_SCALING: Double = 1.5
+    val BG_COLOR = Color(0, 10, 20)
+    val FG_COLOR = Color(200, 255, 230)
+    val BORDER_COLOR = Color(20, 30, 40)
+    val Characters = loadCharacters()
+
+    private fun loadCharacters(): Array<BufferedImage> {
+        val img = ImageIO.read(javaClass.getResource("/charset/unscii8x16.png"))
+        val charactersImage = BufferedImage(img.width, img.height, BufferedImage.TYPE_INT_ARGB)
+        charactersImage.createGraphics().drawImage(img, 0, 0, null)
+
+        val black = Color(0, 0, 0).rgb
+        val foreground = FG_COLOR.rgb
+        val nopixel = Color(0, 0, 0, 0).rgb
+        for (y in 0 until charactersImage.height) {
+            for (x in 0 until charactersImage.width) {
+                val col = charactersImage.getRGB(x, y)
+                if (col == black)
+                    charactersImage.setRGB(x, y, nopixel)
+                else
+                    charactersImage.setRGB(x, y, foreground)
+            }
+        }
+
+        val numColumns = charactersImage.width / 8
+        val charImages = (0..255).map {
+            val charX = it % numColumns
+            val charY = it / numColumns
+            charactersImage.getSubimage(charX * 8, charY * 16, 8, 16)
+        }
+
+        return charImages.toTypedArray()
+    }
+}
+
+private class BitmapScreenPanel : JPanel() {
+
+    private val image = BufferedImage(ScreenDefs.SCREEN_WIDTH, ScreenDefs.SCREEN_HEIGHT, BufferedImage.TYPE_INT_ARGB)
+    private val g2d = image.graphics as Graphics2D
+    private var cursorX: Int = 0
+    private var cursorY: Int = 0
+
+    init {
+        val size = Dimension(
+            (image.width * ScreenDefs.DISPLAY_PIXEL_SCALING).toInt(),
+            (image.height * ScreenDefs.DISPLAY_PIXEL_SCALING).toInt()
+        )
+        minimumSize = size
+        maximumSize = size
+        preferredSize = size
+        clearScreen()
+        isFocusable = true
+        requestFocusInWindow()
+    }
+
+    override fun paint(graphics: Graphics?) {
+        val g2d = graphics as Graphics2D?
+        g2d!!.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF)
+        g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE)
+        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC)
+        g2d.drawImage(
+            image, 0, 0, (image.width * ScreenDefs.DISPLAY_PIXEL_SCALING).toInt(),
+            (image.height * ScreenDefs.DISPLAY_PIXEL_SCALING).toInt(), null
+        )
+    }
+
+    fun clearScreen() {
+        g2d.background = ScreenDefs.BG_COLOR
+        g2d.clearRect(0, 0, ScreenDefs.SCREEN_WIDTH, ScreenDefs.SCREEN_HEIGHT)
+        cursorX = 0
+        cursorY = 0
+    }
+
+    fun setPixel(x: Int, y: Int, onOff: Boolean) {
+        if (onOff)
+            image.setRGB(x, y, ScreenDefs.FG_COLOR.rgb)
+        else
+            image.setRGB(x, y, ScreenDefs.BG_COLOR.rgb)
+    }
+
+    fun getPixel(x: Int, y: Int) = image.getRGB(x, y) != ScreenDefs.BG_COLOR.rgb
+
+    fun setChar(x: Int, y: Int, character: Char) {
+        g2d.clearRect(8 * x, 16 * y, 8, 16)
+        val coloredImage = ScreenDefs.Characters[character.toInt()]
+        g2d.drawImage(coloredImage, 8 * x, 16 * y, null)
+    }
+
+    fun scrollUp() {
+        g2d.copyArea(0, 16, ScreenDefs.SCREEN_WIDTH, ScreenDefs.SCREEN_HEIGHT - 16, 0, -16)
+        g2d.background = ScreenDefs.BG_COLOR
+        g2d.clearRect(0, ScreenDefs.SCREEN_HEIGHT - 16, ScreenDefs.SCREEN_WIDTH, 16)
+    }
+
+    fun mousePixelPosition(): Point? {
+        val pos = mousePosition ?: return null
+        return Point(
+            (pos.x / ScreenDefs.DISPLAY_PIXEL_SCALING).toInt(),
+            (pos.y / ScreenDefs.DISPLAY_PIXEL_SCALING).toInt()
+        )
+    }
+}
+
+class DebugWindow(val vm: VirtualMachine) : JFrame("debugger"), ActionListener {
+    val cyclesTf = JTextField("00000000000000")
+    val regAtf = JTextField("000")
+    val regXtf = JTextField("000")
+    val regYtf = JTextField("000")
+    val regPCtf = JTextField("00000")
+    val regSPtf = JTextField("000")
+    val regPtf = JTextField("000000000")
+    val opcodeTf = JTextField("000")
+    val mnemonicTf = JTextField("brk ")
+    private val pauseBt = JButton("Pause").also { it.actionCommand = "pause" }
+
+    init {
+        isFocusable = true
+        val cpuPanel = JPanel(GridBagLayout())
+        cpuPanel.border = BorderFactory.createTitledBorder("CPU: ${vm.cpu.name}")
+        val gc = GridBagConstraints()
+        gc.insets = Insets(4, 4, 4, 4)
+        gc.anchor = GridBagConstraints.EAST
+        gc.gridx = 0
+        gc.gridy = 0
+        val cyclesLb = JLabel("cycles")
+        val regAlb = JLabel("A")
+        val regXlb = JLabel("X")
+        val regYlb = JLabel("Y")
+        val regSPlb = JLabel("SP")
+        val regPClb = JLabel("PC")
+        val dummyLb = JLabel("")
+        val regPlb = JLabel("Status")
+        val opcodeLb = JLabel("opcode")
+        val mnemonicLb = JLabel("mnemonic")
+        listOf(cyclesLb, regAlb, regXlb, regYlb, regSPlb, regPClb, dummyLb, regPlb, opcodeLb, mnemonicLb).forEach {
+            cpuPanel.add(it, gc)
+            gc.gridy++
+        }
+        gc.anchor = GridBagConstraints.WEST
+        gc.gridx = 1
+        gc.gridy = 0
+        val bitsLb = JTextField("NV-BDIZC")
+        listOf(cyclesTf, regAtf, regXtf, regYtf, regSPtf, regPCtf, bitsLb, regPtf, opcodeTf, mnemonicTf).forEach {
+            it.font = Font(Font.MONOSPACED, Font.PLAIN, 16)
+            it.isEditable = false
+            it.columns = it.text.length
+            cpuPanel.add(it, gc)
+            gc.gridy++
+        }
+        add(cpuPanel, BorderLayout.NORTH)
+
+        val buttonPanel = JPanel(FlowLayout())
+        buttonPanel.border = BorderFactory.createTitledBorder("Control")
+
+        val resetBt = JButton("Reset").also { it.actionCommand = "reset" }
+        val cycleBt = JButton("Cycle").also { it.actionCommand = "cycle" }
+        listOf(resetBt, cycleBt, pauseBt).forEach {
+            it.addActionListener(this)
+            buttonPanel.add(it)
+        }
+
+        add(buttonPanel, BorderLayout.CENTER)
+
+        pack()
+    }
+
+    override fun actionPerformed(e: ActionEvent) {
+        when {
+            e.actionCommand == "reset" -> {
+                vm.bus.reset()
+                updateCpu(vm.cpu)
+            }
+            e.actionCommand == "cycle" -> {
+                vm.bus.clock()
+                updateCpu(vm.cpu)
+            }
+            e.actionCommand == "pause" -> {
+                vm.paused = true
+                pauseBt.actionCommand = "continue"
+                pauseBt.text = "Cont."
+            }
+            e.actionCommand == "continue" -> {
+                vm.paused = false
+                pauseBt.actionCommand = "pause"
+                pauseBt.text = "Pause"
+            }
+        }
+    }
+
+    fun updateCpu(cpu: Cpu6502) {
+        cyclesTf.text = cpu.totalCycles.toString()
+        regAtf.text = cpu.hexB(cpu.regA)
+        regXtf.text = cpu.hexB(cpu.regX)
+        regYtf.text = cpu.hexB(cpu.regY)
+        regPtf.text = cpu.regP.asByte().toString(2).padStart(8, '0')
+        regPCtf.text = cpu.hexW(cpu.regPC)
+        regSPtf.text = cpu.hexB(cpu.regSP)
+        opcodeTf.text = cpu.hexB(cpu.currentOpcode)
+        mnemonicTf.text = cpu.currentMnemonic
+    }
+}
+
+
+class MainWindow(title: String) : JFrame(title), KeyListener, MouseInputListener, IHostInterface {
+    private val canvas = BitmapScreenPanel()
+    val keyboardBuffer = ArrayDeque<Char>()
+    var mousePos = Point(0, 0)
+    var leftButton = false
+    var rightButton = false
+    var middleButton = false
+
+    init {
+        val borderWidth = 16
+        layout = GridBagLayout()
+        defaultCloseOperation = EXIT_ON_CLOSE
+        isResizable = false
+        isFocusable = true
+
+        // the borders (top, left, right, bottom)
+        val borderTop = JPanel().apply {
+            preferredSize = Dimension(
+                (ScreenDefs.DISPLAY_PIXEL_SCALING * (ScreenDefs.SCREEN_WIDTH + 2 * borderWidth)).toInt(),
+                (ScreenDefs.DISPLAY_PIXEL_SCALING * borderWidth).toInt()
+            )
+            background = ScreenDefs.BORDER_COLOR
+        }
+        val borderBottom = JPanel().apply {
+            preferredSize = Dimension(
+                (ScreenDefs.DISPLAY_PIXEL_SCALING * (ScreenDefs.SCREEN_WIDTH + 2 * borderWidth)).toInt(),
+                (ScreenDefs.DISPLAY_PIXEL_SCALING * borderWidth).toInt()
+            )
+            background = ScreenDefs.BORDER_COLOR
+        }
+        val borderLeft = JPanel().apply {
+            preferredSize = Dimension(
+                (ScreenDefs.DISPLAY_PIXEL_SCALING * borderWidth).toInt(),
+                (ScreenDefs.DISPLAY_PIXEL_SCALING * ScreenDefs.SCREEN_HEIGHT).toInt()
+            )
+            background = ScreenDefs.BORDER_COLOR
+        }
+        val borderRight = JPanel().apply {
+            preferredSize = Dimension(
+                (ScreenDefs.DISPLAY_PIXEL_SCALING * borderWidth).toInt(),
+                (ScreenDefs.DISPLAY_PIXEL_SCALING * ScreenDefs.SCREEN_HEIGHT).toInt()
+            )
+            background = ScreenDefs.BORDER_COLOR
+        }
+        var c = GridBagConstraints()
+        c.gridx = 0; c.gridy = 1; c.gridwidth = 3
+        add(borderTop, c)
+        c = GridBagConstraints()
+        c.gridx = 0; c.gridy = 2
+        add(borderLeft, c)
+        c = GridBagConstraints()
+        c.gridx = 2; c.gridy = 2
+        add(borderRight, c)
+        c = GridBagConstraints()
+        c.gridx = 0; c.gridy = 3; c.gridwidth = 3
+        add(borderBottom, c)
+        // the screen canvas(bitmap)
+        c = GridBagConstraints()
+        c.gridx = 1; c.gridy = 2
+        add(canvas, c)
+        addKeyListener(this)
+        addMouseMotionListener(this)
+        addMouseListener(this)
+        pack()
+        requestFocusInWindow()
+        setLocationRelativeTo(null)
+        isVisible = true
+    }
+
+    fun start() {
+        // repaint the screen's back buffer ~60 times per second
+        val repaintTimer = Timer(1000 / 60) { repaint() }
+        repaintTimer.initialDelay = 0
+        repaintTimer.start()
+    }
+
+    // keyboard events:
+    override fun keyTyped(p0: KeyEvent) {
+        println(p0)
+        println("[${p0.keyChar}]")
+        keyboardBuffer.add(p0.keyChar)
+        while (keyboardBuffer.size > 8)
+            keyboardBuffer.pop()
+    }
+
+    override fun keyPressed(p0: KeyEvent) {}
+    override fun keyReleased(p0: KeyEvent) {}
+
+    // mouse events:
+    override fun mousePressed(p0: MouseEvent) {}
+
+    override fun mouseReleased(p0: MouseEvent) {}
+    override fun mouseEntered(p0: MouseEvent) {}
+    override fun mouseExited(p0: MouseEvent) {}
+    override fun mouseDragged(p0: MouseEvent) {}
+    override fun mouseClicked(p0: MouseEvent) {
+        val pos = canvas.mousePixelPosition()
+        if (pos == null)
+            return
+        else {
+            mousePos = pos
+            leftButton = SwingUtilities.isLeftMouseButton(p0)
+            rightButton = SwingUtilities.isRightMouseButton(p0)
+            middleButton = SwingUtilities.isMiddleMouseButton(p0)
+        }
+    }
+
+    override fun mouseMoved(p0: MouseEvent) {
+        val pos = canvas.mousePixelPosition()
+        if (pos == null)
+            return
+        else
+            mousePos = pos
+    }
+
+
+    // the overrides required for IHostDisplay:
+    override fun clearScreen() = canvas.clearScreen()
+
+    override fun setPixel(x: Int, y: Int) = canvas.setPixel(x, y, true)
+    override fun clearPixel(x: Int, y: Int) = canvas.setPixel(x, y, false)
+    override fun getPixel(x: Int, y: Int) = canvas.getPixel(x, y)
+    override fun setChar(x: Int, y: Int, character: Char) = canvas.setChar(x, y, character)
+    override fun scrollUp() = canvas.scrollUp()
+    override fun mouse(): IHostInterface.MouseInfo {
+        return IHostInterface.MouseInfo(mousePos.x, mousePos.y, leftButton, rightButton, middleButton)
+    }
+
+    override fun keyboard(): Char? {
+        return if (keyboardBuffer.isEmpty())
+            null
+        else
+            keyboardBuffer.pop()
+    }
+}
diff --git a/src/main/kotlin/razorvine/examplemachine/systemMain.kt b/src/main/kotlin/razorvine/examplemachine/systemMain.kt
new file mode 100644
index 0000000..7c8bdd6
--- /dev/null
+++ b/src/main/kotlin/razorvine/examplemachine/systemMain.kt
@@ -0,0 +1,84 @@
+package razorvine.examplemachine
+
+import kotlin.concurrent.scheduleAtFixedRate
+import java.time.LocalDateTime
+import razorvine.ksim65.Bus
+import razorvine.ksim65.Cpu6502
+import razorvine.ksim65.Version
+import razorvine.ksim65.components.*
+import razorvine.ksim65.components.Timer
+
+/**
+ * A virtual computer constructed from the various virtual components
+ */
+class VirtualMachine(title: String) {
+    val bus = Bus()
+    val cpu = Cpu6502(false)
+    val ram = Ram(0x0000, 0xffff)
+    private val rtc = RealTimeClock(0xd100, 0xd108)
+    private val timer = Timer(0xd200, 0xd203, cpu)
+
+    private val hostDisplay = MainWindow(title)
+    private val debugWindow = DebugWindow(this)
+    private val display = Display(0xd000, 0xd00a, hostDisplay,
+        ScreenDefs.SCREEN_WIDTH_CHARS, ScreenDefs.SCREEN_HEIGHT_CHARS,
+        ScreenDefs.SCREEN_WIDTH, ScreenDefs.SCREEN_HEIGHT)
+    private val mouse = Mouse(0xd300, 0xd304, hostDisplay)
+    private val keyboard = Keyboard(0xd400, 0xd400, hostDisplay)
+
+    init {
+        ram[Cpu6502.RESET_vector] = 0x00
+        ram[Cpu6502.RESET_vector + 1] = 0x10
+
+        bus += rtc
+        bus += timer
+        bus += display
+        bus += mouse
+        bus += keyboard
+        bus += ram
+        bus += cpu
+        bus.reset()
+
+        hostDisplay.start()
+
+        debugWindow.setLocation(hostDisplay.location.x+hostDisplay.width, hostDisplay.location.y)
+        debugWindow.isVisible = true
+    }
+
+    var paused = false
+
+    fun clock() {
+        if(!paused) {
+            bus.clock()
+            debugWindow.updateCpu(cpu)
+        }
+    }
+}
+
+fun main(args: Array<String>) {
+    val machine = VirtualMachine("KSim65 demo virtual machine - using ksim65 v${Version.version}")
+    val v = 0xd000
+
+    machine.bus[v + 0x08] = 20
+    machine.bus[v + 0x09] = 2
+    val text = ">> Hello this is an example text! 1234567890 <<\n" +
+            "next line 1\n" +
+            "next line 2\n" +
+            "next line 3\rnext line 4\rnext line 5\n" +
+            "a mistakk\be\n\n\n\n\n\n\n\n\n\n"
+    text.forEach {
+        machine.bus[v + 0x0a] = it.toShort()
+    }
+
+    repeat(20) {
+        Thread.sleep(100)
+        "time: ${LocalDateTime.now()}\n".forEach { c ->
+            machine.bus[v + 0x0a] = c.toShort()
+        }
+    }
+
+    val timer = java.util.Timer("clock", true)
+    timer.scheduleAtFixedRate(1, 1) {
+        machine.clock()
+    }
+}
diff --git a/src/main/kotlin/razorvine/ksim65/Bus.kt b/src/main/kotlin/razorvine/ksim65/Bus.kt
index 5726b7f..1b55276 100644
--- a/src/main/kotlin/razorvine/ksim65/Bus.kt
+++ b/src/main/kotlin/razorvine/ksim65/Bus.kt
@@ -27,6 +27,12 @@ class Bus {
         memComponents.forEach { it.clock() }
     }
 
+    operator fun plusAssign(memcomponent: MemMappedComponent) = add(memcomponent)
+    operator fun plusAssign(component: BusComponent) = add(component)
+    operator fun get(address: Address): UByte = read(address)
+    operator fun set(address: Address, data: UByte) = write(address, data)
+
+
     fun add(component: BusComponent) {
         components.add(component)
         component.bus = this
@@ -54,6 +60,7 @@ class Bus {
      * Any memory mapped component that listens to the address, will receive the data.
      */
     fun write(address: Address, data: UByte) {
+        require(data in 0..255) { "data must be a byte 0..255" }
         memComponents.forEach {
             if (address >= it.startAddress && address <= it.endAddress)
                 it[address] = data
diff --git a/src/main/kotlin/razorvine/ksim65/Cpu6502.kt b/src/main/kotlin/razorvine/ksim65/Cpu6502.kt
index 9bdf959..1c2e3f3 100644
--- a/src/main/kotlin/razorvine/ksim65/Cpu6502.kt
+++ b/src/main/kotlin/razorvine/ksim65/Cpu6502.kt
@@ -11,6 +11,7 @@ import razorvine.ksim65.components.UByte
  * TODO: add the optional additional cycles to certain instructions and addressing modes
  */
 open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() {
+    open val name = "6502"
     var tracing: ((state:String) -> Unit)? = null
     var totalCycles: Long = 0
         protected set
@@ -102,6 +103,8 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() {
         protected set
 
     protected lateinit var currentInstruction: Instruction
+    val currentMnemonic: String
+        get() = currentInstruction.mnemonic
 
     // has an interrupt been requested?
     protected var pendingInterrupt: Pair<Boolean, BusComponent>? = null
@@ -249,6 +252,9 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() {
         return result
     }
 
+    /**
+     * Reset the cpu
+     */
     override fun reset() {
         regSP = 0xfd
         regPC = readWord(RESET_vector)
@@ -267,6 +273,9 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() {
         currentInstruction = instructions[0]
     }
 
+    /**
+     * Process once clock cycle in the cpu
+     */
     override fun clock() {
         if (instrCycles == 0) {
             if (pendingInterrupt != null) {
@@ -309,11 +318,13 @@ open class Cpu6502(private val stopOnBrk: Boolean = false) : BusComponent() {
         totalCycles++
     }
 
+    /**
+     * Execute one single complete instruction
+     */
     open fun step() {
-        // step a whole instruction
-        while (instrCycles > 0) clock()        // remaining instruction subcycles from the previous instruction
-        clock()   // the actual instruction execution cycle
-        while (instrCycles > 0) clock()        // instruction subcycles
+        while (instrCycles > 0) clock()
+        clock()
+        while (instrCycles > 0) clock()
     }
 
     fun nmi(source: BusComponent) {
diff --git a/src/main/kotlin/razorvine/ksim65/Cpu65C02.kt b/src/main/kotlin/razorvine/ksim65/Cpu65C02.kt
index dad9224..a6a18bb 100644
--- a/src/main/kotlin/razorvine/ksim65/Cpu65C02.kt
+++ b/src/main/kotlin/razorvine/ksim65/Cpu65C02.kt
@@ -7,6 +7,7 @@ import razorvine.ksim65.components.Address
  * TODO: add the optional additional cycles to certain instructions and addressing modes
  */
 class Cpu65C02(stopOnBrk: Boolean = false) : Cpu6502(stopOnBrk) {
+    override val name = "65C02"
 
     enum class Wait {
         Normal,
@@ -23,6 +24,9 @@ class Cpu65C02(stopOnBrk: Boolean = false) : Cpu6502(stopOnBrk) {
         const val resetCycles = Cpu6502.resetCycles
     }
 
+    /**
+     * Process once clock cycle in the cpu
+     */
     override fun clock() {
         when (waiting) {
             Wait.Normal -> super.clock()
@@ -42,13 +46,15 @@ class Cpu65C02(stopOnBrk: Boolean = false) : Cpu6502(stopOnBrk) {
         }
     }
 
+    /**
+     * Execute one single complete instruction
+     */
     override fun step() {
-        // step a whole instruction
         if (waiting == Wait.Normal) {
-            while (instrCycles > 0) clock()        // remaining instruction subcycles from the previous instruction
-            clock()   // the actual instruction execution cycle
+            while (instrCycles > 0) clock()
+            clock()
             if (waiting == Wait.Normal)
-                while (instrCycles > 0) clock()        // instruction subcycles
+                while (instrCycles > 0) clock()
             else {
                 totalCycles += instrCycles
                 instrCycles = 0
diff --git a/src/main/kotlin/razorvine/ksim65/IHostInterface.kt b/src/main/kotlin/razorvine/ksim65/IHostInterface.kt
new file mode 100644
index 0000000..be84d87
--- /dev/null
+++ b/src/main/kotlin/razorvine/ksim65/IHostInterface.kt
@@ -0,0 +1,18 @@
+package razorvine.ksim65
+
+/**
+ * The virtual machine uses this to interface with the host system,
+ * to connect to the "real" devices.
+ */
+interface IHostInterface {
+    fun clearScreen()
+    fun getPixel(x: Int, y: Int): Boolean
+    fun setPixel(x: Int, y: Int)
+    fun clearPixel(x: Int, y: Int)
+    fun setChar(x: Int, y: Int, character: Char)
+    fun scrollUp()
+    fun mouse(): MouseInfo
+    fun keyboard(): Char?
+
+    class MouseInfo(val x: Int, val y: Int, val left: Boolean, val right: Boolean, val middle: Boolean)
+}
diff --git a/src/main/kotlin/razorvine/ksim65/components/Component.kt b/src/main/kotlin/razorvine/ksim65/components/Component.kt
index 5635281..eebe2d5 100644
--- a/src/main/kotlin/razorvine/ksim65/components/Component.kt
+++ b/src/main/kotlin/razorvine/ksim65/components/Component.kt
@@ -12,7 +12,14 @@ typealias Address = Int
 abstract class BusComponent {
     lateinit var bus: Bus
 
+    /**
+     * One clock cycle on the bus
+     */
     abstract fun clock()
+
+    /**
+     * Reset all devices on the bus
+     */
     abstract fun reset()
 }
 
@@ -53,4 +60,8 @@ abstract class MemMappedComponent(val startAddress: Address, val endAddress: Add
 abstract class MemoryComponent(startAddress: Address, endAddress: Address) :
     MemMappedComponent(startAddress, endAddress) {
     abstract fun copyOfMem(): Array<UByte>
+
+    init {
+        require(startAddress and 0xff == 0 && endAddress and 0xff == 0xff) {"address range must span complete page(s)"}
+    }
 }
diff --git a/src/main/kotlin/razorvine/ksim65/components/Display.kt b/src/main/kotlin/razorvine/ksim65/components/Display.kt
new file mode 100644
index 0000000..cc98d8f
--- /dev/null
+++ b/src/main/kotlin/razorvine/ksim65/components/Display.kt
@@ -0,0 +1,167 @@
+package razorvine.ksim65.components
+
+import razorvine.ksim65.IHostInterface
+import kotlin.math.min
+
+/**
+ * Text mode and graphics (bitmap) mode display.
+ * Note that the character matrix and pixel matrix are NOT memory mapped,
+ * this display device is controlled by sending char/pixel commands to it.
+ *
+ * Requires a host display to actually view the stuff, obviously.
+ *
+ * reg.    value
+ * ----    -----
+ *  00      char X position
+ *  01      char Y position
+ *  02      r/w character at cX,cY (doesn't change cursor position)
+ *  03      pixel X pos (lsb)
+ *  04      pixel X pos (msb)
+ *  05      pixel Y pos (lsb)
+ *  06      pixel Y pos (msb)
+ *  07      read or write pixel value at pX, pY
+ *  08      cursor X position (r/w)
+ *  09      cursor Y position (r/w)
+ *  0a      read or write character at cursor pos, updates cursor position, scrolls up if necessary
+ *          control characters: 0x08=backspace, 0x09=tab, 0x0a=newline, 0x0c=formfeed(clear screen), 0x0d=carriagereturn
+ *
+ *          TODO: cursor blinking, blink speed (0=off)
+ */
+class Display(
+    startAddress: Address, endAddress: Address,
+    private val host: IHostInterface,
+    private val charWidth: Int,
+    private val charHeight: Int,
+    private val pixelWidth: Int,
+    private val pixelHeight: Int
+) : MemMappedComponent(startAddress, endAddress) {
+
+
+    init {
+        require(endAddress - startAddress + 1 == 11) { "display needs exactly 11 memory bytes" }
+    }
+
+    private var cursorX = 0
+    private var cursorY = 0
+    private var charposX = 0
+    private var charposY = 0
+    private var pixelX = 0
+    private var pixelY = 0
+    private val charMatrix = Array<ShortArray>(charHeight) { ShortArray(charWidth) }    // matrix[y][x] to access
+
+    override fun clock() {
+        // if the system clock is synced to the display refresh,
+        // you *could* add a Vertical Blank interrupt here.
+    }
+
+    override fun reset() {
+        charMatrix.forEach { it.fill(' '.toShort()) }
+        cursorX = 0
+        cursorY = 0
+        charposX = 0
+        charposY = 0
+        pixelX = 0
+        pixelY = 0
+        host.clearScreen()
+    }
+
+    override operator fun get(address: Address): UByte {
+        return when(address-startAddress) {
+            0x02 -> {
+                if(charposY in 0 until charHeight && charposX in 0 until charWidth) {
+                    charMatrix[charposY][charposX]
+                } else 0xff
+            }
+            0x07 -> if(host.getPixel(pixelX, pixelY)) 1 else 0
+            0x08 -> cursorX.toShort()
+            0x09 -> cursorY.toShort()
+            0x0a -> {
+                if(cursorY in 0 until charHeight && cursorX in 0 until charWidth) {
+                    charMatrix[cursorY][cursorX]
+                } else 0xff
+            }
+            else -> return 0xff
+        }
+    }
+
+    override operator fun set(address: Address, data: UByte) {
+        when(address-startAddress) {
+            0x00 -> charposX = data.toInt()
+            0x01 -> charposY = data.toInt()
+            0x02 -> {
+                if(charposY in 0 until charHeight && charposX in 0 until charWidth) {
+                    charMatrix[charposY][charposX] = data
+                    host.setChar(charposX, charposY, data.toChar())
+                }
+            }
+            0x03 -> pixelX = (pixelX and 0xff00) or data.toInt()
+            0x04 -> pixelX = (pixelX and 0x00ff) or (data.toInt() shl 8)
+            0x05 -> pixelY = (pixelY and 0xff00) or data.toInt()
+            0x06 -> pixelY = (pixelY and 0x00ff) or (data.toInt() shl 8)
+            0x07 -> {
+                if(data==0.toShort()) host.clearPixel(pixelX, pixelY)
+                else host.setPixel(pixelX, pixelY)
+            }
+            0x08 -> cursorX = min(data.toInt() and 65535, charWidth-1)
+            0x09 -> cursorY = min(data.toInt() and 65535, charHeight-1)
+            0x0a -> {
+                if(cursorY in 0 until charHeight && cursorX in 0 until charWidth) {
+                    when(data.toInt()) {
+                        0x08 -> {
+                            // backspace
+                            cursorX--
+                            if(cursorX<0) {
+                                if(cursorY>0) {
+                                    cursorY--
+                                    cursorX = charWidth - 1
+                                }
+                            }
+                            charMatrix[cursorY][cursorX] = ' '.toShort()
+                            host.setChar(cursorX, cursorY, ' ')
+                        }
+                        0x09 -> {
+                            // tab
+                            cursorX = (cursorX and 248) + 8
+                            if(cursorX >= charWidth) {
+                                cursorX = 0
+                                cursorDown()
+                            }
+                        }
+                        0x0a -> {
+                            // newline
+                            cursorX = 0
+                            cursorDown()
+                        }
+                        0x0c -> reset()         // clear screen
+                        0x0d -> cursorX = 0     // carriage return
+                        else -> {
+                            // set character on screen
+                            charMatrix[cursorY][cursorX] = data
+                            host.setChar(cursorX, cursorY, data.toChar())
+                            cursorX++
+                            if(cursorX >= charWidth) {
+                                cursorX = 0
+                                cursorDown()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun cursorDown() {
+        cursorY++
+        while(cursorY >= charHeight) {
+            // scroll up 1 line
+            for(y in 0 .. charHeight-2) {
+                charMatrix[y+1].copyInto(charMatrix[y])
+            }
+            for(x in 0 until charWidth) {
+                charMatrix[charHeight-1][x] = ' '.toShort()
+            }
+            cursorY--
+            host.scrollUp()
+        }
+    }
+}
diff --git a/src/main/kotlin/razorvine/ksim65/components/Keyboard.kt b/src/main/kotlin/razorvine/ksim65/components/Keyboard.kt
new file mode 100644
index 0000000..9cc8694
--- /dev/null
+++ b/src/main/kotlin/razorvine/ksim65/components/Keyboard.kt
@@ -0,0 +1,34 @@
+package razorvine.ksim65.components
+
+import razorvine.ksim65.IHostInterface
+
+/**
+ * Simple keyboard for text entry.
+ * The keyboard device itself takes care of decoding the keys,
+ * this device simply produces the actual keys pressed.
+ * There's NO support right now to detect keydown/keyup events or the
+ * state of the shift/control/function keys.
+ *
+ * reg.   value
+ * ----   ---------
+ *  00    character from keyboard, 0 = no character/key pressed
+ */
+class Keyboard(startAddress: Address, endAddress: Address, private val host: IHostInterface) :
+    MemMappedComponent(startAddress, endAddress) {
+
+    init {
+        require(endAddress - startAddress + 1 == 1) { "keyboard needs exactly 1 memory byte" }
+    }
+
+    override fun clock() {}
+    override fun reset() {}
+
+    override operator fun get(address: Address): UByte {
+        return when(address-startAddress) {
+            0x00 -> host.keyboard()?.toShort() ?: 0
+            else -> 0xff
+        }
+    }
+
+    override operator fun set(address: Address, data: UByte) { /* read-only device */ }
+}
diff --git a/src/main/kotlin/razorvine/ksim65/components/Mouse.kt b/src/main/kotlin/razorvine/ksim65/components/Mouse.kt
new file mode 100644
index 0000000..58868af
--- /dev/null
+++ b/src/main/kotlin/razorvine/ksim65/components/Mouse.kt
@@ -0,0 +1,44 @@
+package razorvine.ksim65.components
+
+import razorvine.ksim65.IHostInterface
+
+/**
+ * An analog mouse or paddle input device, with 2 buttons.
+ *
+ * reg.   value
+ * ----   ---------
+ *  00    mouse pixel pos X (lsb)
+ *  01    mouse pixel pos X (msb)
+ *  02    mouse pixel pos Y (lsb)
+ *  03    mouse pixel pos Y (msb)
+ *  04    buttons, bit 0 = left button, bit 1 = right button, bit 2 = middle button
+ */
+class Mouse(startAddress: Address, endAddress: Address, private val host: IHostInterface) :
+    MemMappedComponent(startAddress, endAddress) {
+
+    init {
+        require(endAddress - startAddress + 1 == 5) { "mouse needs exactly 5 memory bytes" }
+    }
+
+    override fun clock() {}
+    override fun reset() {}
+
+    override operator fun get(address: Address): UByte {
+        val mouse = host.mouse()
+        return when (address - startAddress) {
+            0x00 -> (mouse.x and 0xff).toShort()
+            0x01 -> (mouse.x ushr 8).toShort()
+            0x02 -> (mouse.y and 0xff).toShort()
+            0x03 -> (mouse.y ushr 8).toShort()
+            0x04 -> {
+                val b1 = if (mouse.left) 0b00000001 else 0
+                val b2 = if (mouse.right) 0b00000010 else 0
+                val b3 = if (mouse.middle) 0b00000100 else 0
+                return (b1 or b2 or b3).toShort()
+            }
+            else -> 0xff
+        }
+    }
+
+    override operator fun set(address: Address, data: UByte) { /* read-only device */ }
+}
diff --git a/src/main/kotlin/razorvine/ksim65/components/ParallelPort.kt b/src/main/kotlin/razorvine/ksim65/components/ParallelPort.kt
index 3a4e7eb..6918891 100644
--- a/src/main/kotlin/razorvine/ksim65/components/ParallelPort.kt
+++ b/src/main/kotlin/razorvine/ksim65/components/ParallelPort.kt
@@ -3,7 +3,7 @@ package razorvine.ksim65.components
 /**
  * A simple parallel output device (basically, prints bytes as characters to the console)
  *
- * byte   value
+ * reg.   value
  * ----   ---------
  *  00    data (the 8 parallel bits)
  *  01    control latch (set bit 0 to write the data byte)
@@ -22,7 +22,7 @@ class ParallelPort(startAddress: Address, endAddress: Address) : MemMappedCompon
         return if (address == startAddress)
             dataByte
         else
-            0
+            0xff
     }
 
     override operator fun set(address: Address, data: UByte) {
diff --git a/src/main/kotlin/razorvine/ksim65/components/RealTimeClock.kt b/src/main/kotlin/razorvine/ksim65/components/RealTimeClock.kt
index 8691236..8aa5bcd 100644
--- a/src/main/kotlin/razorvine/ksim65/components/RealTimeClock.kt
+++ b/src/main/kotlin/razorvine/ksim65/components/RealTimeClock.kt
@@ -8,7 +8,7 @@ import java.time.LocalTime
  * A real-time time of day clock.
  * (System timers are elsewhere)
  *
- * byte   value
+ * reg.   value
  * ----   ----------
  *  00    year (lsb)
  *  01    year (msb)
@@ -36,28 +36,28 @@ class RealTimeClock(startAddress: Address, endAddress: Address) : MemMappedCompo
 
     override operator fun get(address: Address): UByte {
         return when (address - startAddress) {
-            0 -> {
+            0x00 -> {
                 val year = LocalDate.now().year
                 (year and 255).toShort()
             }
-            1 -> {
+            0x01 -> {
                 val year = LocalDate.now().year
                 (year ushr 8).toShort()
             }
-            2 -> LocalDate.now().monthValue.toShort()
-            3 -> LocalDate.now().dayOfMonth.toShort()
-            4 -> LocalTime.now().hour.toShort()
-            5 -> LocalTime.now().minute.toShort()
-            6 -> LocalTime.now().second.toShort()
-            7 -> {
+            0x02 -> LocalDate.now().monthValue.toShort()
+            0x03 -> LocalDate.now().dayOfMonth.toShort()
+            0x04 -> LocalTime.now().hour.toShort()
+            0x05 -> LocalTime.now().minute.toShort()
+            0x06 -> LocalTime.now().second.toShort()
+            0x07 -> {
                 val ms = LocalTime.now().nano / 1000
                 (ms and 255).toShort()
             }
-            8 -> {
+            0x08 -> {
                 val ms = LocalTime.now().nano / 1000
                 (ms ushr 8).toShort()
             }
-            else -> 0
+            else -> 0xff
         }
     }
 
diff --git a/src/main/kotlin/razorvine/ksim65/components/Timer.kt b/src/main/kotlin/razorvine/ksim65/components/Timer.kt
index 6fb8b51..1ac329c 100644
--- a/src/main/kotlin/razorvine/ksim65/components/Timer.kt
+++ b/src/main/kotlin/razorvine/ksim65/components/Timer.kt
@@ -3,15 +3,14 @@ package razorvine.ksim65.components
 import razorvine.ksim65.Cpu6502
 
 /**
- * A programmable timer. Causes an IRQ or NMI at specified 24-bits intervals.
+ * A programmable timer. Causes an IRQ or NMI at specified 24-bits clock cycle intervals.
  *
- * byte   value
+ * reg.   value
  * ----   --------------
  *  00    control register  bit 0=enable  bit 1=nmi (instead of irq)
  *  01    24 bits interval value, bits 0-7 (lo)
  *  02    24 bits interval value, bits 8-15 (mid)
  *  03    24 bits interval value, bits 16-23  (hi)
- *
  */
 class Timer(startAddress: Address, endAddress: Address, val cpu: Cpu6502) : MemMappedComponent(startAddress, endAddress) {
     private var counter: Int = 0
@@ -51,40 +50,34 @@ class Timer(startAddress: Address, endAddress: Address, val cpu: Cpu6502) : MemM
     }
 
     override operator fun get(address: Address): UByte {
-        when (address - startAddress) {
-            0 -> {
+        return when (address - startAddress) {
+            0x00 -> {
                 var data = 0
                 if (enabled) data = data or 0b00000001
                 if (nmi) data = data or 0b00000010
-                return data.toShort()
+                data.toShort()
             }
-            1 -> {
-                return (counter and 0xff).toShort()
-            }
-            2 -> {
-                return ((counter ushr 8) and 0xff).toShort()
-            }
-            3 -> {
-                return ((counter ushr 16) and 0xff).toShort()
-            }
-            else -> return 0
+            0x01 -> (counter and 0xff).toShort()
+            0x02 -> ((counter ushr 8) and 0xff).toShort()
+            0x03 -> ((counter ushr 16) and 0xff).toShort()
+            else -> 0xff
         }
     }
 
     override operator fun set(address: Address, data: UByte) {
         when (address - startAddress) {
-            0 -> {
+            0x00 -> {
                 val i = data.toInt()
                 enabled = (i and 0b00000001) != 0
                 nmi = (i and 0b00000010) != 0
             }
-            1 -> {
+            0x01 -> {
                 interval = (interval and 0x7fffff00) or data.toInt()
             }
-            2 -> {
+            0x02 -> {
                 interval = (interval and 0x7fff00ff) or (data.toInt() shl 8)
             }
-            3 -> {
+            0x03 -> {
                 interval = (interval and 0x7f00ffff) or (data.toInt() shl 16)
             }
         }
diff --git a/src/main/kotlin/testmain/Sim65Main.kt b/src/main/kotlin/testmain/Sim65Main.kt
deleted file mode 100644
index 223f47f..0000000
--- a/src/main/kotlin/testmain/Sim65Main.kt
+++ /dev/null
@@ -1,75 +0,0 @@
-package testmain
-
-import razorvine.ksim65.Bus
-import razorvine.ksim65.Cpu6502
-import razorvine.ksim65.Version
-import razorvine.ksim65.components.*
-
-
-fun main(args: Array<String>) {
-    println(Version.copyright)
-    startSimulator(args)
-}
-
-
-private fun startSimulator(args: Array<String>) {
-
-    // create a computer system.
-    // note that the order in which components are added to the bus, is important:
-    // it determines the priority of reads and writes.
-    val cpu = Cpu6502(true)
-    val ram = Ram(0, 0xffff)
-    ram[Cpu6502.RESET_vector] = 0x00
-    ram[Cpu6502.RESET_vector + 1] = 0x10
-    ram[Cpu6502.IRQ_vector] = 0x00
-    ram[Cpu6502.IRQ_vector + 1] = 0x20
-    ram[Cpu6502.NMI_vector] = 0x00
-    ram[Cpu6502.NMI_vector + 1] = 0x30
-
-//    // read the RTC and write the date+time to $2000
-//    for(b in listOf(0xa0, 0x00, 0xb9, 0x00, 0xd1, 0x99, 0x00, 0x20, 0xc8, 0xc0, 0x09, 0xd0, 0xf5, 0x00).withIndex()) {
-//        ram[0x1000+b.index] = b.value.toShort()
-//    }
-
-    // set the timer to $22aa00 and enable it on regular irq
-    for(b in listOf(0xa9, 0x00, 0x8d, 0x00, 0xd2, 0xa9, 0x00, 0x8d, 0x01, 0xd2, 0xa9, 0xaa, 0x8d, 0x02,
-            0xd2, 0xa9, 0x22, 0x8d, 0x03, 0xd2, 0xa9, 0x01, 0x8d, 0x00, 0xd2, 0x4c, 0x19, 0x10).withIndex()) {
-        ram[0x1000+b.index] = b.value.toShort()
-    }
-
-
-    // load the irq routine that prints  'irq!' to the parallel port
-    for(b in listOf(0x48, 0xa9, 0x09, 0x8d, 0x00, 0xd0, 0xee, 0x01, 0xd0, 0xa9, 0x12, 0x8d, 0x00, 0xd0,
-            0xee, 0x01, 0xd0, 0xa9, 0x11, 0x8d, 0x00, 0xd0, 0xee, 0x01, 0xd0, 0xa9, 0x21, 0x8d, 0x00, 0xd0,
-            0xee, 0x01, 0xd0, 0x68, 0x40).withIndex()) {
-        ram[0x2000+b.index] = b.value.toShort()
-    }
-
-    val parallel = ParallelPort(0xd000, 0xd001)
-    val clock = RealTimeClock(0xd100, 0xd108)
-    val timer = Timer(0xd200, 0xd203, cpu)
-
-    val bus = Bus()
-    bus.add(cpu)
-    bus.add(parallel)
-    bus.add(clock)
-    bus.add(timer)
-    bus.add(ram)
-    bus.reset()
-
-    cpu.regP.I = false    // enable interrupts
-
-    // TODO
-//    try {
-//        while (true) {
-//            bus.clock()
-//        }
-//    } catch (ix: Cpu6502.InstructionError) {
-//        println("Hmmm... $ix")
-//    }
-
-    ram.hexDump(0x1000, 0x1020)
-    val dis = cpu.disassemble(ram, 0x1000, 0x1020)
-    println(dis.joinToString("\n"))
-    ram.hexDump(0x2000, 0x2008)
-}
diff --git a/src/main/resources/charset/unscii8x16.png b/src/main/resources/charset/unscii8x16.png
new file mode 100644
index 0000000..da5ae79
Binary files /dev/null and b/src/main/resources/charset/unscii8x16.png differ
diff --git a/src/test/kotlin/Test6502CpuBasics.kt b/src/test/kotlin/Test6502CpuBasics.kt
index 082081a..53cacc7 100644
--- a/src/test/kotlin/Test6502CpuBasics.kt
+++ b/src/test/kotlin/Test6502CpuBasics.kt
@@ -48,7 +48,7 @@ class Test6502CpuBasics {
     @Test
     fun testCpuPerformance6502() {
         val cpu = Cpu6502(true)
-        val ram = Ram(0x1000, 0x2000)
+        val ram = Ram(0x1000, 0x1fff)
         // load a simple program that loops a few instructions
         for(b in listOf(0xa9, 0x63, 0xaa, 0x86, 0x22, 0x8e, 0x22, 0x22, 0x91, 0x22, 0x6d, 0x33, 0x33, 0xcd, 0x55, 0x55, 0xd0, 0xee, 0xf0, 0xec).withIndex()) {
             ram[0x1000+b.index] = b.value.toShort()
@@ -79,7 +79,7 @@ class Test6502CpuBasics {
     @Test
     fun testCpuPerformance65C02() {
         val cpu = Cpu65C02(true)
-        val ram = Ram(0x0000, 0x2000)
+        val ram = Ram(0x0000, 0x1fff)
         // load a simple program that loops a few instructions
         for(b in listOf(0xa9, 0x63, 0xaa, 0x86, 0x22, 0x8e, 0x22, 0x22, 0x91, 0x22, 0x6d, 0x33, 0x33, 0xcd, 0x55, 0x55,
             0xff, 0xff, 0x79, 0x9e, 0x56, 0x34, 0xd0, 0xe8, 0xf0, 0xe6).withIndex()) {
diff --git a/src/test/kotlin/TestDisassembler.kt b/src/test/kotlin/TestDisassembler.kt
index 914338e..f97bb9b 100644
--- a/src/test/kotlin/TestDisassembler.kt
+++ b/src/test/kotlin/TestDisassembler.kt
@@ -28,7 +28,7 @@ class TestDisassembler {
     @Test
     fun testDisassembleRockwell65C02() {
         val cpu = Cpu65C02()
-        val memory = Ram(0, 0x1000)
+        val memory = Ram(0, 0x0fff)
         val source = javaClass.classLoader.getResource("disassem_r65c02.bin")!!
         memory.load(source, 0x0200)
         val resultLines = cpu.disassemble(memory, 0x0200, 0x0250)
@@ -73,7 +73,7 @@ ${'$'}0250  00          brk""", result)
     @Test
     fun testDisassembleWDC65C02() {
         val cpu = Cpu65C02()
-        val memory = Ram(0, 0x1000)
+        val memory = Ram(0, 0x0fff)
         val source = javaClass.classLoader.getResource("disassem_wdc65c02.bin")!!
         memory.load(source, 0x200)
         val resultLines = cpu.disassemble(memory, 0x0200, 0x0215)